@veryfront/ext-llm-openai 0.1.985

package/esm/openai-responses-request-builder.js

@@ -0,0 +1,220 @@
+import { readProviderOptions, stringifyJsonValue, unwrapToolInputSchema, } from "veryfront/provider/shared";
+function isOpenAIReasoningModel(modelId) {
+    return /^o[134](-|$)/.test(modelId);
+}
+function resolveOpenAIReasoningEffort(option) {
+    if (!option || option.enabled !== true) {
+        return undefined;
+    }
+    switch (option.effort) {
+        case "low":
+            return "low";
+        case "high":
+        case "max":
+            return "high";
+        case "medium":
+        default:
+            return "medium";
+    }
+}
+function toSnakeCaseRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [
+        key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`),
+        value,
+    ]));
+}
+function toOpenAIResponsesInput(prompt) {
+    const instructionsParts = [];
+    const input = [];
+    for (const message of prompt) {
+        switch (message.role) {
+            case "system":
+                if (message.content.length > 0) {
+                    instructionsParts.push(message.content);
+                }
+                break;
+            case "user":
+                input.push({
+                    role: "user",
+                    content: toOpenAIResponsesUserContent(message.content),
+                });
+                break;
+            case "assistant": {
+                const messageContent = [];
+                for (const part of message.content) {
+                    if (part.type === "text") {
+                        messageContent.push({ type: "output_text", text: part.text });
+                        continue;
+                    }
+                    if (part.type === "reasoning") {
+                        if (messageContent.length > 0) {
+                            input.push({ role: "assistant", content: [...messageContent] });
+                            messageContent.length = 0;
+                        }
+                        const summary = [];
+                        if (typeof part.text === "string" && part.text.length > 0) {
+                            summary.push({ type: "summary_text", text: part.text });
+                        }
+                        input.push({
+                            type: "reasoning",
+                            ...(typeof part.signature === "string" ? { encrypted_content: part.signature } : {}),
+                            summary,
+                        });
+                        continue;
+                    }
+                    if (messageContent.length > 0) {
+                        input.push({ role: "assistant", content: [...messageContent] });
+                        messageContent.length = 0;
+                    }
+                    input.push({
+                        type: "function_call",
+                        call_id: part.toolCallId,
+                        name: part.toolName,
+                        arguments: stringifyJsonValue(part.input),
+                    });
+                }
+                if (messageContent.length > 0) {
+                    input.push({ role: "assistant", content: messageContent });
+                }
+                break;
+            }
+            case "tool":
+                for (const part of message.content) {
+                    input.push({
+                        type: "function_call_output",
+                        call_id: part.toolCallId,
+                        output: stringifyJsonValue(part.output.value),
+                    });
+                }
+                break;
+        }
+    }
+    return {
+        ...(instructionsParts.length > 0 ? { instructions: instructionsParts.join("\n\n") } : {}),
+        input,
+    };
+}
+function toOpenAIResponsesUserContent(parts) {
+    const content = [];
+    for (const part of parts) {
+        if (part.type === "text") {
+            if (part.text.length > 0) {
+                content.push({ type: "input_text", text: part.text });
+            }
+            continue;
+        }
+        if (part.type === "image" || part.mediaType.startsWith("image/")) {
+            content.push({ type: "input_image", image_url: part.url, detail: "auto" });
+            continue;
+        }
+        content.push({
+            type: "input_file",
+            file_url: part.url,
+            ...(part.filename ? { filename: part.filename } : {}),
+        });
+    }
+    return content;
+}
+function toOpenAIResponsesTools(tools) {
+    if (!tools)
+        return undefined;
+    const normalized = [];
+    for (const tool of tools) {
+        if (tool.type === "function") {
+            normalized.push({
+                type: "function",
+                name: tool.name,
+                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+                parameters: unwrapToolInputSchema(tool.inputSchema),
+            });
+            continue;
+        }
+        if (!tool.id.startsWith("openai."))
+            continue;
+        const providerType = tool.id.slice("openai.".length);
+        if (providerType.length === 0)
+            continue;
+        normalized.push({
+            type: providerType,
+            ...toSnakeCaseRecord(tool.args),
+        });
+    }
+    return normalized.length > 0 ? normalized : undefined;
+}
+export function buildOpenAIResponsesRequest(modelId, providerName, options, stream, warnings) {
+    const isReasoningModel = isOpenAIReasoningModel(modelId);
+    const reasoningEffort = resolveOpenAIReasoningEffort(options.reasoning);
+    const reasoningEnabled = isReasoningModel || reasoningEffort !== undefined;
+    if (options.topK !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "openai",
+            setting: "topK",
+            details: "OpenAI Responses API does not expose top_k; the value was dropped.",
+        });
+    }
+    if (reasoningEnabled) {
+        const dropped = [
+            ["temperature", "temperature"],
+            ["topP", "top_p"],
+            ["presencePenalty", "presence_penalty"],
+            ["frequencyPenalty", "frequency_penalty"],
+        ];
+        for (const [key, openaiName] of dropped) {
+            if (options[key] !== undefined) {
+                warnings.push({
+                    type: "unsupported-setting",
+                    provider: "openai",
+                    setting: key,
+                    details: `Dropped because OpenAI reasoning models reject ${openaiName}. Reasoning was active for this request.`,
+                });
+            }
+        }
+    }
+    const { instructions, input } = toOpenAIResponsesInput(options.prompt);
+    const responsesTools = toOpenAIResponsesTools(options.tools);
+    const body = {
+        model: modelId,
+        input,
+        ...(instructions !== undefined ? { instructions } : {}),
+        ...(stream ? { stream: true } : {}),
+        ...(options.maxOutputTokens !== undefined
+            ? { max_output_tokens: options.maxOutputTokens }
+            : {}),
+        ...(!reasoningEnabled && options.temperature !== undefined
+            ? { temperature: options.temperature }
+            : {}),
+        ...(!reasoningEnabled && options.topP !== undefined ? { top_p: options.topP } : {}),
+        ...(responsesTools ? { tools: responsesTools } : {}),
+        ...(options.toolChoice !== undefined ? { tool_choice: options.toolChoice } : {}),
+        ...(reasoningEffort !== undefined
+            ? { reasoning: { effort: reasoningEffort, summary: "auto" } }
+            : {}),
+        ...(typeof options.userId === "string" && options.userId.length > 0
+            ? { user: options.userId }
+            : {}),
+        ...(options.serviceTier !== undefined ? { service_tier: options.serviceTier } : {}),
+        ...(options.parallelToolCalls !== undefined
+            ? { parallel_tool_calls: options.parallelToolCalls }
+            : {}),
+        ...(options.responseFormat && options.responseFormat.type !== "text"
+            ? {
+                text: {
+                    format: options.responseFormat.type === "json" ? { type: "json_object" } : {
+                        type: "json_schema",
+                        name: options.responseFormat.name,
+                        ...(typeof options.responseFormat.description === "string"
+                            ? { description: options.responseFormat.description }
+                            : {}),
+                        schema: unwrapToolInputSchema(options.responseFormat.schema),
+                        ...(options.responseFormat.strict !== undefined
+                            ? { strict: options.responseFormat.strict }
+                            : {}),
+                    },
+                },
+            }
+            : {}),
+    };
+    Object.assign(body, readProviderOptions(options.providerOptions, "openai", providerName));
+    return body;
+}

package/esm/openai-responses-stream.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeUsage } from "veryfront/provider/shared";
+/**
+ * The Responses API uses `input_tokens` / `output_tokens` field names
+ * instead of Chat Completions' `prompt_tokens` / `completion_tokens`.
+ */
+export declare function extractOpenAIResponsesUsage(payload: unknown): RuntimeUsage | undefined;
+export declare function normalizeOpenAIResponsesFinishReason(raw: unknown): string | {
+    unified: string;
+    raw: string;
+} | null;
+/**
+ * Parse the Responses API streaming event grammar into the same UI part
+ * shapes the existing OpenAI / Anthropic / Google streams emit.
+ */
+export declare function streamOpenAIResponsesParts(stream: ReadableStream<Uint8Array>): AsyncIterable<unknown>;
+//# sourceMappingURL=openai-responses-stream.d.ts.map

package/esm/openai-responses-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-responses-stream.d.ts","sourceRoot":"","sources":["../src/openai-responses-stream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAc9D;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAqEtF;AAED,wBAAgB,oCAAoC,CAClD,GAAG,EAAE,OAAO,GACX,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAclD;AAED;;;GAGG;AACH,wBAAuB,0BAA0B,CAC/C,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,aAAa,CAAC,OAAO,CAAC,CAqJxB"}

package/esm/openai-responses-stream.js

@@ -0,0 +1,235 @@
+import { parseSseChunk, readGatewayBillingMode, readRecord } from "veryfront/provider/shared";
+/**
+ * The Responses API uses `input_tokens` / `output_tokens` field names
+ * instead of Chat Completions' `prompt_tokens` / `completion_tokens`.
+ */
+export function extractOpenAIResponsesUsage(payload) {
+    const record = readRecord(payload);
+    // Streaming usage lives on response.completed inside `response.usage`;
+    // non-streaming has it at the top level.
+    const responseRecord = readRecord(record?.response);
+    const usage = readRecord(responseRecord?.usage) ?? readRecord(record?.usage);
+    if (!usage)
+        return undefined;
+    const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : undefined;
+    const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : undefined;
+    const totalTokens = typeof usage.total_tokens === "number"
+        ? usage.total_tokens
+        : (inputTokens !== undefined || outputTokens !== undefined
+            ? (inputTokens ?? 0) + (outputTokens ?? 0)
+            : undefined);
+    const inputDetails = readRecord(usage.input_tokens_details);
+    const cachedTokens = inputDetails?.cached_tokens;
+    const outputDetails = readRecord(usage.output_tokens_details);
+    const reasoningTokens = outputDetails?.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,
+        outputTokens,
+        totalTokens,
+        ...(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 }
+            : {}),
+    };
+}
+export function normalizeOpenAIResponsesFinishReason(raw) {
+    if (typeof raw !== "string")
+        return null;
+    switch (raw) {
+        case "completed":
+            return { unified: "stop", raw };
+        case "incomplete":
+            return { unified: "length", raw };
+        case "failed":
+            return { unified: "error", raw };
+        case "in_progress":
+            return null;
+        default:
+            return raw;
+    }
+}
+/**
+ * Parse the Responses API streaming event grammar into the same UI part
+ * shapes the existing OpenAI / Anthropic / Google streams emit.
+ */
+export async function* streamOpenAIResponsesParts(stream) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const reasoningBlocks = new Map();
+    const functionCalls = new Map();
+    const startedToolCalls = new Set();
+    let finishReason = null;
+    let usage;
+    let reasoningCounter = 0;
+    for await (const chunk of stream) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const parsed = parseSseChunk(buffer);
+        buffer = parsed.remainder;
+        for (const event of parsed.events) {
+            if (event === "[DONE]")
+                continue;
+            const record = readRecord(event);
+            const type = typeof record?.type === "string" ? record.type : undefined;
+            if (!type)
+                continue;
+            // response.output_item.added: a new output item begins.
+            if (type === "response.output_item.added") {
+                const item = readRecord(record?.item);
+                const itemType = typeof item?.type === "string" ? item.type : undefined;
+                const itemId = typeof item?.id === "string" ? item.id : undefined;
+                if (itemType === "function_call" && itemId) {
+                    const callId = typeof item?.call_id === "string" ? item.call_id : itemId;
+                    const name = typeof item?.name === "string" ? item.name : "";
+                    functionCalls.set(itemId, {
+                        id: itemId,
+                        toolCallId: callId,
+                        name,
+                        arguments: "",
+                    });
+                }
+                if (itemType === "reasoning" && itemId) {
+                    reasoningBlocks.set(itemId, {
+                        id: `reasoning-${reasoningCounter++}`,
+                        emittedStart: false,
+                    });
+                }
+                continue;
+            }
+            // response.output_text.delta: text chunk for a message item.
+            if (type === "response.output_text.delta" && typeof record?.delta === "string") {
+                if (record.delta.length > 0) {
+                    yield { type: "text-delta", delta: record.delta };
+                }
+                continue;
+            }
+            // response.reasoning_summary_text.delta: reasoning summary text chunk.
+            if (type === "response.reasoning_summary_text.delta" && typeof record?.delta === "string") {
+                const itemId = typeof record?.item_id === "string" ? record.item_id : undefined;
+                const state = itemId ? reasoningBlocks.get(itemId) : undefined;
+                if (state && record.delta.length > 0) {
+                    if (!state.emittedStart) {
+                        yield { type: "reasoning-start", id: state.id };
+                        state.emittedStart = true;
+                    }
+                    yield { type: "reasoning-delta", id: state.id, delta: record.delta };
+                }
+                continue;
+            }
+            // response.function_call_arguments.delta: tool call argument chunk.
+            if (type === "response.function_call_arguments.delta" && typeof record?.delta === "string") {
+                const itemId = typeof record?.item_id === "string" ? record.item_id : undefined;
+                const state = itemId ? functionCalls.get(itemId) : undefined;
+                if (state && record.delta.length > 0) {
+                    if (!startedToolCalls.has(state.id)) {
+                        yield {
+                            type: "tool-input-start",
+                            id: state.toolCallId,
+                            toolName: state.name,
+                        };
+                        startedToolCalls.add(state.id);
+                    }
+                    state.arguments += record.delta;
+                    yield {
+                        type: "tool-input-delta",
+                        id: state.toolCallId,
+                        delta: record.delta,
+                    };
+                }
+                continue;
+            }
+            // response.output_item.done: an item has finished emitting deltas.
+            if (type === "response.output_item.done") {
+                const item = readRecord(record?.item);
+                const itemType = typeof item?.type === "string" ? item.type : undefined;
+                const itemId = typeof item?.id === "string" ? item.id : undefined;
+                if (itemType === "reasoning" && itemId) {
+                    const state = reasoningBlocks.get(itemId);
+                    if (state?.emittedStart) {
+                        yield { type: "reasoning-end", id: state.id };
+                    }
+                    reasoningBlocks.delete(itemId);
+                }
+                if (itemType === "function_call" && itemId) {
+                    const state = functionCalls.get(itemId);
+                    if (state) {
+                        yield {
+                            type: "tool-call",
+                            toolCallId: state.toolCallId,
+                            toolName: state.name,
+                            input: state.arguments,
+                        };
+                    }
+                    functionCalls.delete(itemId);
+                }
+                continue;
+            }
+            // response.completed: terminal event with the final response object.
+            if (type === "response.completed") {
+                usage = extractOpenAIResponsesUsage(record) ?? usage;
+                const responseRecord = readRecord(record?.response);
+                finishReason = normalizeOpenAIResponsesFinishReason(responseRecord?.status);
+                continue;
+            }
+            if (type === "response.failed" || type === "response.incomplete") {
+                const responseRecord = readRecord(record?.response);
+                finishReason = normalizeOpenAIResponsesFinishReason(responseRecord?.status) ??
+                    (type === "response.failed"
+                        ? { unified: "error", raw: "failed" }
+                        : { unified: "length", raw: "incomplete" });
+                usage = extractOpenAIResponsesUsage(record) ?? usage;
+                continue;
+            }
+        }
+    }
+    // Close any reasoning streams still open at end-of-stream (defensive).
+    for (const state of reasoningBlocks.values()) {
+        if (state.emittedStart) {
+            yield { type: "reasoning-end", id: state.id };
+        }
+    }
+    yield {
+        type: "finish",
+        finishReason,
+        ...(usage ? { usage } : {}),
+    };
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@veryfront/ext-llm-openai",
+  "version": "0.1.985",
+  "description": "Veryfront first-party extension package for ext-llm-openai",
+  "keywords": [
+    "veryfront",
+    "extension",
+    "ext-llm-openai"
+  ],
+  "author": "Veryfront",
+  "homepage": "https://github.com/veryfront/veryfront-code/tree/main/extensions/ext-llm-openai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/veryfront/veryfront-code.git",
+    "directory": "extensions/ext-llm-openai"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/veryfront/veryfront-code/issues"
+  },
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "types": "./esm/index.d.ts"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "veryfront": {
+    "extension": true,
+    "contracts": {
+      "provides": [
+        "LLMProvider:openai"
+      ],
+      "requires": [
+        "LLMProviderRegistry"
+      ]
+    },
+    "capabilities": []
+  },
+  "peerDependencies": {
+    "veryfront": "^0.1.985"
+  },
+  "type": "module",
+  "types": "./esm/index.d.ts",
+  "files": [
+    "esm",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ]
+}