@ank1015/agents-provider-openai 0.1.0

package/dist/adapter.js

@@ -0,0 +1,697 @@
+import OpenAI from 'openai';
+import { createEventStream } from '@ank1015/agents-contracts';
+import { OPENAI_PROVIDER, getOpenAIModel, openAIProviderConfigSchema, } from '@ank1015/agents-provider-openai-spec';
+import { getOpenAIErrorDetails, isAbortError } from './errors.js';
+import { buildOpenAIResponseParams } from './mapping.js';
+export class OpenAIProviderAdapter {
+    provider = OPENAI_PROVIDER;
+    #config;
+    #client;
+    #createMessageId;
+    #now;
+    #resolveModel;
+    constructor(config, deps = {}) {
+        this.#config = openAIProviderConfigSchema.parse(config);
+        this.#client =
+            deps.client ?? deps.createClient?.(this.#config) ?? createOpenAIClient(this.#config);
+        this.#createMessageId = deps.createMessageId ?? createDefaultMessageId;
+        this.#now = deps.now ?? Date.now;
+        this.#resolveModel = deps.resolveModel ?? getOpenAIModel;
+    }
+    stream(request) {
+        const stream = createEventStream();
+        void this.#produce(request, stream);
+        return stream;
+    }
+    async #produce(request, stream) {
+        const model = this.#resolveModel(request.modelId);
+        if (!model) {
+            const message = this.#buildUnknownModelMessage(request);
+            stream.push({ type: 'error', reason: 'error', message });
+            stream.end(message);
+            return;
+        }
+        const state = {
+            request,
+            model,
+            stream,
+            startedAt: this.#now(),
+            content: [],
+            statesByOutputIndex: new Map(),
+            statesByItemId: new Map(),
+            sawRefusal: false,
+        };
+        try {
+            const params = buildOpenAIResponseParams(request, model);
+            const requestOptions = request.signal ? { signal: request.signal } : undefined;
+            const openAIStream = await this.#client.responses.create(params, requestOptions);
+            stream.push({ type: 'start' });
+            for await (const event of openAIStream) {
+                handleStreamEvent(state, event);
+            }
+            if (request.signal?.aborted) {
+                const message = this.#buildAbortedMessage(state);
+                stream.push({ type: 'aborted', reason: 'aborted', message });
+                stream.end(message);
+                return;
+            }
+            closeOpenBlocks(state);
+            if (!state.finalResponse) {
+                throw new Error('OpenAI stream ended without a final response.');
+            }
+            const message = this.#buildSuccessfulMessage(state);
+            stream.push({ type: 'done', reason: message.stopReason, message });
+            stream.end(message);
+        }
+        catch (error) {
+            closeOpenBlocks(state, { allowInvalidToolJson: true });
+            if (request.signal?.aborted || isAbortError(error)) {
+                const message = this.#buildAbortedMessage(state);
+                stream.push({ type: 'aborted', reason: 'aborted', message });
+                stream.end(message);
+                return;
+            }
+            const message = this.#buildFailedMessage(state, error);
+            stream.push({ type: 'error', reason: 'error', message });
+            stream.end(message);
+        }
+    }
+    #buildSuccessfulMessage(state) {
+        const finalResponse = state.finalResponse;
+        if (!finalResponse) {
+            throw new Error('Cannot build a successful OpenAI message without a response.');
+        }
+        hydrateContentFromResponse(state, finalResponse);
+        return {
+            role: 'assistant',
+            id: this.#createMessageId(),
+            model: modelRef(state),
+            usage: usageFromResponse(finalResponse, state.model),
+            duration: this.#now() - state.startedAt,
+            nativeMessage: finalResponse,
+            content: state.content,
+            timestamp: this.#now(),
+            stopReason: mapDoneStopReason(finalResponse, state.content, state.sawRefusal),
+        };
+    }
+    #buildFailedMessage(state, error) {
+        const message = {
+            role: 'assistant',
+            id: this.#createMessageId(),
+            model: modelRef(state),
+            usage: state.finalResponse ? usageFromResponse(state.finalResponse, state.model) : undefined,
+            duration: this.#now() - state.startedAt,
+            content: state.content,
+            timestamp: this.#now(),
+            stopReason: 'error',
+            error: getOpenAIErrorDetails(error),
+        };
+        if (state.finalResponse) {
+            message.nativeMessage = state.finalResponse;
+        }
+        return message;
+    }
+    #buildAbortedMessage(state) {
+        const message = {
+            role: 'assistant',
+            id: this.#createMessageId(),
+            model: modelRef(state),
+            usage: state.finalResponse ? usageFromResponse(state.finalResponse, state.model) : undefined,
+            duration: this.#now() - state.startedAt,
+            content: state.content,
+            timestamp: this.#now(),
+            stopReason: 'aborted',
+        };
+        if (state.finalResponse) {
+            message.nativeMessage = state.finalResponse;
+        }
+        return message;
+    }
+    #buildUnknownModelMessage(request) {
+        return {
+            role: 'assistant',
+            id: this.#createMessageId(),
+            model: { provider: OPENAI_PROVIDER, id: request.modelId },
+            duration: 0,
+            content: [],
+            timestamp: this.#now(),
+            stopReason: 'error',
+            error: {
+                message: `Model "${request.modelId}" is not a known OpenAI model.`,
+                canRetry: false,
+            },
+        };
+    }
+}
+export class OpenAIProviderAdapterFactory {
+    provider = OPENAI_PROVIDER;
+    #deps;
+    constructor(deps = {}) {
+        this.#deps = deps;
+    }
+    create(config) {
+        return new OpenAIProviderAdapter(config, this.#deps);
+    }
+}
+export function createOpenAIProviderAdapter(config, deps) {
+    return new OpenAIProviderAdapter(config, deps);
+}
+export function createOpenAIProviderAdapterFactory(deps) {
+    return new OpenAIProviderAdapterFactory(deps);
+}
+function createOpenAIClient(config) {
+    return new OpenAI({
+        apiKey: resolveSecret(config.apiKey),
+        baseURL: config.baseUrl,
+        defaultHeaders: config.headers,
+        organization: config.organization,
+        project: config.project,
+    });
+}
+function resolveSecret(secret) {
+    if (secret.type === 'value') {
+        return secret.value;
+    }
+    return resolveEnvSecret(secret.name);
+}
+function resolveEnvSecret(name) {
+    const processLike = globalThis.process;
+    const value = processLike?.env?.[name];
+    if (!value) {
+        throw new Error(`OpenAI API key environment variable "${name}" is not set.`);
+    }
+    return value;
+}
+function handleStreamEvent(state, event) {
+    switch (event.type) {
+        case 'response.output_item.added':
+            handleOutputItemAdded(state, event.output_index, event.item);
+            break;
+        case 'response.content_part.added':
+            if (event.part.type === 'refusal') {
+                state.sawRefusal = true;
+            }
+            if (event.part.type === 'output_text' || event.part.type === 'refusal') {
+                ensureResponseBlock(state, event.output_index, event.item_id);
+            }
+            break;
+        case 'response.output_text.delta':
+            appendTextDelta(state, event.output_index, event.item_id, event.delta, false);
+            break;
+        case 'response.output_text.done':
+            setTextContent(state, event.output_index, event.item_id, event.text, false);
+            break;
+        case 'response.refusal.delta':
+            state.sawRefusal = true;
+            appendTextDelta(state, event.output_index, event.item_id, event.delta, true);
+            break;
+        case 'response.refusal.done':
+            state.sawRefusal = true;
+            setTextContent(state, event.output_index, event.item_id, event.refusal, true);
+            break;
+        case 'response.reasoning_summary_text.delta':
+        case 'response.reasoning_text.delta':
+            appendThinkingDelta(state, event.output_index, event.item_id, event.delta);
+            break;
+        case 'response.reasoning_summary_text.done':
+        case 'response.reasoning_text.done':
+            setThinkingText(state, event.output_index, event.item_id, event.text);
+            break;
+        case 'response.function_call_arguments.delta':
+            appendFunctionCallDelta(state, event.output_index, event.item_id, event.delta);
+            break;
+        case 'response.function_call_arguments.done':
+            setFunctionCallArguments(state, event.output_index, event.item_id, event.arguments);
+            break;
+        case 'response.custom_tool_call_input.delta':
+            appendCustomToolCallDelta(state, event.output_index, event.item_id, event.delta);
+            break;
+        case 'response.custom_tool_call_input.done':
+            setCustomToolCallInput(state, event.output_index, event.item_id, event.input);
+            break;
+        case 'response.output_item.done':
+            handleOutputItemDone(state, event.output_index, event.item);
+            break;
+        case 'response.completed':
+        case 'response.incomplete':
+            state.finalResponse = event.response;
+            break;
+        case 'response.failed':
+            state.finalResponse = event.response;
+            throw Object.assign(new Error(event.response.error?.message ?? 'OpenAI response failed.'), {
+                code: event.response.error?.code,
+            });
+        case 'error':
+            throw new Error(event.message);
+        default:
+            break;
+    }
+}
+function handleOutputItemAdded(state, outputIndex, item) {
+    switch (item.type) {
+        case 'message':
+            ensureResponseBlock(state, outputIndex, item.id);
+            break;
+        case 'reasoning':
+            ensureThinkingBlock(state, outputIndex, item.id);
+            break;
+        case 'function_call':
+            ensureFunctionCallBlock(state, outputIndex, item);
+            break;
+        case 'custom_tool_call':
+            ensureCustomToolCallBlock(state, outputIndex, item);
+            break;
+        default:
+            break;
+    }
+}
+function handleOutputItemDone(state, outputIndex, item) {
+    switch (item.type) {
+        case 'message':
+            finishResponseBlock(state, outputIndex, item);
+            break;
+        case 'reasoning':
+            finishThinkingBlock(state, outputIndex, item);
+            break;
+        case 'function_call':
+            finishFunctionCallBlock(state, outputIndex, item);
+            break;
+        case 'custom_tool_call':
+            finishCustomToolCallBlock(state, outputIndex, item);
+            break;
+        default:
+            break;
+    }
+}
+function ensureResponseBlock(state, outputIndex, itemId) {
+    const existing = state.statesByOutputIndex.get(outputIndex);
+    if (existing?.type === 'response') {
+        bindItemId(state, existing, itemId);
+        return existing;
+    }
+    const content = {
+        type: 'response',
+        response: {
+            type: 'text',
+            content: '',
+        },
+    };
+    const block = {
+        type: 'response',
+        contentIndex: state.content.push(content) - 1,
+        itemId,
+        content,
+        ended: false,
+        refusal: false,
+    };
+    registerState(state, outputIndex, block);
+    state.stream.push({ type: 'text_start', contentIndex: block.contentIndex });
+    return block;
+}
+function ensureThinkingBlock(state, outputIndex, itemId) {
+    const existing = state.statesByOutputIndex.get(outputIndex);
+    if (existing?.type === 'thinking') {
+        bindItemId(state, existing, itemId);
+        return existing;
+    }
+    const content = {
+        type: 'thinking',
+        thinkingText: '',
+    };
+    const block = {
+        type: 'thinking',
+        contentIndex: state.content.push(content) - 1,
+        itemId,
+        content,
+        ended: false,
+    };
+    registerState(state, outputIndex, block);
+    state.stream.push({ type: 'thinking_start', contentIndex: block.contentIndex });
+    return block;
+}
+function ensureFunctionCallBlock(state, outputIndex, item) {
+    const existing = state.statesByOutputIndex.get(outputIndex);
+    if (existing?.type === 'function_call') {
+        bindItemId(state, existing, item.id);
+        return existing;
+    }
+    const toolCall = {
+        type: 'toolCall',
+        toolCallId: item.call_id,
+        name: item.name,
+        arguments: parsePartialJsonObject(item.arguments),
+    };
+    const block = {
+        type: 'function_call',
+        contentIndex: state.content.push(toolCall) - 1,
+        itemId: item.id,
+        name: item.name,
+        partialJson: item.arguments,
+        toolCallId: item.call_id,
+        ended: false,
+    };
+    registerState(state, outputIndex, block);
+    state.stream.push({
+        type: 'toolcall_start',
+        contentIndex: block.contentIndex,
+        toolCallId: block.toolCallId,
+        name: block.name,
+    });
+    return block;
+}
+function ensureCustomToolCallBlock(state, outputIndex, item) {
+    const existing = state.statesByOutputIndex.get(outputIndex);
+    if (existing?.type === 'custom_tool_call') {
+        bindItemId(state, existing, item.id);
+        return existing;
+    }
+    const toolCall = {
+        type: 'toolCall',
+        toolCallId: item.call_id,
+        name: item.name,
+        arguments: { input: item.input },
+    };
+    const block = {
+        type: 'custom_tool_call',
+        contentIndex: state.content.push(toolCall) - 1,
+        itemId: item.id,
+        name: item.name,
+        partialInput: item.input,
+        toolCallId: item.call_id,
+        ended: false,
+    };
+    registerState(state, outputIndex, block);
+    state.stream.push({
+        type: 'toolcall_start',
+        contentIndex: block.contentIndex,
+        toolCallId: block.toolCallId,
+        name: block.name,
+    });
+    return block;
+}
+function appendTextDelta(state, outputIndex, itemId, delta, refusal) {
+    const block = ensureResponseBlock(state, outputIndex, itemId);
+    block.refusal = block.refusal || refusal;
+    block.content.response.content += delta;
+    state.stream.push({ type: 'text_delta', contentIndex: block.contentIndex, delta });
+}
+function setTextContent(state, outputIndex, itemId, text, refusal) {
+    const block = ensureResponseBlock(state, outputIndex, itemId);
+    block.refusal = block.refusal || refusal;
+    block.content.response.content = text;
+}
+function appendThinkingDelta(state, outputIndex, itemId, delta) {
+    const block = ensureThinkingBlock(state, outputIndex, itemId);
+    block.content.thinkingText += delta;
+    state.stream.push({ type: 'thinking_delta', contentIndex: block.contentIndex, delta });
+}
+function setThinkingText(state, outputIndex, itemId, text) {
+    const block = ensureThinkingBlock(state, outputIndex, itemId);
+    block.content.thinkingText = text;
+}
+function appendFunctionCallDelta(state, outputIndex, itemId, delta) {
+    const block = getBlockByOutputOrItem(state, outputIndex, itemId);
+    if (!block || block.type !== 'function_call') {
+        return;
+    }
+    bindItemId(state, block, itemId);
+    block.partialJson += delta;
+    const content = state.content[block.contentIndex];
+    if (content?.type === 'toolCall') {
+        content.arguments = parsePartialJsonObject(block.partialJson);
+    }
+    state.stream.push({ type: 'toolcall_delta', contentIndex: block.contentIndex, delta });
+}
+function setFunctionCallArguments(state, outputIndex, itemId, argumentsJson) {
+    const block = getBlockByOutputOrItem(state, outputIndex, itemId);
+    if (block?.type === 'function_call') {
+        bindItemId(state, block, itemId);
+        block.partialJson = argumentsJson;
+    }
+}
+function appendCustomToolCallDelta(state, outputIndex, itemId, delta) {
+    const block = getBlockByOutputOrItem(state, outputIndex, itemId);
+    if (!block || block.type !== 'custom_tool_call') {
+        return;
+    }
+    bindItemId(state, block, itemId);
+    block.partialInput += delta;
+    const content = state.content[block.contentIndex];
+    if (content?.type === 'toolCall') {
+        content.arguments = { input: block.partialInput };
+    }
+    state.stream.push({ type: 'toolcall_delta', contentIndex: block.contentIndex, delta });
+}
+function setCustomToolCallInput(state, outputIndex, itemId, input) {
+    const block = getBlockByOutputOrItem(state, outputIndex, itemId);
+    if (block?.type === 'custom_tool_call') {
+        bindItemId(state, block, itemId);
+        block.partialInput = input;
+    }
+}
+function finishResponseBlock(state, outputIndex, item) {
+    const block = ensureResponseBlock(state, outputIndex, item.id);
+    const text = textFromOutputMessage(item);
+    block.refusal = block.refusal || item.content.some((part) => part.type === 'refusal');
+    state.sawRefusal = state.sawRefusal || block.refusal;
+    block.content.response.content = text;
+    finishTextBlock(state, block);
+}
+function finishThinkingBlock(state, outputIndex, item) {
+    const block = ensureThinkingBlock(state, outputIndex, item.id);
+    const text = thinkingTextFromReasoningItem(item);
+    if (text) {
+        block.content.thinkingText = text;
+    }
+    finishThinkingState(state, block);
+}
+function finishFunctionCallBlock(state, outputIndex, item, options = {}) {
+    const block = ensureFunctionCallBlock(state, outputIndex, item);
+    const args = options.allowInvalidToolJson
+        ? parsePartialJsonObject(item.arguments || block.partialJson)
+        : parseJsonObject(item.arguments || block.partialJson);
+    const toolCall = {
+        type: 'toolCall',
+        toolCallId: item.call_id,
+        name: item.name,
+        arguments: args,
+    };
+    state.content[block.contentIndex] = toolCall;
+    finishToolCallBlock(state, block, toolCall);
+}
+function finishCustomToolCallBlock(state, outputIndex, item) {
+    const block = ensureCustomToolCallBlock(state, outputIndex, item);
+    const toolCall = {
+        type: 'toolCall',
+        toolCallId: item.call_id,
+        name: item.name,
+        arguments: { input: item.input },
+    };
+    state.content[block.contentIndex] = toolCall;
+    finishToolCallBlock(state, block, toolCall);
+}
+function finishTextBlock(state, block) {
+    if (block.ended) {
+        return;
+    }
+    block.ended = true;
+    state.stream.push({
+        type: 'text_end',
+        contentIndex: block.contentIndex,
+        content: block.content,
+    });
+}
+function finishThinkingState(state, block) {
+    if (block.ended) {
+        return;
+    }
+    block.ended = true;
+    state.stream.push({
+        type: 'thinking_end',
+        contentIndex: block.contentIndex,
+        content: block.content,
+    });
+}
+function finishToolCallBlock(state, block, toolCall) {
+    if (block.ended) {
+        return;
+    }
+    block.ended = true;
+    state.stream.push({
+        type: 'toolcall_end',
+        contentIndex: block.contentIndex,
+        toolCall,
+    });
+}
+function closeOpenBlocks(state, options = {}) {
+    for (const block of state.statesByOutputIndex.values()) {
+        if (block.ended) {
+            continue;
+        }
+        if (block.type === 'response') {
+            finishTextBlock(state, block);
+        }
+        else if (block.type === 'thinking') {
+            finishThinkingState(state, block);
+        }
+        else if (block.type === 'function_call') {
+            const args = options.allowInvalidToolJson
+                ? parsePartialJsonObject(block.partialJson)
+                : parseJsonObject(block.partialJson);
+            const toolCall = {
+                type: 'toolCall',
+                toolCallId: block.toolCallId,
+                name: block.name,
+                arguments: args,
+            };
+            const content = state.content[block.contentIndex];
+            if (content?.type === 'toolCall') {
+                content.arguments = args;
+            }
+            finishToolCallBlock(state, block, toolCall);
+        }
+        else {
+            const toolCall = {
+                type: 'toolCall',
+                toolCallId: block.toolCallId,
+                name: block.name,
+                arguments: { input: block.partialInput },
+            };
+            state.content[block.contentIndex] = toolCall;
+            finishToolCallBlock(state, block, toolCall);
+        }
+    }
+}
+function registerState(state, outputIndex, block) {
+    state.statesByOutputIndex.set(outputIndex, block);
+    if (block.itemId) {
+        state.statesByItemId.set(block.itemId, block);
+    }
+}
+function bindItemId(state, block, itemId) {
+    if (!itemId || block.itemId === itemId) {
+        return;
+    }
+    block.itemId = itemId;
+    state.statesByItemId.set(itemId, block);
+}
+function getBlockByOutputOrItem(state, outputIndex, itemId) {
+    return state.statesByOutputIndex.get(outputIndex) ?? state.statesByItemId.get(itemId);
+}
+function hydrateContentFromResponse(state, response) {
+    if (state.content.length > 0) {
+        return;
+    }
+    for (const output of response.output) {
+        if (output.type === 'message') {
+            const text = textFromOutputMessage(output);
+            state.sawRefusal =
+                state.sawRefusal || output.content.some((part) => part.type === 'refusal');
+            state.content.push({
+                type: 'response',
+                response: { type: 'text', content: text },
+            });
+        }
+        else if (output.type === 'reasoning') {
+            state.content.push({
+                type: 'thinking',
+                thinkingText: thinkingTextFromReasoningItem(output),
+            });
+        }
+        else if (output.type === 'function_call') {
+            state.content.push({
+                type: 'toolCall',
+                name: output.name,
+                toolCallId: output.call_id,
+                arguments: parseJsonObject(output.arguments),
+            });
+        }
+        else if (output.type === 'custom_tool_call') {
+            state.content.push({
+                type: 'toolCall',
+                name: output.name,
+                toolCallId: output.call_id,
+                arguments: { input: output.input },
+            });
+        }
+    }
+}
+function textFromOutputMessage(message) {
+    return message.content
+        .map((part) => (part.type === 'output_text' ? part.text : part.refusal))
+        .join('');
+}
+function thinkingTextFromReasoningItem(item) {
+    const summary = item.summary.map((part) => part.text).filter(Boolean).join('\n\n');
+    if (summary) {
+        return summary;
+    }
+    return item.content?.map((part) => part.text).filter(Boolean).join('\n\n') ?? '';
+}
+function parsePartialJsonObject(value) {
+    try {
+        return parseJsonObject(value);
+    }
+    catch {
+        return {};
+    }
+}
+function parseJsonObject(value) {
+    const parsed = JSON.parse(value || '{}');
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('OpenAI function call arguments must be a JSON object.');
+    }
+    return parsed;
+}
+function mapDoneStopReason(response, content, sawRefusal) {
+    if (content.some((part) => part.type === 'toolCall')) {
+        return 'toolUse';
+    }
+    if (response.status === 'incomplete') {
+        return response.incomplete_details?.reason === 'content_filter'
+            ? 'contentFilter'
+            : 'length';
+    }
+    if (sawRefusal) {
+        return 'refusal';
+    }
+    return 'stop';
+}
+function usageFromResponse(response, model) {
+    if (!response.usage) {
+        return undefined;
+    }
+    const cacheRead = response.usage.input_tokens_details.cached_tokens;
+    const input = Math.max(response.usage.input_tokens - cacheRead, 0);
+    const output = response.usage.output_tokens;
+    const cacheWrite = 0;
+    const cost = {
+        input: costForTokens(input, model.cost.input),
+        output: costForTokens(output, model.cost.output),
+        cacheRead: costForTokens(cacheRead, model.cost.cacheRead),
+        cacheWrite: costForTokens(cacheWrite, model.cost.cacheWrite),
+        total: 0,
+    };
+    cost.total = cost.input + cost.output + cost.cacheRead + cost.cacheWrite;
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+        cost,
+    };
+}
+function costForTokens(tokens, costPerMillion) {
+    return (tokens * costPerMillion) / 1_000_000;
+}
+function modelRef(state) {
+    return {
+        provider: OPENAI_PROVIDER,
+        id: state.request.modelId,
+        name: state.model.name,
+    };
+}
+function createDefaultMessageId() {
+    return `msg_${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}_${Math.random().toString(36).slice(2)}`}`;
+}
+//# sourceMappingURL=adapter.js.map