@mupt-ai/dari-gateway 0.2.0 → 0.2.1

package/dist/protocol/input/router_model.js

@@ -0,0 +1,43 @@
+/* The router exposes one logical model, `dari/routing`. Some client protocols
+   need protocol-specific synonyms for it; each synonym set lives here beside
+   the canonical id, scoped by protocol, so a future set for another protocol
+   (e.g. Codex) slots in alongside rather than widening a shared one.
+
+   Anthropic: Claude Desktop / Cowork only mark a discovered model "usable"
+   when its id maps to a Claude family tier, so the Anthropic-facing surfaces
+   accept bare tier names. The alias carries no routing meaning — the selector
+   decides the executed model — it only keeps every tier a harness can emit
+   (fable main threads, opus subagents, haiku background work) funneling into
+   the router instead of leaking to a direct provider call. */
+export const CANONICAL_ROUTER_MODEL = "dari/routing";
+/* Full anthropicFamilyTier enum per Anthropic's third-party gateway docs,
+   ordered most to least capable; discovery advertises them in this order. */
+export const ANTHROPIC_ROUTER_MODEL_TIERS = ["mythos", "opus", "fable", "sonnet", "haiku"];
+const ANTHROPIC_ROUTER_MODELS = new Set([CANONICAL_ROUTER_MODEL, ...ANTHROPIC_ROUTER_MODEL_TIERS]);
+/* Claude Code's subagent bootstrap resolves tiers to concrete ids before the
+   request leaves the client (wire-captured live: Task spawns emit
+   `claude-opus-5` even when the session model is dari/routing), so concrete
+   Claude-family ids are synonyms too — both bare (`claude-opus-5`) and
+   provider-prefixed (`anthropic/claude-opus-5`) forms. */
+const ANTHROPIC_MODEL_ID_PATTERN = /^(anthropic\/)?claude-[a-z0-9][a-z0-9.-]*$/i;
+export function isAnthropicRouterModel(model) {
+    return ANTHROPIC_ROUTER_MODELS.has(model) || ANTHROPIC_MODEL_ID_PATTERN.test(model);
+}
+/* An explicit model, `dari/model/<catalog id>`, serves exactly that enabled
+   model without selection, so a client's model picker can switch models. It
+   is a separate namespace so the synonyms above, which Claude Code subagents
+   emit, keep routing. */
+export const EXPLICIT_MODEL_PREFIX = "dari/model/";
+export function explicitModelId(model) {
+    if (!model?.startsWith(EXPLICIT_MODEL_PREFIX))
+        return null;
+    const id = model.slice(EXPLICIT_MODEL_PREFIX.length);
+    return id.length > 0 ? id : null;
+}
+export function explicitModelSlug(modelId) {
+    return EXPLICIT_MODEL_PREFIX + modelId;
+}
+const UNSUPPORTED_MODEL_MESSAGE = `Only model '${CANONICAL_ROUTER_MODEL}' or '${EXPLICIT_MODEL_PREFIX}<model>' is supported.`;
+export function unsupportedModelMessage() {
+    return UNSUPPORTED_MODEL_MESSAGE;
+}

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

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

package/dist/protocol/output/anthropic_messages.js

