// Generated from API_TOOL_MANIFEST. Typed source companion; use utilito-client.js directly in browsers.
import type { UtilitoClientFailure, UtilitoClientResult, UtilitoRawOutput, UtilitoResponseModeForTool, UtilitoRunRequest, UtilitoToolId } from './utilito-types';
const MAX_RESPONSE_BYTES = 4_000_000;

async function readBounded(response: Response): Promise<Uint8Array> {
  const reader = response.body?.getReader?.();
  const header = response.headers.get('Content-Length');
  if (header !== null && /^(?:0|[1-9][0-9]*)$/.test(header)) { const declared = Number(header); if (!Number.isSafeInteger(declared) || declared > MAX_RESPONSE_BYTES) { if (reader) try { await reader.cancel(); } catch {} throw new Error('RESPONSE_TOO_LARGE'); } }
  if (!reader) { if ([204, 205, 304].includes(response.status)) return new Uint8Array(); throw new Error('RESPONSE_BOUND_UNAVAILABLE'); }
  const chunks: Uint8Array[] = []; let bytes = 0;
  while (true) {
    const part = await reader.read();
    if (part.done) break;
    bytes += part.value.byteLength;
    if (bytes > MAX_RESPONSE_BYTES) { try { await reader.cancel(); } finally { throw new Error('RESPONSE_TOO_LARGE'); } }
    chunks.push(part.value);
  }
  return concat(chunks, bytes);
}

function failure(response: Response, parsed: any, invalidResponse: boolean): UtilitoClientFailure {
  const source = parsed?.error && typeof parsed.error === 'object' ? parsed.error : parsed?.result?.error;
  const error = source && typeof source === 'object' ? { ...source, code: String(source.code || `HTTP_${response.status}`), message: String(source.message || 'The request failed.'), ...(source.path !== undefined ? { path: String(source.path) } : {}), ...(source.hint !== undefined ? { hint: String(source.hint) } : {}) } : { code: invalidResponse ? 'INVALID_RESPONSE' : `HTTP_${response.status}`, message: invalidResponse ? 'The server returned an empty, malformed, or non-JSON response.' : 'The request failed.' };
  return { ok: false, http_status: response.status, ...(response.headers.get('Retry-After') ? { retry_after: response.headers.get('Retry-After') } : {}), ...(response.headers.get('X-Utilito-Admission') ? { admission: response.headers.get('X-Utilito-Admission') } : {}), ...(response.headers.get('X-RateLimit-Remaining') ? { rate_limit_remaining: response.headers.get('X-RateLimit-Remaining') } : {}), error };
}

function concat(chunks: Uint8Array[], length: number): Uint8Array { const output = new Uint8Array(length); let offset = 0; for (const chunk of chunks) { output.set(chunk, offset); offset += chunk.byteLength; } return output; }
function mediaType(response: Response): string { return (response.headers.get('Content-Type') || 'application/octet-stream').split(';', 1)[0].trim().toLowerCase() || 'application/octet-stream'; }
function extensionFor(type: string): string { return ({ 'application/json':'json', 'text/plain':'txt', 'text/html':'html', 'text/csv':'csv', 'image/png':'png', 'image/svg+xml':'svg', 'application/pdf':'pdf', 'application/octet-stream':'bin' } as Record<string, string>)[type] || 'bin'; }
function parseJson(bytes: Uint8Array): { ok: true; value: unknown } | { ok: false } { if (!bytes.byteLength) return { ok:false }; try { return { ok:true, value:JSON.parse(new TextDecoder('utf-8', { fatal:true }).decode(bytes)) }; } catch { return { ok:false }; } }
function validEnvelope(value: any, mode: 'full' | 'compact', toolId: string): boolean { if (!value || typeof value !== 'object' || Array.isArray(value)) return false; if (mode === 'compact') return typeof value.ok === 'boolean' && Object.prototype.hasOwnProperty.call(value, 'output') && (value.stats === undefined || (!!value.stats && typeof value.stats === 'object' && !Array.isArray(value.stats))) && (value.warnings === undefined || Array.isArray(value.warnings)); return value.success === true && value.tool_id === toolId && Object.prototype.hasOwnProperty.call(value, 'result') && Number.isFinite(value.tokens_saved_estimate) && Number.isFinite(value.processing_time_ms); }
function rawOutput(response: Response, bytes: Uint8Array): UtilitoRawOutput | null { const type=mediaType(response), extension=extensionFor(type); if (type==='application/json' || type.endsWith('+json')) { const parsed=parseJson(bytes); return parsed.ok ? { kind:'json', value:parsed.value, bytes, media_type:type, extension:'json' } : null; } if (type.startsWith('text/') || type==='image/svg+xml') { try { return { kind:'text', value:new TextDecoder('utf-8', { fatal:true }).decode(bytes), bytes, media_type:type, extension }; } catch { return { kind:'binary', bytes, media_type:type, extension }; } } return { kind:'binary', bytes, media_type:type, extension }; }

export async function runTool<T extends UtilitoToolId, M extends UtilitoResponseModeForTool<T> = UtilitoResponseModeForTool<T>>(request: UtilitoRunRequest<T, M>, options: { signal?: AbortSignal } = {}): Promise<UtilitoClientResult<T, M>> {
  if (options.signal?.aborted) throw new DOMException('The request was aborted.', 'AbortError');
  const response = await fetch('https://utilito.dev/api/run', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(request), signal: options.signal, credentials: 'omit' });
  const bytes = await readBounded(response);
  if (request.response_mode === 'output' && response.ok) { const output=rawOutput(response, bytes); return output ? { ok:true, http_status:response.status, output } : failure(response, null, true); }
  const parsed = parseJson(bytes);
  if (!response.ok) return failure(response, parsed.ok ? parsed.value : null, !parsed.ok);
  if (!parsed.ok || !validEnvelope(parsed.value, request.response_mode === 'compact' ? 'compact' : 'full', request.tool_id)) return failure(response, parsed.ok ? parsed.value : null, true);
  return { ok: true, http_status: response.status, body: parsed.value as any };
}