@veryfront/ext-llm-openai 0.1.985

package/esm/openai-provider.js

@@ -0,0 +1,436 @@
+/**
+ * OpenAI provider, implements the {@link LLMProvider} contract for OpenAI,
+ * OpenAI-compatible endpoints (Azure OpenAI, Moonshot AI), and OpenAI's
+ * Responses API.
+ *
+ * Ported from `src/provider/runtime-loader.ts` as part of PR 11.
+ *
+ * @module extensions/ext-llm-openai/openai-provider
+ */
+import { buildProviderError, createOpenAIRequestInit, createWarningCollector, getOpenAIChatCompletionsUrl, getOpenAIEmbeddingUrl, getOpenAIResponsesUrl, isNumberArray, mergeUsage, parseRetryAfterMs, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, readGatewayBillingMode, readRecord, requestJson, requestStream, stringifyJsonValue, TOOL_INPUT_PENDING_THRESHOLD_MS, withToolInputStatusTransitions, } from "veryfront/provider/shared";
+import { buildOpenAIChatRequest, } from "./openai-chat-request-builder.js";
+import { streamOpenAICompatibleParts } from "./openai-chat-stream.js";
+import { buildOpenAIResponsesRequest } from "./openai-responses-request-builder.js";
+import { extractOpenAIResponsesUsage, normalizeOpenAIResponsesFinishReason, streamOpenAIResponsesParts, } from "./openai-responses-stream.js";
+// Re-export error classes so extension tests can import from this module.
+export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, TOOL_INPUT_PENDING_THRESHOLD_MS, withToolInputStatusTransitions, };
+// ---------------------------------------------------------------------------
+// Embedding helpers
+// ---------------------------------------------------------------------------
+function extractOpenAIEmbeddings(payload) {
+    const record = readRecord(payload);
+    const data = record?.data;
+    if (!Array.isArray(data)) {
+        throw new Error("Invalid OpenAI embedding response: data array missing");
+    }
+    const embeddings = [];
+    for (const item of data) {
+        const itemRecord = readRecord(item);
+        const embedding = itemRecord?.embedding;
+        if (!isNumberArray(embedding)) {
+            throw new Error("Invalid OpenAI embedding response: embedding vector missing");
+        }
+        embeddings.push(embedding);
+    }
+    return embeddings;
+}
+function extractOpenAIUsageTokens(payload) {
+    const record = readRecord(payload);
+    const usage = readRecord(record?.usage);
+    const totalTokens = usage?.total_tokens;
+    return typeof totalTokens === "number" ? totalTokens : undefined;
+}
+// ---------------------------------------------------------------------------
+// Chat helpers
+// ---------------------------------------------------------------------------
+function normalizeOpenAIFinishReason(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    if (raw === "tool_calls") {
+        return { unified: "tool-calls", raw };
+    }
+    if (raw === "content_filter") {
+        return { unified: "content-filter", raw };
+    }
+    return raw;
+}
+function extractOpenAIUsage(payload) {
+    const record = readRecord(payload);
+    const usage = readRecord(record?.usage);
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = usage.prompt_tokens;
+    const outputTokens = usage.completion_tokens;
+    const totalTokens = usage.total_tokens;
+    const promptTokensDetails = readRecord(usage.prompt_tokens_details);
+    const cachedTokens = promptTokensDetails?.cached_tokens;
+    const completionTokensDetails = readRecord(usage.completion_tokens_details);
+    const reasoningTokens = completionTokensDetails?.reasoning_tokens;
+    const veryfront = readRecord(usage.veryfront);
+    const costSource = veryfront?.cost_source;
+    const billingMode = readGatewayBillingMode(veryfront?.billing_mode);
+    const usageCaptureStatus = veryfront?.usage_capture_status;
+    return {
+        inputTokens: typeof inputTokens === "number" ? inputTokens : undefined,
+        outputTokens: typeof outputTokens === "number" ? outputTokens : undefined,
+        totalTokens: typeof totalTokens === "number" ? totalTokens : undefined,
+        ...(typeof cachedTokens === "number" ? { cacheReadInputTokens: cachedTokens } : {}),
+        ...(typeof reasoningTokens === "number" ? { reasoningTokens } : {}),
+        ...(typeof veryfront?.billable_input_tokens === "number"
+            ? { billableInputTokens: veryfront.billable_input_tokens }
+            : {}),
+        ...(typeof veryfront?.billable_output_tokens === "number"
+            ? { billableOutputTokens: veryfront.billable_output_tokens }
+            : {}),
+        ...(typeof veryfront?.cost_usd === "number" ? { costUsd: veryfront.cost_usd } : {}),
+        ...(typeof veryfront?.provider_input_cost_usd === "number"
+            ? { providerInputCostUsd: veryfront.provider_input_cost_usd }
+            : {}),
+        ...(typeof veryfront?.provider_output_cost_usd === "number"
+            ? { providerOutputCostUsd: veryfront.provider_output_cost_usd }
+            : {}),
+        ...(typeof veryfront?.provider_cost_usd === "number"
+            ? { providerCostUsd: veryfront.provider_cost_usd }
+            : {}),
+        ...(typeof veryfront?.veryfront_input_charge_usd === "number"
+            ? { veryfrontInputChargeUsd: veryfront.veryfront_input_charge_usd }
+            : {}),
+        ...(typeof veryfront?.veryfront_output_charge_usd === "number"
+            ? { veryfrontOutputChargeUsd: veryfront.veryfront_output_charge_usd }
+            : {}),
+        ...(typeof veryfront?.veryfront_charge_usd === "number"
+            ? { veryfrontChargeUsd: veryfront.veryfront_charge_usd }
+            : {}),
+        ...(typeof veryfront?.veryfront_billed_usd === "number"
+            ? { veryfrontBilledUsd: veryfront.veryfront_billed_usd }
+            : {}),
+        ...(typeof veryfront?.cost_credits === "number" ? { costCredits: veryfront.cost_credits } : {}),
+        ...(costSource === "gateway" || costSource === "missing" || costSource === "partial"
+            ? { costSource }
+            : {}),
+        ...(billingMode !== undefined ? { billingMode } : {}),
+        ...(usageCaptureStatus === "complete" ||
+            usageCaptureStatus === "missing" ||
+            usageCaptureStatus === "partial"
+            ? { usageCaptureStatus }
+            : {}),
+    };
+}
+function extractOpenAIContentText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    let text = "";
+    for (const part of content) {
+        const record = readRecord(part);
+        const type = record?.type;
+        if (type === "text" && typeof record?.text === "string") {
+            text += record.text;
+        }
+    }
+    return text;
+}
+function extractOpenAIToolCalls(message) {
+    const toolCalls = message.tool_calls;
+    if (!Array.isArray(toolCalls)) {
+        return [];
+    }
+    const normalized = [];
+    for (const entry of toolCalls) {
+        const record = readRecord(entry);
+        const id = typeof record?.id === "string" ? record.id : undefined;
+        const fn = readRecord(record?.function);
+        const name = typeof fn?.name === "string" ? fn.name : undefined;
+        const argumentsText = typeof fn?.arguments === "string" ? fn.arguments : undefined;
+        if (!id || !name || argumentsText === undefined) {
+            continue;
+        }
+        normalized.push({
+            toolCallId: id,
+            toolName: name,
+            input: argumentsText,
+        });
+    }
+    return normalized;
+}
+function extractFirstChoice(payload) {
+    const record = readRecord(payload);
+    const choices = record?.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return undefined;
+    }
+    const first = readRecord(choices[0]);
+    if (!first) {
+        return undefined;
+    }
+    return first;
+}
+function buildOpenAIGenerateResult(payload) {
+    const choice = extractFirstChoice(payload);
+    const message = readRecord(choice?.message);
+    const text = extractOpenAIContentText(message?.content);
+    const toolCalls = message ? extractOpenAIToolCalls(message) : [];
+    return {
+        content: [
+            ...(text.length > 0 ? [{ type: "text", text }] : []),
+            ...toolCalls.map((toolCall) => ({
+                type: "tool-call",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input,
+            })),
+        ],
+        finishReason: normalizeOpenAIFinishReason(choice?.finish_reason),
+        usage: extractOpenAIUsage(payload),
+    };
+}
+function buildOpenAIResponsesGenerateResult(payload) {
+    const record = readRecord(payload);
+    const output = Array.isArray(record?.output) ? record.output : [];
+    const content = [];
+    for (const item of output) {
+        const itemRecord = readRecord(item);
+        const itemType = typeof itemRecord?.type === "string" ? itemRecord.type : undefined;
+        if (itemType === "message" && Array.isArray(itemRecord?.content)) {
+            // A message item bundles one or more output_text parts.
+            let text = "";
+            for (const part of itemRecord.content) {
+                const p = readRecord(part);
+                if (typeof p?.type === "string" && p.type === "output_text" && typeof p.text === "string") {
+                    text += p.text;
+                }
+            }
+            if (text.length > 0) {
+                content.push({ type: "text", text });
+            }
+            continue;
+        }
+        if (itemType === "function_call") {
+            content.push({
+                type: "tool-call",
+                toolCallId: typeof itemRecord?.call_id === "string"
+                    ? itemRecord.call_id
+                    : (typeof itemRecord?.id === "string" ? itemRecord.id : ""),
+                toolName: typeof itemRecord?.name === "string" ? itemRecord.name : "",
+                input: typeof itemRecord?.arguments === "string"
+                    ? itemRecord.arguments
+                    : stringifyJsonValue(itemRecord?.arguments ?? {}),
+            });
+            continue;
+        }
+        if (itemType === "reasoning") {
+            const summary = Array.isArray(itemRecord?.summary) ? itemRecord.summary : [];
+            const summaries = [];
+            for (const s of summary) {
+                const sr = readRecord(s);
+                if (typeof sr?.text === "string" && sr.text.length > 0) {
+                    summaries.push({
+                        ...(typeof sr?.id === "string" ? { id: sr.id } : {}),
+                        text: sr.text,
+                    });
+                }
+            }
+            content.push({
+                type: "reasoning",
+                ...(summaries.length > 0 ? { summaries } : {}),
+                ...(typeof itemRecord?.encrypted_content === "string"
+                    ? { signature: itemRecord.encrypted_content }
+                    : {}),
+            });
+            continue;
+        }
+    }
+    return {
+        content,
+        finishReason: normalizeOpenAIResponsesFinishReason(record?.status),
+        usage: extractOpenAIResponsesUsage(payload),
+    };
+}
+// ---------------------------------------------------------------------------
+// Public factory functions
+// ---------------------------------------------------------------------------
+export function createOpenAIModelRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    return {
+        provider: config.name ?? "openai",
+        modelId,
+        specificationVersion: "v3",
+        supportedUrls: {},
+        doGenerate(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getOpenAIChatCompletionsUrl(config.baseURL);
+            const warnings = createWarningCollector();
+            const body = buildOpenAIChatRequest(modelId, config.name ?? "openai", options, false, warnings);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                providerKind: "openai",
+                init: createOpenAIRequestInit({
+                    apiKey: config.apiKey,
+                    extraHeaders: options.headers,
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                }),
+            }).then((payload) => {
+                const drained = warnings.drain();
+                return {
+                    ...buildOpenAIGenerateResult(payload),
+                    ...(drained.length > 0 ? { warnings: drained } : {}),
+                };
+            });
+        },
+        doStream(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getOpenAIChatCompletionsUrl(config.baseURL);
+            const warnings = createWarningCollector();
+            const body = buildOpenAIChatRequest(modelId, config.name ?? "openai", options, true, warnings);
+            return requestStream({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                providerKind: "openai",
+                init: createOpenAIRequestInit({
+                    apiKey: config.apiKey,
+                    extraHeaders: options.headers,
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                }),
+            }).then((responseStream) => {
+                const drained = warnings.drain();
+                return {
+                    stream: ReadableStream.from(withToolInputStatusTransitions(streamOpenAICompatibleParts(responseStream))),
+                    ...(drained.length > 0 ? { warnings: drained } : {}),
+                };
+            });
+        },
+    };
+}
+export function createOpenAIResponsesRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    return {
+        provider: config.name ?? "openai",
+        modelId,
+        specificationVersion: "v3",
+        supportedUrls: {},
+        doGenerate(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getOpenAIResponsesUrl(config.baseURL);
+            const warnings = createWarningCollector();
+            const body = buildOpenAIResponsesRequest(modelId, config.name ?? "openai", options, false, warnings);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                providerKind: "openai",
+                init: createOpenAIRequestInit({
+                    apiKey: config.apiKey,
+                    extraHeaders: options.headers,
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                }),
+            }).then((payload) => {
+                const drained = warnings.drain();
+                return {
+                    ...buildOpenAIResponsesGenerateResult(payload),
+                    ...(drained.length > 0 ? { warnings: drained } : {}),
+                };
+            });
+        },
+        doStream(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getOpenAIResponsesUrl(config.baseURL);
+            const warnings = createWarningCollector();
+            const body = buildOpenAIResponsesRequest(modelId, config.name ?? "openai", options, true, warnings);
+            return requestStream({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                providerKind: "openai",
+                init: createOpenAIRequestInit({
+                    apiKey: config.apiKey,
+                    extraHeaders: options.headers,
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                }),
+            }).then((responseStream) => {
+                const drained = warnings.drain();
+                return {
+                    stream: ReadableStream.from(withToolInputStatusTransitions(streamOpenAIResponsesParts(responseStream))),
+                    ...(drained.length > 0 ? { warnings: drained } : {}),
+                };
+            });
+        },
+    };
+}
+export function createOpenAIEmbeddingRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    return {
+        provider: config.name ?? "openai",
+        modelId,
+        supportsParallelCalls: true,
+        doEmbed({ values, abortSignal }) {
+            if (values.length === 0) {
+                return Promise.resolve({
+                    embeddings: [],
+                    warnings: [],
+                    rawResponse: { data: [] },
+                });
+            }
+            const url = getOpenAIEmbeddingUrl(config.baseURL);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                providerKind: "openai",
+                init: createOpenAIRequestInit({
+                    apiKey: config.apiKey,
+                    body: JSON.stringify({
+                        model: modelId,
+                        input: values,
+                    }),
+                    signal: abortSignal,
+                }),
+            }).then((payload) => ({
+                embeddings: extractOpenAIEmbeddings(payload),
+                usage: {
+                    tokens: extractOpenAIUsageTokens(payload),
+                },
+                rawResponse: payload,
+                warnings: [],
+            }));
+        },
+    };
+}
+export class OpenAIProvider {
+    id = "openai";
+    createModel(modelId, config) {
+        return createOpenAIModelRuntime({
+            apiKey: config.credential,
+            baseURL: config.baseURL,
+            name: config.name ?? "openai",
+            fetch: config.fetch,
+        }, modelId);
+    }
+    createEmbedding(modelId, config) {
+        return createOpenAIEmbeddingRuntime({
+            apiKey: config.credential,
+            baseURL: config.baseURL,
+            name: config.name ?? "openai",
+            fetch: config.fetch,
+        }, modelId);
+    }
+    createResponses(modelId, config) {
+        return createOpenAIResponsesRuntime({
+            apiKey: config.credential,
+            baseURL: config.baseURL,
+            name: config.name ?? "openai",
+            fetch: config.fetch,
+        }, modelId);
+    }
+}