@@ -0,0 +1,15 @@
+import { anthropicContent, anthropicMessageId, anthropicRouting, anthropicStopReason, anthropicUsage, } from "./anthropic_messages_output.js";
+export function anthropicMessagesResponse(args) {
+    return {
+        id: anthropicMessageId(args.id),
+        type: "message",
+        role: "assistant",
+        model: args.model,
+        content: anthropicContent(args.output),
+        stop_reason: anthropicStopReason(args.output),
+        stop_sequence: null,
+        usage: anthropicUsage(args.output),
+        ...(args.output.safeguardResults ? { safeguard_results: args.output.safeguardResults } : {}),
+        dari_routing: anthropicRouting(args.routing, args.id, args.conversationId),
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { InteractionOutput } from "../../interaction/types.js";
+import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+export declare function anthropicMessageId(requestId: string): string;
+export declare function anthropicContent(output: InteractionOutput): Array<Record<string, unknown>>;
+export declare function anthropicReasoningBlock(item: Extract<InteractionOutput["items"][number], {
+    type: "reasoning";
+}>): Record<string, unknown>;
+export declare function anthropicStopReason(output: Pick<InteractionOutput, "stopReason">): string;
+export declare function anthropicUsage(output: Pick<InteractionOutput, "usage">): Record<string, unknown>;
+export declare function anthropicRouting(decision: RoutingDecision, requestId: string, conversationId?: string): Record<string, unknown>;

package/dist/protocol/output/anthropic_messages_output.js

@@ -0,0 +1,124 @@
+import { parseDataImageUrl } from "../../interaction/image.js";
+import { encodeProviderContinuationState } from "../../interaction/provider_continuation_state.js";
+import { encodePortableReasoningState } from "../../interaction/portable_reasoning_state.js";
+export function anthropicMessageId(requestId) {
+    return `msg_${requestId.replace(/[^A-Za-z0-9_-]/g, "_")}`.slice(0, 64);
+}
+export function anthropicContent(output) {
+    const content = [];
+    for (const item of output.items) {
+        if (item.type === "reasoning") {
+            content.push(anthropicReasoningBlock(item));
+            continue;
+        }
+        if (item.type === "tool_call") {
+            content.push({
+                type: "tool_use",
+                id: item.callId,
+                name: item.namespace ? `${item.namespace}__${item.name}` : item.name,
+                input: toolInput(item.kind, item.input),
+            });
+            continue;
+        }
+        if (item.type === "hosted_tool_call") {
+            // Render server tool use and tool search results for Anthropic protocol.
+            if (item.tool === "server_tool_use") {
+                content.push({
+                    type: "server_tool_use",
+                    id: item.serverToolUseId ?? item.id,
+                    name: item.serverToolName ?? "tool",
+                    input: item.serverToolInput ?? {},
+                });
+            }
+            else if (item.tool === "tool_search") {
+                content.push({
+                    type: "tool_search_tool_result",
+                    tool_use_id: item.serverToolUseId ?? item.id,
+                    content: (item.serverToolResult ?? []).map((ref) => ({
+                        type: "tool_reference",
+                        tool_name: ref.toolName,
+                    })),
+                });
+            }
+            continue;
+        }
+        for (const part of item.content) {
+            if (part.type === "text") {
+                content.push({ type: "text", text: part.text });
+                continue;
+            }
+            if (part.type === "tool_reference") {
+                content.push({ type: "text", text: `Referenced tool: ${part.toolName}` });
+                continue;
+            }
+            const image = parseDataImageUrl(part.url);
+            if (!image)
+                throw new Error("Anthropic output images must use base64 data URLs.");
+            content.push({
+                type: "image",
+                source: { type: "base64", media_type: image.mimeType, data: image.data },
+            });
+        }
+    }
+    return content.length > 0 ? content : [{ type: "text", text: "" }];
+}
+export function anthropicReasoningBlock(item) {
+    const encoded = item.continuation
+        ? encodeProviderContinuationState(item.continuation)
+        : encodePortableReasoningState({ source: item.source, itemId: item.id });
+    if (item.continuation?.kind === "anthropic_redacted_thinking") {
+        return { type: "redacted_thinking", data: encoded };
+    }
+    return {
+        type: "thinking",
+        thinking: item.continuation?.kind === "anthropic_thinking"
+            ? item.continuation.thinking
+            : [...item.summary, ...item.content].join("\n"),
+        signature: encoded,
+    };
+}
+export function anthropicStopReason(output) {
+    if (output.stopReason === "length")
+        return "max_tokens";
+    if (output.stopReason === "tool_use")
+        return "tool_use";
+    return "end_turn";
+}
+export function anthropicUsage(output) {
+    return {
+        input_tokens: output.usage.input,
+        cache_creation_input_tokens: output.usage.cacheWrite,
+        cache_read_input_tokens: output.usage.cacheRead,
+        output_tokens: output.usage.output,
+    };
+}
+export function anthropicRouting(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 } : {}),
+        ...(decision.leaseTurnsRemaining === undefined
+            ? {}
+            : { lease_turns_remaining: decision.leaseTurnsRemaining }),
+    };
+}
+function toolInput(kind, value) {
+    if (kind === "custom")
+        return { input: typeof value === "string" ? value : "" };
+    if (value && typeof value === "object")
+        return value;
+    if (typeof value !== "string" || !value)
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { InteractionRequest, ProviderIdentity } from "../../interaction/types.js";
+import { type ProviderStreamOutcome } from "../../runtime/provider_stream_outcome.js";
+export declare function anthropicMessagesSseStream(args: {
+    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;
+}): ReadableStream<Uint8Array>;
+import { type RoutingDecision } from "@mupt-ai/dari-router/policy-engine";

package/dist/protocol/output/anthropic_messages_stream.js

@@ -0,0 +1,267 @@
+import { piMessageToInteractionOutput } from "../../providers/pi_output.js";
+import { providerToolCallIdentity } from "../../interaction/tool_identity.js";
+import { isProviderFailureMessage, providerFailureFromEvent, providerFailureMessage, } from "../../runtime/provider_stream_outcome.js";
+import { sseStream } from "./sse_stream.js";
+import { anthropicMessageId, anthropicReasoningBlock, anthropicRouting, anthropicStopReason, anthropicUsage, } from "./anthropic_messages_output.js";
+export function anthropicMessagesSseStream(args) {
+    const encoder = new TextEncoder();
+    const id = anthropicMessageId(args.id);
+    return sseStream({
+        protocol: "anthropic_messages",
+        lifecycle: args,
+        start: ({ controller, snapshot, lifecycle, settle, observeTerminal }) => {
+            const send = (event, payload) => {
+                if (!lifecycle.canWrite)
+                    return;
+                snapshot.record({ event, data: payload });
+                controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`));
+            };
+            const sendProviderError = (message) => {
+                send("error", {
+                    type: "error",
+                    error: { type: "api_error", message: providerFailureMessage(message) },
+                });
+            };
+            send("message_start", {
+                type: "message_start",
+                message: {
+                    id,
+                    type: "message",
+                    role: "assistant",
+                    model: args.model,
+                    content: [],
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: 0, output_tokens: 0 },
+                    dari_routing: anthropicRouting(args.routing, args.id, args.conversationId),
+                },
+            });
+            const argumentDeltaIndexes = new Set();
+            const redactedThinkingIndexes = new Set();
+            const thinkingTextByIndex = new Map();
+            return {
+                consume: async () => {
+                    for await (const event of args.events) {
+                        if (lifecycle.shouldStopConsuming)
+                            break;
+                        const type = event.type;
+                        const index = contentIndex(event);
+                        if (type === "text_start" && index !== null) {
+                            send("content_block_start", {
+                                type: "content_block_start",
+                                index,
+                                content_block: { type: "text", text: "" },
+                            });
+                        }
+                        else if (type === "text_delta" && index !== null && typeof event.delta === "string") {
+                            send("content_block_delta", {
+                                type: "content_block_delta",
+                                index,
+                                delta: { type: "text_delta", text: event.delta },
+                            });
+                        }
+                        else if (type === "text_end" && index !== null) {
+                            send("content_block_stop", { type: "content_block_stop", index });
+                        }
+                        else if (type === "thinking_start" && index !== null) {
+                            thinkingTextByIndex.set(index, "");
+                            const reasoning = reasoningFromPartial(event.partial, index, args.source, args.request);
+                            if (reasoning?.continuation?.kind === "anthropic_redacted_thinking") {
+                                redactedThinkingIndexes.add(index);
+                                send("content_block_start", {
+                                    type: "content_block_start",
+                                    index,
+                                    content_block: anthropicReasoningBlock(reasoning),
+                                });
+                            }
+                            else {
+                                send("content_block_start", {
+                                    type: "content_block_start",
+                                    index,
+                                    content_block: { type: "thinking", thinking: "", signature: "" },
+                                });
+                            }
+                        }
+                        else if (type === "thinking_delta" && index !== null && typeof event.delta === "string") {
+                            if (!redactedThinkingIndexes.has(index)) {
+                                thinkingTextByIndex.set(index, `${thinkingTextByIndex.get(index) ?? ""}${event.delta}`);
+                                send("content_block_delta", {
+                                    type: "content_block_delta",
+                                    index,
+                                    delta: { type: "thinking_delta", thinking: event.delta },
+                                });
+                            }
+                        }
+                        else if (type === "thinking_end" && index !== null) {
+                            if (!redactedThinkingIndexes.has(index)) {
+                                const reasoning = reasoningFromPartial(event.partial, index, args.source, args.request);
+                                const thinkingText = thinkingTextByIndex.get(index) ?? "";
+                                const fallbackReasoning = {
+                                    type: "reasoning",
+                                    summary: thinkingText ? [thinkingText] : [],
+                                    content: [],
+                                    source: args.source,
+                                };
+                                const block = anthropicReasoningBlock(reasoning ?? fallbackReasoning);
+                                const signature = String(block.signature);
+                                send("content_block_delta", {
+                                    type: "content_block_delta",
+                                    index,
+                                    delta: { type: "signature_delta", signature },
+                                });
+                            }
+                            thinkingTextByIndex.delete(index);
+                            send("content_block_stop", { type: "content_block_stop", index });
+                        }
+                        else if (type === "toolcall_start" && index !== null) {
+                            const toolCall = toolCallFromEvent(event);
+                            const providerId = stringValue(event.toolCallId) ?? stringValue(toolCall.id) ?? `toolu_${index}`;
+                            const identity = providerToolCallIdentity(providerId, args.source);
+                            send("content_block_start", {
+                                type: "content_block_start",
+                                index,
+                                content_block: {
+                                    type: "tool_use",
+                                    id: identity.callId,
+                                    name: stringValue(event.toolName) ?? stringValue(toolCall.name) ?? "tool",
+                                    input: {},
+                                },
+                            });
+                        }
+                        else if (type === "toolcall_delta" && index !== null && typeof event.delta === "string") {
+                            argumentDeltaIndexes.add(index);
+                            send("content_block_delta", {
+                                type: "content_block_delta",
+                                index,
+                                delta: { type: "input_json_delta", partial_json: event.delta },
+                            });
+                        }
+                        else if (type === "toolcall_end" && index !== null) {
+                            if (!argumentDeltaIndexes.has(index)) {
+                                const toolCall = toolCallFromEvent(event);
+                                send("content_block_delta", {
+                                    type: "content_block_delta",
+                                    index,
+                                    delta: {
+                                        type: "input_json_delta",
+                                        partial_json: JSON.stringify(isRecord(toolCall.arguments) ? toolCall.arguments : {}),
+                                    },
+                                });
+                            }
+                            send("content_block_stop", { type: "content_block_stop", index });
+                        }
+                        else if (type === "server_tool_call_start" && index !== null) {
+                            const serverToolCall = isRecord(event.serverToolCall) ? event.serverToolCall : {};
+                            const id = stringValue(serverToolCall.id) ?? `st_${index}`;
+                            send("content_block_start", {
+                                type: "content_block_start",
+                                index,
+                                content_block: {
+                                    type: "server_tool_use",
+                                    id,
+                                    name: stringValue(serverToolCall.name) ?? "tool_search_tool",
+                                    input: {},
+                                },
+                            });
+                            send("content_block_delta", {
+                                type: "content_block_delta",
+                                index,
+                                delta: {
+                                    type: "input_json_delta",
+                                    partial_json: JSON.stringify(isRecord(serverToolCall.arguments) ? serverToolCall.arguments : {}),
+                                },
+                            });
+                        }
+                        else if (type === "server_tool_call_end" && index !== null) {
+                            send("content_block_stop", { type: "content_block_stop", index });
+                        }
+                        else if (type === "tool_search_result_start" && index !== null) {
+                            const result = isRecord(event.toolSearchResult) ? event.toolSearchResult : {};
+                            const content = Array.isArray(result.content) ? result.content.map((ref) => {
+                                if (isRecord(ref))
+                                    return { type: "tool_reference", tool_name: String(ref.tool_name ?? "") };
+                                return ref;
+                            }) : [];
+                            send("content_block_start", {
+                                type: "content_block_start",
+                                index,
+                                content_block: {
+                                    type: "tool_search_tool_result",
+                                    tool_use_id: String(result.toolUseId ?? ""),
+                                    content,
+                                },
+                            });
+                        }
+                        else if (type === "tool_search_result_end" && index !== null) {
+                            send("content_block_stop", { type: "content_block_stop", index });
+                        }
+                        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 });
+                                send("message_delta", {
+                                    type: "message_delta",
+                                    delta: {
+                                        stop_reason: anthropicStopReason(output),
+                                        stop_sequence: null,
+                                        ...(output.safeguardResults ? { safeguard_results: output.safeguardResults } : {}),
+                                    },
+                                    // message_start goes out before the provider answers, so the
+                                    // cumulative input and cache counts ride here, as on Anthropic.
+                                    // Claude Code sizes its context window from them.
+                                    usage: anthropicUsage(output),
+                                });
+                            }
+                            break;
+                        }
+                        else if (type === "error") {
+                            const message = providerFailureFromEvent(event);
+                            settle({ status: "provider_error", message });
+                            sendProviderError(message);
+                            break;
+                        }
+                    }
+                },
+                emitProviderError: sendProviderError,
+                close: (outcome) => {
+                    if (outcome.status === "completed") {
+                        send("message_stop", { type: "message_stop" });
+                    }
+                    controller.close();
+                },
+            };
+        },
+    });
+}
+function reasoningFromPartial(partial, index, source, request) {
+    if (!isRecord(partial))
+        return null;
+    const output = piMessageToInteractionOutput(partial, source, request);
+    const item = output.items[index];
+    return item?.type === "reasoning" ? item : null;
+}
+function contentIndex(event) {
+    if (typeof event.contentIndex === "number")
+        return event.contentIndex;
+    return typeof event.index === "number" ? event.index : null;
+}
+function toolCallFromEvent(event) {
+    if (isRecord(event.toolCall))
+        return event.toolCall;
+    if (!isRecord(event.partial) || !Array.isArray(event.partial.content))
+        return {};
+    const index = contentIndex(event);
+    const block = index === null ? undefined : event.partial.content[index];
+    return isRecord(block) && block.type === "toolCall" ? block : {};
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";

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

@@ -0,0 +1,29 @@
+import { type ChatMessage, type RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+import type { InteractionOutput, InteractionRequest, ProviderIdentity } from "../../interaction/types.js";
+import { type ProviderStreamOutcome } from "../../runtime/provider_stream_outcome.js";
+export declare function chatCompletionResponse(args: {
+    id: string;
+    model: string;
+    output: InteractionOutput;
+    modelCost?: number | null;
+    routing: RoutingDecision;
+    conversationId?: string;
+}): Record<string, unknown>;
+export declare function chatCompletionsSseStream(args: {
+    id: string;
+    model: string;
+    routing: RoutingDecision;
+    events: AsyncIterable<Record<string, unknown>>;
+    source: ProviderIdentity;
+    request: InteractionRequest;
+    conversationId?: string;
+    onFinal?: (outcome: ProviderStreamOutcome) => void;
+    modelCost?: (message: Record<string, unknown>, failed: boolean) => number | null;
+    beforeClose?: (outcome: ProviderStreamOutcome) => Promise<void> | void;
+    clientSignal?: AbortSignal;
+    onAbort?: () => void;
+}): ReadableStream<Uint8Array>;
+export declare function assistantMessagePayload(output: InteractionOutput): ChatMessage;
+export declare function chatHostedToolReplayPayload(item: Extract<InteractionOutput["items"][number], {
+    type: "hosted_tool_call";
+}>): Record<string, unknown>;