@skyold/provider-adapters 0.1.0-beta.0

package/dist/openai-responses/codec.js

@@ -0,0 +1,1086 @@
+import { parseOpenAiResponsesSseFrames, PROVIDER_STREAM_INVALID } from './sse.js';
+const PROTOCOL_FAMILY = 'openai-responses/v1';
+const RESPONSE_INVALID = 'PROVIDER_RESPONSE_INVALID';
+const MAX_ERROR_BODY_BYTES = 1024 * 1024;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const REQUEST_FIELDS = new Set([
+    'input',
+    'instructions',
+    'tools',
+    'tool_choice',
+    'reasoning',
+    'max_output_tokens',
+    'max_tool_calls',
+    'parallel_tool_calls',
+    'temperature',
+    'top_p',
+    'store',
+    'stream',
+]);
+export const openAiResponsesCodec = {
+    protocolFamily: PROTOCOL_FAMILY,
+    encodeProviderRequest(task, providerModel) {
+        if (task.dispatchProtocolFamily !== PROTOCOL_FAMILY || task.taskKind !== 'chat') {
+            throw new Error('OPENAI_RESPONSES_TASK_UNSUPPORTED');
+        }
+        const body = { model: providerModel };
+        for (const [key, value] of Object.entries(task.input)) {
+            if (key === 'model')
+                continue;
+            if (!REQUEST_FIELDS.has(key))
+                throw new Error('OPENAI_RESPONSES_REQUEST_UNSUPPORTED_FIELD');
+            if (key === 'store' && value !== false)
+                throw new Error('OPENAI_RESPONSES_STORE_UNSUPPORTED');
+            if (key !== 'store' && key !== 'stream')
+                body[key] = value;
+        }
+        if (body['input'] === undefined)
+            throw new Error('OPENAI_RESPONSES_REQUEST_INVALID');
+        body['store'] = false;
+        body['stream'] = task.executionMode === 'stream';
+        return encoder.encode(JSON.stringify(body));
+    },
+    async decodeProviderStart(response) {
+        const responseMetadata = metadata(response);
+        if (response.status < 200 || response.status >= 300) {
+            return failedStart(responseMetadata, response.status, response.body);
+        }
+        if (isAsyncIterable(response.body))
+            return streamStart(response.body, responseMetadata);
+        return syncStart(response.body, responseMetadata);
+    },
+};
+function syncStart(body, responseMetadata) {
+    try {
+        const response = parseResponse(parseJson(decoder.decode(body), RESPONSE_INVALID), RESPONSE_INVALID);
+        const usage = parseUsage(response.usage, RESPONSE_INVALID);
+        const result = toResult(response.output, response.status, usage, response.incompleteReason);
+        const normalizedResponse = {
+            ...response.normalizedResponse,
+            ...(usage ? { usage } : {}),
+        };
+        let terminal;
+        switch (response.status) {
+            case 'completed':
+                terminal = {
+                    status: 'succeeded',
+                    acceptanceState: 'accepted',
+                    retryable: false,
+                    result,
+                    normalizedResponse,
+                    ...(usage ? { usage } : {}),
+                };
+                break;
+            case 'incomplete':
+                if (!response.incompleteReason)
+                    throw new Error(RESPONSE_INVALID);
+                terminal = {
+                    status: 'incomplete',
+                    acceptanceState: 'accepted',
+                    retryable: false,
+                    result,
+                    normalizedResponse,
+                    ...(usage ? { usage } : {}),
+                    incompleteDetails: { reason: response.incompleteReason },
+                };
+                break;
+            case 'failed':
+                if (!response.providerError)
+                    throw new Error(RESPONSE_INVALID);
+                terminal = {
+                    status: 'failed',
+                    acceptanceState: 'accepted',
+                    failureOrigin: 'provider',
+                    failureCode: response.providerError.code,
+                    retryable: false,
+                    result,
+                    normalizedResponse,
+                    ...(usage ? { usage } : {}),
+                    providerError: response.providerError,
+                };
+                break;
+            case 'cancelled':
+                terminal = {
+                    status: 'cancelled',
+                    acceptanceState: 'accepted',
+                    retryable: false,
+                    result,
+                    normalizedResponse,
+                    ...(usage ? { usage } : {}),
+                };
+                break;
+        }
+        return {
+            kind: 'sync',
+            acceptance: { state: 'accepted' },
+            responseMetadata: {
+                ...responseMetadata,
+                ...(response.normalizedResponse.model
+                    ? { observedModel: response.normalizedResponse.model }
+                    : {}),
+            },
+            terminal,
+        };
+    }
+    catch {
+        return invalidSyncStart(responseMetadata);
+    }
+}
+function invalidSyncStart(responseMetadata) {
+    return {
+        kind: 'sync',
+        acceptance: { state: 'accepted' },
+        responseMetadata,
+        terminal: {
+            status: 'failed',
+            acceptanceState: 'accepted',
+            failureOrigin: 'provider',
+            failureCode: RESPONSE_INVALID,
+            retryable: false,
+        },
+    };
+}
+async function failedStart(responseMetadata, status, body) {
+    const rateLimited = status === 429;
+    const errorBody = await collectErrorBody(body);
+    const providerError = errorBody ? tryParseErrorBody(errorBody) : undefined;
+    return {
+        kind: 'sync',
+        acceptance: { state: 'not-accepted' },
+        responseMetadata,
+        terminal: {
+            status: 'failed',
+            acceptanceState: 'not-accepted',
+            failureOrigin: 'provider',
+            failureCode: rateLimited ? 'PROVIDER_RATE_LIMITED' : 'PROVIDER_REQUEST_FAILED',
+            retryable: rateLimited || status >= 500,
+            ...(providerError ? { providerError } : {}),
+        },
+    };
+}
+function streamStart(body, responseMetadata) {
+    let resolveTerminal;
+    let terminalSettled = false;
+    let aborted = false;
+    const terminal = new Promise((resolve) => {
+        resolveTerminal = resolve;
+    });
+    const settle = (outcome) => {
+        if (terminalSettled)
+            return;
+        terminalSettled = true;
+        resolveTerminal(outcome);
+    };
+    const events = (async function* () {
+        let responseId;
+        let previousSequence = -1;
+        let usage;
+        const items = new Map();
+        const itemIndexes = new Map();
+        const completedItems = new Map();
+        try {
+            for await (const frame of parseOpenAiResponsesSseFrames(body)) {
+                if (aborted)
+                    return;
+                const value = record(parseJson(frame.data, PROVIDER_STREAM_INVALID), PROVIDER_STREAM_INVALID);
+                if (value['type'] !== frame.event)
+                    throw new Error(PROVIDER_STREAM_INVALID);
+                const sequenceNumber = requiredSequence(value, previousSequence);
+                previousSequence = sequenceNumber;
+                switch (frame.event) {
+                    case 'response.created': {
+                        if (responseId !== undefined)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        responseId = responseIdFrom(value, PROVIDER_STREAM_INVALID);
+                        yield event('response.started', responseId, sequenceNumber);
+                        break;
+                    }
+                    case 'response.in_progress': {
+                        const id = requireResponseId(value, responseId);
+                        const response = record(value['response'], PROVIDER_STREAM_INVALID);
+                        if (response['status'] !== 'in_progress')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        yield {
+                            ...event('response.in_progress', id, sequenceNumber),
+                            status: 'in_progress',
+                        };
+                        break;
+                    }
+                    case 'response.output_item.added': {
+                        const id = requireResponseId(value, responseId);
+                        const outputIndex = requiredIndex(value['output_index']);
+                        const parsed = parseOutputItem(record(value['item'], PROVIDER_STREAM_INVALID), PROVIDER_STREAM_INVALID);
+                        if (parsed.status !== 'in_progress')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        if (items.has(outputIndex) || itemIndexes.has(parsed.id)) {
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        }
+                        const state = stateFromAdded(parsed, outputIndex);
+                        items.set(outputIndex, state);
+                        itemIndexes.set(parsed.id, outputIndex);
+                        yield {
+                            ...event('output.item.added', id, sequenceNumber),
+                            itemId: parsed.id,
+                            outputIndex,
+                            itemKind: parsed.kind,
+                            item: parsed.normalized,
+                        };
+                        break;
+                    }
+                    case 'response.content_part.added': {
+                        const id = requireResponseId(value, responseId);
+                        const outputIndex = requiredIndex(value['output_index']);
+                        const itemId = requiredString(value['item_id'], PROVIDER_STREAM_INVALID);
+                        const contentIndex = requiredIndex(value['content_index']);
+                        const item = requireMessageItem(items, itemIndexes, outputIndex, itemId);
+                        if (item.contents.has(contentIndex))
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const part = parseMessagePart(record(value['part'], PROVIDER_STREAM_INVALID), PROVIDER_STREAM_INVALID);
+                        if (part.value !== '')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        item.contents.set(contentIndex, {
+                            kind: part.kind,
+                            value: part.value,
+                            streamDone: false,
+                            closed: false,
+                        });
+                        yield {
+                            type: 'output.content_part.added',
+                            eventId: `${id}:${sequenceNumber}`,
+                            sequenceNumber,
+                            responseId: id,
+                            itemId,
+                            outputIndex,
+                            contentIndex,
+                            part: part.normalized,
+                        };
+                        break;
+                    }
+                    case 'response.output_text.delta': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = contentCoordinates(value);
+                        const content = requireContent(items, itemIndexes, indexed, 'text');
+                        if (content.streamDone)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const delta = stringValue(value['delta'], PROVIDER_STREAM_INVALID);
+                        content.value += delta;
+                        yield {
+                            ...event('output.text.delta', id, sequenceNumber),
+                            ...indexed,
+                            delta,
+                        };
+                        break;
+                    }
+                    case 'response.output_text.done': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = contentCoordinates(value);
+                        const content = requireContent(items, itemIndexes, indexed, 'text');
+                        const text = stringValue(value['text'], PROVIDER_STREAM_INVALID);
+                        if (content.streamDone || text !== content.value)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        content.streamDone = true;
+                        yield {
+                            ...event('output.text.completed', id, sequenceNumber),
+                            ...indexed,
+                            text,
+                        };
+                        break;
+                    }
+                    case 'response.refusal.delta': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = contentCoordinates(value);
+                        const content = requireContent(items, itemIndexes, indexed, 'refusal');
+                        if (content.streamDone)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const delta = stringValue(value['delta'], PROVIDER_STREAM_INVALID);
+                        content.value += delta;
+                        yield {
+                            ...event('output.refusal.delta', id, sequenceNumber),
+                            ...indexed,
+                            delta,
+                        };
+                        break;
+                    }
+                    case 'response.refusal.done': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = contentCoordinates(value);
+                        const content = requireContent(items, itemIndexes, indexed, 'refusal');
+                        const refusal = stringValue(value['refusal'], PROVIDER_STREAM_INVALID);
+                        if (content.streamDone || refusal !== content.value)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        content.streamDone = true;
+                        yield {
+                            ...event('output.refusal.completed', id, sequenceNumber),
+                            ...indexed,
+                            refusal,
+                        };
+                        break;
+                    }
+                    case 'response.content_part.done': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = contentCoordinates(value);
+                        const content = requireContent(items, itemIndexes, indexed);
+                        const part = parseMessagePart(record(value['part'], PROVIDER_STREAM_INVALID), PROVIDER_STREAM_INVALID);
+                        if (content.closed ||
+                            !content.streamDone ||
+                            part.kind !== content.kind ||
+                            part.value !== content.value) {
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        }
+                        content.closed = true;
+                        yield {
+                            type: 'output.content_part.completed',
+                            eventId: `${id}:${sequenceNumber}`,
+                            sequenceNumber,
+                            responseId: id,
+                            ...indexed,
+                            part: part.normalized,
+                        };
+                        break;
+                    }
+                    case 'response.function_call_arguments.delta': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = itemCoordinates(value);
+                        const item = requireFunctionItem(items, itemIndexes, indexed.outputIndex, indexed.itemId);
+                        if (item.argumentsDone)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const delta = stringValue(value['delta'], PROVIDER_STREAM_INVALID);
+                        item.arguments += delta;
+                        yield {
+                            ...event('output.tool_call.delta', id, sequenceNumber),
+                            ...indexed,
+                            callId: item.callId,
+                            name: item.name,
+                            argumentsDelta: delta,
+                        };
+                        break;
+                    }
+                    case 'response.function_call_arguments.done': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = itemCoordinates(value);
+                        const item = requireFunctionItem(items, itemIndexes, indexed.outputIndex, indexed.itemId);
+                        const name = requiredString(value['name'], PROVIDER_STREAM_INVALID);
+                        const args = stringValue(value['arguments'], PROVIDER_STREAM_INVALID);
+                        if (item.argumentsDone || name !== item.name || args !== item.arguments) {
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        }
+                        item.argumentsDone = true;
+                        yield {
+                            ...event('output.tool_call.completed', id, sequenceNumber),
+                            ...indexed,
+                            callId: item.callId,
+                            name,
+                            arguments: args,
+                        };
+                        break;
+                    }
+                    case 'response.reasoning_summary_part.added': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = summaryCoordinates(value);
+                        const item = requireReasoningItem(items, itemIndexes, indexed.outputIndex, indexed.itemId);
+                        if (item.summaries.has(indexed.contentIndex))
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const part = parseSummaryPart(record(value['part'], PROVIDER_STREAM_INVALID), PROVIDER_STREAM_INVALID);
+                        if (part.text !== '')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        item.summaries.set(indexed.contentIndex, {
+                            value: part.text,
+                            streamDone: false,
+                            closed: false,
+                        });
+                        yield {
+                            type: 'output.content_part.added',
+                            eventId: `${id}:${sequenceNumber}`,
+                            sequenceNumber,
+                            responseId: id,
+                            ...indexed,
+                            part: { type: 'reasoning_summary', text: part.text },
+                        };
+                        break;
+                    }
+                    case 'response.reasoning_summary_text.delta': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = summaryCoordinates(value);
+                        const summary = requireSummary(items, itemIndexes, indexed);
+                        if (summary.streamDone)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const delta = stringValue(value['delta'], PROVIDER_STREAM_INVALID);
+                        summary.value += delta;
+                        yield {
+                            ...event('output.reasoning_summary.delta', id, sequenceNumber),
+                            ...indexed,
+                            delta,
+                        };
+                        break;
+                    }
+                    case 'response.reasoning_summary_text.done': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = summaryCoordinates(value);
+                        const summary = requireSummary(items, itemIndexes, indexed);
+                        const text = stringValue(value['text'], PROVIDER_STREAM_INVALID);
+                        if (summary.streamDone || text !== summary.value)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        summary.streamDone = true;
+                        yield {
+                            ...event('output.reasoning_summary.completed', id, sequenceNumber),
+                            ...indexed,
+                            text,
+                        };
+                        break;
+                    }
+                    case 'response.reasoning_summary_part.done': {
+                        const id = requireResponseId(value, responseId);
+                        const indexed = summaryCoordinates(value);
+                        const summary = requireSummary(items, itemIndexes, indexed);
+                        const part = parseSummaryPart(record(value['part'], PROVIDER_STREAM_INVALID), PROVIDER_STREAM_INVALID);
+                        if (summary.closed || !summary.streamDone || part.text !== summary.value) {
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        }
+                        summary.closed = true;
+                        yield {
+                            type: 'output.content_part.completed',
+                            eventId: `${id}:${sequenceNumber}`,
+                            sequenceNumber,
+                            responseId: id,
+                            ...indexed,
+                            part: { type: 'reasoning_summary', text: part.text },
+                        };
+                        break;
+                    }
+                    case 'response.output_item.done': {
+                        const id = requireResponseId(value, responseId);
+                        const outputIndex = requiredIndex(value['output_index']);
+                        const parsed = parseOutputItem(record(value['item'], PROVIDER_STREAM_INVALID), PROVIDER_STREAM_INVALID);
+                        const state = requireItem(items, itemIndexes, outputIndex, parsed.id);
+                        if (state.closed ||
+                            (parsed.status !== 'completed' && parsed.status !== 'incomplete') ||
+                            parsed.kind !== state.kind) {
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        }
+                        const normalized = normalizedFromState(state);
+                        if (JSON.stringify(parsed.normalized) !== JSON.stringify(normalized)) {
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        }
+                        state.closed = true;
+                        state.finalStatus = parsed.status;
+                        completedItems.set(outputIndex, normalized);
+                        yield {
+                            ...event('output.item.completed', id, sequenceNumber),
+                            itemId: parsed.id,
+                            outputIndex,
+                            itemKind: parsed.kind,
+                            status: parsed.status,
+                            item: normalized,
+                        };
+                        break;
+                    }
+                    case 'response.completed': {
+                        const id = requireResponseId(value, responseId);
+                        assertItemStatuses(items, new Set(['completed']));
+                        const response = record(value['response'], PROVIDER_STREAM_INVALID);
+                        if (response['status'] !== 'completed')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        usage = parseUsage(response['usage'], PROVIDER_STREAM_INVALID) ?? usage;
+                        const terminalOutcome = {
+                            status: 'succeeded',
+                            acceptanceState: 'accepted',
+                            retryable: false,
+                            result: toResult(sortedItems(completedItems), 'completed', usage),
+                            ...(usage ? { usage } : {}),
+                        };
+                        settle(terminalOutcome);
+                        yield {
+                            ...event('response.completed', id, sequenceNumber),
+                            ...(usage ? { usage } : {}),
+                        };
+                        return;
+                    }
+                    case 'response.incomplete': {
+                        const id = requireResponseId(value, responseId);
+                        assertItemStatuses(items, new Set(['completed', 'incomplete']));
+                        const response = record(value['response'], PROVIDER_STREAM_INVALID);
+                        if (response['status'] !== 'incomplete')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const reason = incompleteReason(response, PROVIDER_STREAM_INVALID);
+                        usage = parseUsage(response['usage'], PROVIDER_STREAM_INVALID) ?? usage;
+                        const terminalOutcome = {
+                            status: 'incomplete',
+                            acceptanceState: 'accepted',
+                            retryable: false,
+                            result: toResult(sortedItems(completedItems), 'incomplete', usage, reason),
+                            ...(usage ? { usage } : {}),
+                            incompleteDetails: { reason },
+                        };
+                        settle(terminalOutcome);
+                        yield {
+                            ...event('response.incomplete', id, sequenceNumber),
+                            reason,
+                            status: 'incomplete',
+                            incompleteDetails: { reason },
+                            ...(usage ? { usage } : {}),
+                        };
+                        return;
+                    }
+                    case 'response.failed': {
+                        const id = requireResponseId(value, responseId);
+                        const response = record(value['response'], PROVIDER_STREAM_INVALID);
+                        if (response['status'] !== 'failed')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        const providerError = parseProviderError(response['error'], PROVIDER_STREAM_INVALID);
+                        if (!providerError)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        usage = parseUsage(response['usage'], PROVIDER_STREAM_INVALID) ?? usage;
+                        settle(providerFailure(providerError, usage));
+                        yield failureEvent(id, sequenceNumber, providerError, usage);
+                        return;
+                    }
+                    case 'response.cancelled': {
+                        const id = requireResponseId(value, responseId);
+                        const response = record(value['response'], PROVIDER_STREAM_INVALID);
+                        if (response['status'] !== 'cancelled')
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        usage = parseUsage(response['usage'], PROVIDER_STREAM_INVALID) ?? usage;
+                        const terminalOutcome = {
+                            status: 'cancelled',
+                            acceptanceState: 'accepted',
+                            retryable: false,
+                            result: toResult(sortedItems(completedItems), 'cancelled', usage),
+                            ...(usage ? { usage } : {}),
+                        };
+                        settle(terminalOutcome);
+                        yield {
+                            ...event('response.cancelled', id, sequenceNumber),
+                            status: 'cancelled',
+                            ...(usage ? { usage } : {}),
+                        };
+                        return;
+                    }
+                    case 'error': {
+                        const providerError = parseProviderError(value, PROVIDER_STREAM_INVALID);
+                        if (!providerError)
+                            throw new Error(PROVIDER_STREAM_INVALID);
+                        settle(providerFailure(providerError));
+                        if (responseId)
+                            yield failureEvent(responseId, sequenceNumber, providerError);
+                        return;
+                    }
+                    default:
+                        throw new Error(PROVIDER_STREAM_INVALID);
+                }
+            }
+            throw new Error(PROVIDER_STREAM_INVALID);
+        }
+        catch {
+            if (aborted)
+                return;
+            settle({
+                status: 'failed',
+                acceptanceState: 'accepted',
+                failureOrigin: 'provider',
+                failureCode: RESPONSE_INVALID,
+                retryable: false,
+            });
+            throw new Error(PROVIDER_STREAM_INVALID);
+        }
+        finally {
+            if (!terminalSettled) {
+                settle({ status: 'cancelled', acceptanceState: 'accepted', retryable: false });
+            }
+        }
+    })();
+    return {
+        kind: 'stream',
+        acceptance: { state: 'accepted' },
+        responseMetadata,
+        events,
+        terminal,
+        abort: () => {
+            aborted = true;
+            settle({ status: 'cancelled', acceptanceState: 'accepted', retryable: false });
+        },
+    };
+}
+function parseResponse(value, error) {
+    const response = record(value, error);
+    const output = Array.isArray(response['output']) ? response['output'] : undefined;
+    if (!output)
+        throw new Error(error);
+    const status = providerStatus(response['status'], error);
+    const providerError = parseProviderError(response['error'], error);
+    const reason = status === 'incomplete' ? incompleteReason(response, error) : undefined;
+    const parsedOutput = output.map((item) => parseOutputItem(record(item, error), error));
+    if (response['object'] !== undefined && response['object'] !== 'response')
+        throw new Error(error);
+    const model = optionalString(response['model'], error);
+    if (response['store'] !== undefined && response['store'] !== false)
+        throw new Error(error);
+    return {
+        id: requiredString(response['id'], error),
+        status,
+        output: parsedOutput.map((item) => item.normalized),
+        normalizedResponse: {
+            protocolFamily: PROTOCOL_FAMILY,
+            id: requiredString(response['id'], error),
+            object: 'response',
+            status,
+            ...(model ? { model } : {}),
+            store: false,
+            output: parsedOutput.map((item) => item.normalizedResponse),
+            ...(reason ? { incompleteDetails: { reason } } : {}),
+            ...(providerError ? { error: providerError } : {}),
+        },
+        ...(response['usage'] === undefined || response['usage'] === null
+            ? {}
+            : { usage: response['usage'] }),
+        ...(providerError ? { providerError } : {}),
+        ...(reason ? { incompleteReason: reason } : {}),
+    };
+}
+function parseOutputItem(value, error) {
+    const id = requiredString(value['id'], error);
+    const status = outputItemStatus(value['status'], error);
+    if (value['type'] === 'message') {
+        const content = Array.isArray(value['content']) ? value['content'] : undefined;
+        if (!content)
+            throw new Error(error);
+        const parts = content.map((part) => parseMessagePart(record(part, error), error));
+        const role = optionalString(value['role'], error);
+        if (role !== undefined && role !== 'assistant')
+            throw new Error(error);
+        return {
+            id,
+            kind: 'message',
+            status,
+            normalized: {
+                type: 'message',
+                content: parts.map((part) => part.normalized),
+            },
+            normalizedResponse: {
+                id,
+                type: 'message',
+                status,
+                ...(role === 'assistant' ? { role } : {}),
+                content: parts.map((part) => part.normalizedResponse),
+            },
+        };
+    }
+    if (value['type'] === 'function_call') {
+        return {
+            id,
+            kind: 'function_call',
+            status,
+            normalized: {
+                type: 'function_call',
+                callId: requiredString(value['call_id'], error),
+                name: requiredString(value['name'], error),
+                arguments: stringValue(value['arguments'], error),
+            },
+            normalizedResponse: {
+                id,
+                type: 'function_call',
+                status,
+                callId: requiredString(value['call_id'], error),
+                name: requiredString(value['name'], error),
+                arguments: stringValue(value['arguments'], error),
+            },
+        };
+    }
+    if (value['type'] === 'reasoning') {
+        const summary = Array.isArray(value['summary']) ? value['summary'] : undefined;
+        if (!summary)
+            throw new Error(error);
+        const parts = summary.map((part) => parseSummaryPart(record(part, error), error));
+        return {
+            id,
+            kind: 'reasoning',
+            status,
+            normalized: {
+                type: 'message',
+                content: parts.map((part) => ({
+                    type: 'reasoning_summary',
+                    text: part.text,
+                })),
+            },
+            normalizedResponse: { id, type: 'reasoning', status, summary: parts },
+        };
+    }
+    throw new Error(error);
+}
+function parseMessagePart(value, error) {
+    if (value['type'] === 'output_text') {
+        const text = stringValue(value['text'], error);
+        return {
+            kind: 'text',
+            value: text,
+            normalized: { type: 'text', text },
+            normalizedResponse: { type: 'output_text', text },
+        };
+    }
+    if (value['type'] === 'refusal') {
+        const refusal = stringValue(value['refusal'], error);
+        return {
+            kind: 'refusal',
+            value: refusal,
+            normalized: { type: 'refusal', text: refusal },
+            normalizedResponse: { type: 'refusal', refusal },
+        };
+    }
+    throw new Error(error);
+}
+function parseSummaryPart(value, error) {
+    if (value['type'] !== 'summary_text')
+        throw new Error(error);
+    return { type: 'summary_text', text: stringValue(value['text'], error) };
+}
+function stateFromAdded(parsed, outputIndex) {
+    if (parsed.kind === 'function_call') {
+        if (parsed.normalized.type !== 'function_call' || parsed.normalized.arguments !== '') {
+            throw new Error(PROVIDER_STREAM_INVALID);
+        }
+        return {
+            kind: 'function_call',
+            outputIndex,
+            itemId: parsed.id,
+            callId: parsed.normalized.callId,
+            name: parsed.normalized.name,
+            arguments: '',
+            argumentsDone: false,
+            closed: false,
+        };
+    }
+    if (parsed.normalized.type !== 'message' || parsed.normalized.content.length !== 0) {
+        throw new Error(PROVIDER_STREAM_INVALID);
+    }
+    if (parsed.kind === 'message') {
+        return {
+            kind: 'message',
+            outputIndex,
+            itemId: parsed.id,
+            contents: new Map(),
+            closed: false,
+        };
+    }
+    return {
+        kind: 'reasoning',
+        outputIndex,
+        itemId: parsed.id,
+        summaries: new Map(),
+        closed: false,
+    };
+}
+function requireItem(items, itemIndexes, outputIndex, itemId) {
+    const item = items.get(outputIndex);
+    if (!item || item.closed || item.itemId !== itemId || itemIndexes.get(itemId) !== outputIndex) {
+        throw new Error(PROVIDER_STREAM_INVALID);
+    }
+    return item;
+}
+function requireMessageItem(items, itemIndexes, outputIndex, itemId) {
+    const item = requireItem(items, itemIndexes, outputIndex, itemId);
+    if (item.kind !== 'message')
+        throw new Error(PROVIDER_STREAM_INVALID);
+    return item;
+}
+function requireFunctionItem(items, itemIndexes, outputIndex, itemId) {
+    const item = requireItem(items, itemIndexes, outputIndex, itemId);
+    if (item.kind !== 'function_call')
+        throw new Error(PROVIDER_STREAM_INVALID);
+    return item;
+}
+function requireReasoningItem(items, itemIndexes, outputIndex, itemId) {
+    const item = requireItem(items, itemIndexes, outputIndex, itemId);
+    if (item.kind !== 'reasoning')
+        throw new Error(PROVIDER_STREAM_INVALID);
+    return item;
+}
+function requireContent(items, itemIndexes, indexed, kind) {
+    const item = requireMessageItem(items, itemIndexes, indexed.outputIndex, indexed.itemId);
+    const content = item.contents.get(indexed.contentIndex);
+    if (!content || content.closed || (kind && content.kind !== kind)) {
+        throw new Error(PROVIDER_STREAM_INVALID);
+    }
+    return content;
+}
+function requireSummary(items, itemIndexes, indexed) {
+    const item = requireReasoningItem(items, itemIndexes, indexed.outputIndex, indexed.itemId);
+    const summary = item.summaries.get(indexed.contentIndex);
+    if (!summary || summary.closed)
+        throw new Error(PROVIDER_STREAM_INVALID);
+    return summary;
+}
+function normalizedFromState(state) {
+    if (state.kind === 'function_call') {
+        if (!state.argumentsDone)
+            throw new Error(PROVIDER_STREAM_INVALID);
+        return {
+            type: 'function_call',
+            callId: state.callId,
+            name: state.name,
+            arguments: state.arguments,
+        };
+    }
+    if (state.kind === 'message') {
+        const content = [...state.contents.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([, part]) => {
+            if (!part.closed)
+                throw new Error(PROVIDER_STREAM_INVALID);
+            return part.kind === 'text'
+                ? { type: 'text', text: part.value }
+                : { type: 'refusal', text: part.value };
+        });
+        return { type: 'message', content };
+    }
+    const content = [...state.summaries.entries()]
+        .sort(([left], [right]) => left - right)
+        .map(([, part]) => {
+        if (!part.closed)
+            throw new Error(PROVIDER_STREAM_INVALID);
+        return { type: 'reasoning_summary', text: part.value };
+    });
+    return { type: 'message', content };
+}
+function assertItemStatuses(items, allowedStatuses) {
+    if ([...items.values()].some((item) => !item.closed || !item.finalStatus || !allowedStatuses.has(item.finalStatus))) {
+        throw new Error(PROVIDER_STREAM_INVALID);
+    }
+}
+function sortedItems(items) {
+    return [...items.entries()].sort(([left], [right]) => left - right).map(([, item]) => item);
+}
+function itemCoordinates(value) {
+    return {
+        itemId: requiredString(value['item_id'], PROVIDER_STREAM_INVALID),
+        outputIndex: requiredIndex(value['output_index']),
+    };
+}
+function contentCoordinates(value) {
+    return { ...itemCoordinates(value), contentIndex: requiredIndex(value['content_index']) };
+}
+function summaryCoordinates(value) {
+    return { ...itemCoordinates(value), contentIndex: requiredIndex(value['summary_index']) };
+}
+function providerFailure(providerError, usage) {
+    return {
+        status: 'failed',
+        acceptanceState: 'accepted',
+        failureOrigin: 'provider',
+        failureCode: providerError.code,
+        retryable: false,
+        providerError,
+        ...(usage ? { usage } : {}),
+    };
+}
+function failureEvent(responseId, sequenceNumber, providerError, usage) {
+    return {
+        ...event('response.failed', responseId, sequenceNumber),
+        status: 'failed',
+        error: { code: providerError.code, category: 'provider', retryable: false },
+        providerError,
+        ...(usage ? { usage } : {}),
+    };
+}
+function toResult(output, status, usage, incomplete) {
+    const items = [];
+    for (const item of output) {
+        if (item.type === 'function_call')
+            items.push(item);
+        else {
+            for (const part of item.content) {
+                if (part.type === 'text')
+                    items.push({ type: 'text', text: part.text });
+                if (part.type === 'refusal')
+                    items.push({ type: 'refusal', text: part.text });
+            }
+        }
+    }
+    return {
+        taskKind: 'chat',
+        output: {
+            items,
+            finishReason: status,
+            ...(incomplete ? { incompleteReason: incomplete } : {}),
+        },
+        ...(usage ? { usage } : {}),
+    };
+}
+function parseUsage(value, error) {
+    if (value === undefined || value === null)
+        return undefined;
+    const usage = record(value, error);
+    const inputTokens = optionalNumber(usage['input_tokens'], error);
+    const outputTokens = optionalNumber(usage['output_tokens'], error);
+    const totalTokens = optionalNumber(usage['total_tokens'], error);
+    const inputDetails = usage['input_tokens_details'] === undefined || usage['input_tokens_details'] === null
+        ? undefined
+        : record(usage['input_tokens_details'], error);
+    const outputDetails = usage['output_tokens_details'] === undefined || usage['output_tokens_details'] === null
+        ? undefined
+        : record(usage['output_tokens_details'], error);
+    const cachedInputTokens = inputDetails
+        ? optionalNumber(inputDetails['cached_tokens'], error)
+        : undefined;
+    const reasoningOutputTokens = outputDetails
+        ? optionalNumber(outputDetails['reasoning_tokens'], error)
+        : undefined;
+    return {
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(totalTokens === undefined ? {} : { totalTokens }),
+        ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }),
+        ...(reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens }),
+        ...(inputDetails
+            ? {
+                inputTokenDetails: {
+                    ...(cachedInputTokens === undefined ? {} : { cachedTokens: cachedInputTokens }),
+                },
+            }
+            : {}),
+        ...(outputDetails
+            ? {
+                outputTokenDetails: {
+                    ...(reasoningOutputTokens === undefined
+                        ? {}
+                        : { reasoningTokens: reasoningOutputTokens }),
+                },
+            }
+            : {}),
+        estimated: false,
+    };
+}
+function parseProviderError(value, error) {
+    if (value === undefined || value === null)
+        return undefined;
+    const providerError = record(value, error);
+    const code = requiredString(providerError['code'], error);
+    const message = providerError['message'];
+    if (message !== undefined && message !== null && typeof message !== 'string') {
+        throw new Error(error);
+    }
+    return { code, ...(typeof message === 'string' ? { message } : {}) };
+}
+function tryParseErrorBody(body) {
+    try {
+        const root = record(parseJson(decoder.decode(body), RESPONSE_INVALID), RESPONSE_INVALID);
+        return parseProviderError(root['error'], RESPONSE_INVALID);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function collectErrorBody(body) {
+    if (body instanceof Uint8Array)
+        return body;
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of body) {
+        length += chunk.byteLength;
+        if (length > MAX_ERROR_BODY_BYTES)
+            return undefined;
+        chunks.push(chunk);
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return collected;
+}
+function incompleteReason(response, error) {
+    const details = record(response['incomplete_details'], error);
+    return requiredString(details['reason'], error);
+}
+function providerStatus(value, error) {
+    if (value === 'completed' ||
+        value === 'incomplete' ||
+        value === 'failed' ||
+        value === 'cancelled') {
+        return value;
+    }
+    throw new Error(error);
+}
+function outputItemStatus(value, error) {
+    if (value === 'in_progress' || value === 'completed' || value === 'incomplete')
+        return value;
+    throw new Error(error);
+}
+function event(type, responseId, sequenceNumber) {
+    return {
+        type,
+        eventId: `${responseId}:${sequenceNumber}`,
+        responseId,
+        sequenceNumber,
+    };
+}
+function responseIdFrom(value, error) {
+    return requiredString(record(value['response'], error)['id'], error);
+}
+function requireResponseId(value, responseId) {
+    if (!responseId)
+        throw new Error(PROVIDER_STREAM_INVALID);
+    if (value['response'] !== undefined &&
+        responseIdFrom(value, PROVIDER_STREAM_INVALID) !== responseId) {
+        throw new Error(PROVIDER_STREAM_INVALID);
+    }
+    return responseId;
+}
+function requiredSequence(value, previous) {
+    const sequence = requiredIndex(value['sequence_number']);
+    if (sequence <= previous)
+        throw new Error(PROVIDER_STREAM_INVALID);
+    return sequence;
+}
+function requiredIndex(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new Error(PROVIDER_STREAM_INVALID);
+    return value;
+}
+function requiredString(value, error) {
+    if (typeof value !== 'string' || !value)
+        throw new Error(error);
+    return value;
+}
+function optionalString(value, error) {
+    if (value === undefined || value === null)
+        return undefined;
+    return requiredString(value, error);
+}
+function stringValue(value, error) {
+    if (typeof value !== 'string')
+        throw new Error(error);
+    return value;
+}
+function optionalNumber(value, error) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new Error(error);
+    return value;
+}
+function metadata(response) {
+    const providerRequestId = response.headers['x-request-id'] ?? response.headers['request-id'];
+    return {
+        headersReceived: true,
+        statusCode: response.status,
+        ...(providerRequestId ? { providerRequestId } : {}),
+    };
+}
+function parseJson(value, error) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error(error);
+    }
+}
+function record(value, error) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(error);
+    return value;
+}
+function isAsyncIterable(value) {
+    return typeof value === 'object' && value !== null && Symbol.asyncIterator in value;
+}
+//# sourceMappingURL=codec.js.map