package/esm/openai-responses-request-builder.d.ts

@@ -0,0 +1,42 @@
+import type { OpenAICompatibleLanguageOptions } from "./openai-chat-request-builder.js";
+export type OpenAIResponsesInputItem = Record<string, unknown>;
+export type OpenAIResponsesRequest = {
+    model: string;
+    input: OpenAIResponsesInputItem[];
+    instructions?: string;
+    stream?: boolean;
+    max_output_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    tools?: Array<Record<string, unknown>>;
+    tool_choice?: unknown;
+    reasoning?: {
+        effort?: string;
+        summary?: string;
+    };
+    metadata?: Record<string, string>;
+    user?: string;
+    service_tier?: string;
+    parallel_tool_calls?: boolean;
+    text?: {
+        format: Record<string, unknown>;
+    };
+    [key: string]: unknown;
+};
+type WarningCollector = {
+    push(warning: {
+        type: "unsupported-setting" | "other";
+        setting?: string;
+        details?: string;
+        provider: string;
+    }): void;
+    drain(): Array<{
+        type: "unsupported-setting" | "other";
+        setting?: string;
+        details?: string;
+        provider: string;
+    }>;
+};
+export declare function buildOpenAIResponsesRequest(modelId: string, providerName: string, options: OpenAICompatibleLanguageOptions, stream: boolean, warnings: WarningCollector): OpenAIResponsesRequest;
+export {};
+//# sourceMappingURL=openai-responses-request-builder.d.ts.map

package/esm/openai-responses-request-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-responses-request-builder.d.ts","sourceRoot":"","sources":["../src/openai-responses-request-builder.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,+BAA+B,EAEhC,MAAM,kCAAkC,CAAC;AAI1C,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/D,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,wBAAwB,EAAE,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;IAC3C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,CAAC,OAAO,EAAE;QACZ,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC;QACtC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,IAAI,CAAC;IACT,KAAK,IAAI,KAAK,CAAC;QACb,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC;QACtC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ,CAAC;AAmKF,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,+BAA+B,EACxC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,gBAAgB,GACzB,sBAAsB,CAiFxB"}