@mupt-ai/dari-gateway 0.1.0 → 0.2.1

package/dist/protocol/output/chat_completions.js

@@ -0,0 +1,406 @@
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";
+import { piMessageToInteractionOutput } from "../../providers/pi_output.js";
+import { providerToolCallIdentity } from "../../interaction/tool_identity.js";
+import { encodeProviderContinuationState } from "../../interaction/provider_continuation_state.js";
+import { chatReasoningDetailId } from "./chat_reasoning_detail.js";
+import { isProviderFailureMessage, providerFailureFromEvent, providerFailureMessage, } from "../../runtime/provider_stream_outcome.js";
+import { sseStream } from "./sse_stream.js";
+export function chatCompletionResponse(args) {
+    return {
+        id: completionId(args.id),
+        object: "chat.completion",
+        created: Math.floor(args.output.createdAtMs / 1000),
+        model: args.model,
+        choices: [
+            {
+                index: 0,
+                message: assistantMessagePayload(args.output),
+                finish_reason: interactionFinishReason(args.output),
+            },
+        ],
+        usage: usagePayload(args.output, args.modelCost),
+        dari_routing: routingPayload(args.routing, args.id, args.conversationId),
+    };
+}
+export function chatCompletionsSseStream(args) {
+    const encoder = new TextEncoder();
+    const completion = completionId(args.id);
+    const created = Math.floor(Date.now() / 1000);
+    return sseStream({
+        protocol: "openai_chat",
+        lifecycle: args,
+        start: ({ controller, snapshot, lifecycle, settle, observeTerminal }) => {
+            const send = (value) => {
+                if (!lifecycle.canWrite)
+                    return;
+                snapshot.record({ data: value });
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(value)}\n\n`));
+            };
+            const done = () => {
+                if (!lifecycle.canWrite)
+                    return;
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            };
+            const sendProviderError = (message) => {
+                send({ ...errorChunk({ completion, created, model: args.model, message: providerFailureMessage(message) }),
+                    usage: usagePayload(message, args.modelCost?.(message, true)) });
+            };
+            send(chunk({ completion, created, model: args.model, delta: {}, finishReason: null, routing: routingPayload(args.routing, args.id, args.conversationId) }));
+            send(chunk({ completion, created, model: args.model, delta: { role: "assistant" }, finishReason: null }));
+            const argumentDeltaSeen = new Set();
+            const toolCallIdsSeen = new Set();
+            const emittedToolCallIds = new Set();
+            const toolCallNamesSeen = new Set();
+            const toolCallIndexes = new Map();
+            let reasoningDeltaSeen = false;
+            let nextToolCallIndex = 0;
+            const streamIndexFor = (event) => {
+                const keys = toolCallStreamKeys(event);
+                for (const key of keys) {
+                    const existing = toolCallIndexes.get(key);
+                    if (existing !== undefined)
+                        return existing;
+                }
+                const index = typeof event.index === "number" ? event.index : nextToolCallIndex++;
+                nextToolCallIndex = Math.max(nextToolCallIndex, index + 1);
+                for (const key of keys)
+                    toolCallIndexes.set(key, index);
+                return index;
+            };
+            const markKeys = (event, target) => {
+                for (const key of toolCallStreamKeys(event))
+                    target.add(key);
+            };
+            return {
+                consume: async () => {
+                    for await (const event of args.events) {
+                        if (lifecycle.shouldStopConsuming)
+                            break;
+                        const type = event.type;
+                        if (type === "text_delta" && typeof event.delta === "string" && event.delta) {
+                            send(chunk({ completion, created, model: args.model, delta: { content: event.delta }, finishReason: null }));
+                        }
+                        else if (type === "thinking_delta" && typeof event.delta === "string" && event.delta) {
+                            reasoningDeltaSeen = true;
+                            send(chunk({ completion, created, model: args.model, delta: { reasoning_content: event.delta }, finishReason: null }));
+                        }
+                        else if (type === "toolcall_start") {
+                            const index = streamIndexFor(event);
+                            const delta = toolCallStartDelta(event, index, args.source);
+                            if (typeof delta.id === "string" && delta.id) {
+                                markKeys(event, toolCallIdsSeen);
+                                emittedToolCallIds.add(delta.id);
+                            }
+                            if (toolCallNameFromEvent(event))
+                                markKeys(event, toolCallNamesSeen);
+                            send(chunk({ completion, created, model: args.model, delta: { tool_calls: [delta] }, finishReason: null }));
+                        }
+                        else if (type === "toolcall_delta" && typeof event.delta === "string" && event.delta) {
+                            const index = streamIndexFor(event);
+                            markKeys(event, argumentDeltaSeen);
+                            send(chunk({ completion, created, model: args.model, delta: { tool_calls: [toolCallArgumentsDelta(event, index)] }, finishReason: null }));
+                        }
+                        else if (type === "toolcall_end" && isRecord(event.toolCall)) {
+                            const index = streamIndexFor(event);
+                            const keys = toolCallStreamKeys(event);
+                            const delta = toolCallEndDelta(event, index, args.source, {
+                                includeArguments: !keys.some((key) => argumentDeltaSeen.has(key)),
+                                includeId: !keys.some((key) => toolCallIdsSeen.has(key)),
+                                includeName: !keys.some((key) => toolCallNamesSeen.has(key)),
+                            });
+                            if (typeof delta.id === "string" && delta.id)
+                                emittedToolCallIds.add(delta.id);
+                            if (toolCallDeltaHasPayload(delta)) {
+                                send(chunk({ completion, created, model: args.model, delta: { tool_calls: [delta] }, finishReason: null }));
+                            }
+                        }
+                        else if (type === "done") {
+                            if (!isRecord(event.message))
+                                throw new Error("Provider stream ended without a terminal message.");
+                            observeTerminal(event.message);
+                            if (isProviderFailureMessage(event.message)) {
+                                settle({ status: "provider_error", message: event.message });
+                                sendProviderError(event.message);
+                            }
+                            else {
+                                const output = piMessageToInteractionOutput(event.message, args.source, args.request);
+                                settle({ status: "completed", message: event.message, output });
+                                const assistant = assistantMessagePayload(output);
+                                if (!reasoningDeltaSeen && typeof assistant.reasoning_content === "string" && assistant.reasoning_content) {
+                                    send(chunk({
+                                        completion,
+                                        created,
+                                        model: args.model,
+                                        delta: { reasoning_content: assistant.reasoning_content },
+                                        finishReason: null,
+                                    }));
+                                }
+                                if (Array.isArray(assistant.reasoning_details) && assistant.reasoning_details.length > 0) {
+                                    send(chunk({
+                                        completion,
+                                        created,
+                                        model: args.model,
+                                        delta: { reasoning_details: assistant.reasoning_details },
+                                        finishReason: null,
+                                    }));
+                                }
+                                const terminalToolCalls = Array.isArray(assistant.tool_calls)
+                                    ? assistant.tool_calls.flatMap((toolCall, index) => {
+                                        if (!isRecord(toolCall) || typeof toolCall.id !== "string" || emittedToolCallIds.has(toolCall.id)) {
+                                            return [];
+                                        }
+                                        return [{ index, ...toolCall }];
+                                    })
+                                    : [];
+                                if (terminalToolCalls.length > 0) {
+                                    send(chunk({
+                                        completion,
+                                        created,
+                                        model: args.model,
+                                        delta: { tool_calls: terminalToolCalls },
+                                        finishReason: null,
+                                    }));
+                                }
+                                send(chunk({
+                                    completion,
+                                    created,
+                                    model: args.model,
+                                    delta: {},
+                                    finishReason: interactionFinishReason(output),
+                                    usage: usagePayload(event.message, args.modelCost?.(event.message, false)),
+                                }));
+                            }
+                            break;
+                        }
+                        else if (type === "error") {
+                            const message = providerFailureFromEvent(event);
+                            settle({ status: "provider_error", message });
+                            sendProviderError(message);
+                            break;
+                        }
+                    }
+                },
+                emitProviderError: sendProviderError,
+                close: () => {
+                    done();
+                    controller.close();
+                },
+            };
+        },
+    });
+}
+function routingPayload(decision, requestId, conversationId) {
+    return {
+        requested_model: "dari/routing",
+        selected_model: decision.selectedModel,
+        reasoning_effort: decision.reasoningEffort,
+        reason: decision.reason,
+        request_id: requestId,
+        ...(conversationId ? { conversation_id: conversationId } : {}),
+    };
+}
+function chunk(args) {
+    return {
+        id: args.completion,
+        object: "chat.completion.chunk",
+        created: args.created,
+        model: args.model,
+        choices: [{ index: 0, delta: args.delta, finish_reason: args.finishReason }],
+        ...(args.routing ? { dari_routing: args.routing } : {}),
+        ...(args.usage ? { usage: args.usage } : {}),
+    };
+}
+function errorChunk(args) {
+    return {
+        id: args.completion,
+        object: "chat.completion.chunk",
+        created: args.created,
+        model: args.model,
+        choices: [{ index: 0, delta: {}, finish_reason: "error" }],
+        error: { message: args.message, type: "server_error", code: "provider_execution_failed" },
+    };
+}
+export function assistantMessagePayload(output) {
+    const textParts = [];
+    const reasoningParts = [];
+    const continuations = [];
+    const toolCalls = [];
+    const toolCallIds = [];
+    const reasoningDetailIds = new Set();
+    for (const item of output.items) {
+        if (item.type === "message") {
+            textParts.push(...item.content.filter((part) => part.type === "text").map((part) => part.text));
+        }
+        if (item.type === "reasoning") {
+            reasoningParts.push(...item.summary, ...item.content);
+            if (item.continuation)
+                continuations.push(item.continuation);
+        }
+        if (item.type === "tool_call") {
+            toolCalls.push(toolCallMessage(item, toolCalls.length));
+            toolCallIds.push(item.callId || `call_${toolCallIds.length}`);
+        }
+        if (item.type === "hosted_tool_call") {
+            toolCalls.push(hostedToolCallMessage(item));
+            toolCallIds.push(item.id);
+        }
+    }
+    return {
+        role: "assistant",
+        content: toolCalls.length > 0 && textParts.length === 0 ? null : textParts.join(""),
+        ...(reasoningParts.length > 0 ? { reasoning_content: reasoningParts.join("\n") } : {}),
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+        ...(continuations.length > 0
+            ? {
+                reasoning_details: continuations.map((continuation, index) => ({
+                    type: "reasoning.encrypted",
+                    id: chatReasoningDetailId(continuation, index, toolCallIds, reasoningDetailIds),
+                    data: encodeProviderContinuationState(continuation),
+                })),
+            }
+            : {}),
+    };
+}
+function hostedToolCallMessage(item) {
+    const replayPayload = chatHostedToolReplayPayload(item);
+    return {
+        id: item.id,
+        type: "function",
+        function: {
+            name: item.tool,
+            arguments: JSON.stringify(replayPayload),
+        },
+    };
+}
+export function chatHostedToolReplayPayload(item) {
+    const payload = {
+        ...item.payload,
+        type: item.providerType,
+        id: item.id,
+    };
+    if (item.status)
+        payload.status = item.status;
+    else
+        delete payload.status;
+    return payload;
+}
+function toolCallMessage(item, index) {
+    const name = item.namespace ? `${item.namespace}__${item.name}` : item.name;
+    return {
+        id: item.callId || `call_${index}`,
+        type: "function",
+        function: {
+            name,
+            arguments: typeof item.input === "string" ? item.input : JSON.stringify(item.input ?? {}),
+        },
+    };
+}
+function usagePayload(message, cost) {
+    const usage = isRecord(message.usage) ? message.usage : {};
+    const input = numeric(usage.input);
+    const cacheRead = numeric(usage.cacheRead);
+    const cacheWrite = numeric(usage.cacheWrite);
+    const prompt = input + cacheRead + cacheWrite;
+    const completion = numeric(usage.output);
+    return {
+        // Same field as OpenRouter. Null means unpriced, never a fabricated free request.
+        cost: cost ?? null,
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        // OpenAI counts cached tokens inside prompt_tokens; once cache tokens are
+        // folded in, recompute the total rather than trusting upstream totalTokens.
+        total_tokens: cacheRead || cacheWrite
+            ? prompt + completion
+            : numeric(usage.totalTokens) || prompt + completion,
+        ...(cacheRead || cacheWrite
+            ? { prompt_tokens_details: { cached_tokens: cacheRead, cache_write_tokens: cacheWrite } }
+            : {}),
+    };
+}
+function interactionFinishReason(output) {
+    if (output.stopReason === "length")
+        return "length";
+    if (output.stopReason === "tool_use")
+        return "tool_calls";
+    if (output.stopReason === "error" || output.stopReason === "aborted")
+        return "error";
+    return "stop";
+}
+function completionId(id) {
+    return `chatcmpl-${id}`;
+}
+function toolCallStartDelta(event, index, source) {
+    const toolCall = toolCallFromEvent(event);
+    const providerId = stringValue(event.toolCallId) ?? stringValue(toolCall.id);
+    const id = providerId ? providerToolCallIdentity(providerId, source).callId : undefined;
+    const name = toolCallNameFromEvent(event) ?? "tool";
+    return {
+        index,
+        ...(id ? { id } : {}),
+        type: "function",
+        function: { name, arguments: "" },
+    };
+}
+function toolCallArgumentsDelta(event, index) {
+    return { index, function: { arguments: String(event.delta ?? "") } };
+}
+function toolCallEndDelta(event, index, source, options) {
+    const toolCall = toolCallFromEvent(event);
+    const providerId = stringValue(toolCall.id);
+    const id = providerId ? providerToolCallIdentity(providerId, source).callId : undefined;
+    const name = stringValue(toolCall.name);
+    const functionDelta = {};
+    if (options.includeName && name)
+        functionDelta.name = name;
+    if (options.includeArguments) {
+        functionDelta.arguments = JSON.stringify(isRecord(toolCall.arguments) ? toolCall.arguments : {});
+    }
+    return {
+        index,
+        ...(options.includeId && id ? { id } : {}),
+        ...((options.includeId && id) || (options.includeName && name) ? { type: "function" } : {}),
+        ...(Object.keys(functionDelta).length > 0 ? { function: functionDelta } : {}),
+    };
+}
+function toolCallDeltaHasPayload(delta) {
+    return Boolean(delta.id || delta.type || (isRecord(delta.function) && Object.keys(delta.function).length > 0));
+}
+function toolCallStreamKeys(event) {
+    const keys = [];
+    const toolCall = toolCallFromEvent(event);
+    if (typeof event.index === "number")
+        keys.push(`index:${event.index}`);
+    if (typeof event.contentIndex === "number")
+        keys.push(`content:${event.contentIndex}`);
+    if (typeof event.toolCallId === "string" && event.toolCallId)
+        keys.push(`id:${event.toolCallId}`);
+    if (typeof toolCall.id === "string" && toolCall.id)
+        keys.push(`id:${toolCall.id}`);
+    return keys.length > 0 ? keys : ["unknown"];
+}
+function toolCallFromEvent(event) {
+    if (isRecord(event.toolCall))
+        return event.toolCall;
+    const partial = isRecord(event.partial) ? event.partial : {};
+    const content = Array.isArray(partial.content) ? partial.content : [];
+    const contentIndex = eventContentIndex(event);
+    const item = contentIndex === undefined ? undefined : content[contentIndex];
+    return isRecord(item) && item.type === "toolCall" ? item : {};
+}
+function eventContentIndex(event) {
+    if (typeof event.contentIndex === "number")
+        return event.contentIndex;
+    if (typeof event.index === "number")
+        return event.index;
+    return undefined;
+}
+function toolCallNameFromEvent(event) {
+    const toolCall = toolCallFromEvent(event);
+    return stringValue(event.toolName) ?? stringValue(toolCall.name);
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function numeric(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : 0;
+}

package/dist/protocol/output/chat_reasoning_detail.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderContinuationState } from "../../interaction/types.js";
+export declare function chatReasoningDetailId(continuation: ProviderContinuationState, index: number, toolCallIds: readonly string[], usedIds: Set<string>): string;

package/dist/protocol/output/chat_reasoning_detail.js

@@ -0,0 +1,13 @@
+export function chatReasoningDetailId(continuation, index, toolCallIds, usedIds) {
+    let candidate = toolCallIds[index];
+    if (!candidate
+        && continuation.kind === "openai_reasoning"
+        && continuation.providerItemId)
+        candidate = continuation.providerItemId;
+    if (!candidate || usedIds.has(candidate))
+        candidate = `reasoning_${index}`;
+    while (usedIds.has(candidate))
+        candidate = `${candidate}_${index}`;
+    usedIds.add(candidate);
+    return candidate;
+}

package/dist/protocol/output/delivered_stream_snapshot.d.ts

@@ -0,0 +1,10 @@
+/** Bounded record of protocol frames actually handed to the client stream. */
+export declare class DeliveredStreamSnapshot {
+    private readonly protocol;
+    private readonly events;
+    private encodedBytes;
+    private truncated;
+    constructor(protocol: string);
+    record(event: unknown): void;
+    body(): Record<string, unknown>;
+}

package/dist/protocol/output/delivered_stream_snapshot.js

@@ -0,0 +1,31 @@
+const MAX_SNAPSHOT_BYTES = 256 * 1024;
+/** Bounded record of protocol frames actually handed to the client stream. */
+export class DeliveredStreamSnapshot {
+    protocol;
+    events = [];
+    encodedBytes = 0;
+    truncated = false;
+    constructor(protocol) {
+        this.protocol = protocol;
+    }
+    record(event) {
+        if (this.truncated)
+            return;
+        const encoded = JSON.stringify(event);
+        const bytes = Buffer.byteLength(encoded, "utf8");
+        if (this.encodedBytes + bytes > MAX_SNAPSHOT_BYTES) {
+            this.truncated = true;
+            return;
+        }
+        this.events.push(event);
+        this.encodedBytes += bytes;
+    }
+    body() {
+        return {
+            type: "dari.stream_partial",
+            protocol: this.protocol,
+            events: this.events,
+            truncated: this.truncated,
+        };
+    }
+}

package/dist/protocol/output/openai_responses.d.ts

@@ -0,0 +1,10 @@
+import type { InteractionOutput, InteractionRequest } from "../../interaction/types.js";
+export declare function openAIResponsesResponse(args: {
+    id: string;
+    model: string;
+    output: InteractionOutput;
+    request: InteractionRequest;
+    routing: RoutingDecision;
+    conversationId?: string;
+}): Record<string, unknown>;
+import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";

package/dist/protocol/output/openai_responses.js

@@ -0,0 +1,14 @@
+import { openAIResponsesOutputItems, openAIResponsesResponseId, openAIResponsesRouting, openAIResponsesTerminal, openAIResponsesUsage, } from "./openai_responses_output.js";
+export function openAIResponsesResponse(args) {
+    return {
+        id: openAIResponsesResponseId(args.id),
+        object: "response",
+        created_at: Math.floor(args.output.createdAtMs / 1000),
+        ...openAIResponsesTerminal(args.output),
+        model: args.model,
+        output: openAIResponsesOutputItems(args.output),
+        usage: openAIResponsesUsage(args.output),
+        parallel_tool_calls: args.request.parallelToolCalls ?? true,
+        dari_routing: openAIResponsesRouting(args.routing, args.id, args.conversationId),
+    };
+}

package/dist/protocol/output/openai_responses_output.d.ts

@@ -0,0 +1,14 @@
+import type { InteractionOutput } from "../../interaction/types.js";
+export declare function openAIResponsesResponseId(requestId: string): string;
+export declare function openAIResponsesTerminal(output: Pick<InteractionOutput, "stopReason">): {
+    status: "completed" | "incomplete";
+    incomplete_details: {
+        reason: "max_output_tokens";
+    } | null;
+};
+export declare function openAIResponsesOutputItems(output: InteractionOutput): Array<Record<string, unknown>>;
+export declare function openAIResponsesOutputItem(output: InteractionOutput, item: InteractionOutput["items"][number], index: number): Record<string, unknown>;
+export declare function openAIResponsesUsage(output: Pick<InteractionOutput, "usage">): Record<string, unknown>;
+export declare function openAIResponsesRouting(decision: RoutingDecision, requestId: string, conversationId?: string): Record<string, unknown>;
+export declare function responseMessageOutputItem(id: string, text: string): Record<string, unknown>;
+import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";

package/dist/protocol/output/openai_responses_output.js

@@ -0,0 +1,125 @@
+import { encodeProviderContinuationState } from "../../interaction/provider_continuation_state.js";
+export function openAIResponsesResponseId(requestId) {
+    return `resp_${requestId}`;
+}
+export function openAIResponsesTerminal(output) {
+    return output.stopReason === "length"
+        ? { status: "incomplete", incomplete_details: { reason: "max_output_tokens" } }
+        : { status: "completed", incomplete_details: null };
+}
+export function openAIResponsesOutputItems(output) {
+    return output.items.map((item, index) => openAIResponsesOutputItem(output, item, index));
+}
+export function openAIResponsesOutputItem(output, item, index) {
+    if (item.type === "message")
+        return responseMessageItem(output, item, index);
+    if (item.type === "reasoning")
+        return responseReasoningItem(output, item, index);
+    if (item.type === "hosted_tool_call")
+        return responseHostedToolCallItem(item);
+    return responseToolCallItem(item);
+}
+export function openAIResponsesUsage(output) {
+    const inputTokens = output.usage.input + output.usage.cacheRead + output.usage.cacheWrite;
+    return {
+        input_tokens: inputTokens,
+        input_tokens_details: output.usage.cacheRead || output.usage.cacheWrite
+            ? { cached_tokens: output.usage.cacheRead, cache_write_tokens: output.usage.cacheWrite }
+            : null,
+        output_tokens: output.usage.output,
+        output_tokens_details: null,
+        total_tokens: output.usage.totalTokens || inputTokens + output.usage.output,
+    };
+}
+export function openAIResponsesRouting(decision, requestId, conversationId) {
+    return {
+        requested_model: "dari/routing",
+        selected_model: decision.selectedModel,
+        reasoning_effort: decision.reasoningEffort,
+        reason: decision.reason,
+        request_id: requestId,
+        ...(conversationId ? { conversation_id: conversationId } : {}),
+    };
+}
+export function responseMessageOutputItem(id, text) {
+    return {
+        type: "message",
+        role: "assistant",
+        id,
+        status: "completed",
+        content: [{ type: "output_text", text, annotations: [] }],
+    };
+}
+function responseMessageItem(output, item, index) {
+    const content = item.content.flatMap((part) => part.type === "text"
+        ? [{
+                type: "output_text",
+                text: part.text,
+                annotations: part.annotations ?? [],
+            }]
+        : []);
+    return {
+        ...responseMessageOutputItem(item.id ?? fallbackItemId("msg", output, index), ""),
+        content,
+        status: outputItemStatus(output),
+        ...(item.phase ? { phase: item.phase } : {}),
+    };
+}
+function responseHostedToolCallItem(item) {
+    return {
+        ...item.payload,
+        type: item.providerType,
+        id: item.id,
+        ...(item.status ? { status: item.status } : {}),
+    };
+}
+function responseReasoningItem(output, item, index) {
+    return {
+        type: "reasoning",
+        id: item.id ?? fallbackItemId("rs", output, index),
+        status: outputItemStatus(output),
+        summary: item.summary.map((text) => ({ type: "summary_text", text })),
+        ...(item.content.length
+            ? { content: item.content.map((text) => ({ type: "reasoning_text", text })) }
+            : {}),
+        ...(item.continuation
+            ? { encrypted_content: encodeProviderContinuationState(item.continuation) }
+            : {}),
+    };
+}
+function responseToolCallItem(item) {
+    const id = item.id ?? item.callId;
+    if (item.kind === "custom") {
+        return {
+            type: "custom_tool_call",
+            id,
+            call_id: item.callId,
+            ...(item.namespace ? { namespace: item.namespace } : {}),
+            name: item.name,
+            input: typeof item.input === "string" ? item.input : "",
+        };
+    }
+    return {
+        type: "function_call",
+        id,
+        call_id: item.callId,
+        ...(item.namespace ? { namespace: item.namespace } : {}),
+        name: item.name,
+        arguments: toolArgumentsString(item.input),
+        ...(item.status ? { status: item.status } : {}),
+    };
+}
+function outputItemStatus(output) {
+    return output.stopReason === "length" ? "incomplete" : "completed";
+}
+function fallbackItemId(prefix, output, index) {
+    const responseId = output.responseId?.replace(/[^A-Za-z0-9_-]/g, "_") || "routing";
+    return `${prefix}_${responseId}_${index}`.slice(0, 64);
+}
+function toolArgumentsString(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === undefined || value === null)
+        return "{}";
+    return JSON.stringify(value);
+}

package/dist/protocol/output/openai_responses_stream.d.ts

@@ -0,0 +1,18 @@
+import type { InteractionRequest, ProviderIdentity } from "../../interaction/types.js";
+import { type ProviderStreamOutcome } from "../../runtime/provider_stream_outcome.js";
+type StreamArgs = {
+    id: string;
+    model: string;
+    routing: RoutingDecision;
+    events: AsyncIterable<Record<string, unknown>>;
+    source: ProviderIdentity;
+    request: InteractionRequest;
+    conversationId?: string;
+    onFinal?: (outcome: ProviderStreamOutcome) => void;
+    beforeClose?: (outcome: ProviderStreamOutcome) => Promise<void> | void;
+    clientSignal?: AbortSignal;
+    onAbort?: () => void;
+};
+export declare function openAIResponsesSseStream(args: StreamArgs): ReadableStream<Uint8Array>;
+import { type RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+export {};