@mupt-ai/dari-gateway 0.2.0 → 0.2.1

package/dist/protocol/input/chat_completions.js

@@ -0,0 +1,212 @@
+import { isRecord, } from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../../http/errors.js";
+import { toolsByWireName } from "../../interaction/tool_identity.js";
+import { decodeUntrustedProviderContinuationState } from "../../interaction/provider_continuation_state.js";
+import { validateChatCompletionsRequest } from "./chat_completions_validation.js";
+export function chatCompletionsToInteraction(request) {
+    validateChatCompletionsRequest(request);
+    return internalChatCompletionsToInteraction(request);
+}
+// Internal Chat requests are constructed by Dari and do not use the public
+// dari/routing model constraint enforced at ingress.
+export function internalChatCompletionsToInteraction(request) {
+    const items = [];
+    const toolNames = new Map();
+    for (const [messageIndex, message] of (request.messages ?? []).entries()) {
+        if (message.role === "tool") {
+            items.push({
+                type: "tool_result",
+                callId: message.tool_call_id ?? "",
+                kind: "function",
+                name: toolNames.get(message.tool_call_id ?? ""),
+                output: messageContent(message.content),
+                outputShape: contentShape(message.content),
+            });
+            continue;
+        }
+        const reasoningItems = chatReasoningItems(message, messageIndex);
+        items.push(...reasoningItems);
+        items.push({
+            type: "message",
+            role: message.role,
+            content: messageContent(message.content),
+            contentShape: contentShape(message.content),
+        });
+        for (const [toolCallIndex, toolCall] of (message.tool_calls ?? []).entries()) {
+            const fn = toolCall.function;
+            const callId = String(toolCall.id);
+            const name = String(fn.name);
+            const hostedToolCall = chatHostedToolCall(callId, name, fn.arguments, reasoningItems, messageIndex, toolCallIndex);
+            if (hostedToolCall) {
+                items.push(hostedToolCall);
+                continue;
+            }
+            toolNames.set(callId, name);
+            items.push({
+                type: "tool_call",
+                callId,
+                kind: "function",
+                name,
+                input: typeof fn.arguments === "string" || isRecord(fn.arguments) ? fn.arguments : undefined,
+            });
+        }
+    }
+    const tools = chatTools(request.tools);
+    toolsByWireName(tools);
+    const responseFormat = toInteractionResponseFormat(request.response_format);
+    const reasoningEffort = request.reasoning_effort;
+    return {
+        sourceProtocol: request.source_protocol ?? "openai_chat",
+        model: request.model,
+        items,
+        tools,
+        toolChoice: chatToolChoice(request.tool_choice),
+        parallelToolCalls: request.parallel_tool_calls,
+        generation: {
+            temperature: request.temperature,
+            topP: request.top_p,
+            maxOutputTokens: request.max_completion_tokens ?? request.max_tokens,
+            stop: request.stop,
+        },
+        reasoning: reasoningEffort === undefined ? undefined : { effort: reasoningEffort },
+        responseFormat,
+        promptCacheKey: request.prompt_cache_key,
+        stream: request.stream === true,
+        metadata: request.metadata,
+        user: request.user,
+    };
+}
+function chatHostedToolCall(callId, name, argumentsValue, reasoningItems, messageIndex, toolCallIndex) {
+    if (name !== "web_search")
+        return null;
+    const payload = chatToolArgumentsRecord(argumentsValue);
+    if (!payload || payload.type !== "web_search_call" || payload.id !== callId)
+        return null;
+    const status = hostedToolCallStatus(payload.status, `messages.${messageIndex}.tool_calls.${toolCallIndex}.function.arguments.status`);
+    const source = reasoningItems.flatMap((item) => {
+        if (item.type !== "reasoning"
+            || item.continuation?.kind !== "openai_reasoning"
+            || !item.continuation.hostedToolCallIds?.includes(callId)) {
+            return [];
+        }
+        return [item.continuation.source];
+    })[0];
+    return {
+        type: "hosted_tool_call",
+        id: callId,
+        tool: "web_search",
+        providerType: "web_search_call",
+        ...(status ? { status } : {}),
+        payload: { ...payload },
+        ...(source ? { source } : {}),
+    };
+}
+function chatToolArgumentsRecord(value) {
+    if (isRecord(value))
+        return value;
+    if (typeof value !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function hostedToolCallStatus(value, param) {
+    if (value === undefined)
+        return undefined;
+    if (value === "in_progress"
+        || value === "searching"
+        || value === "completed"
+        || value === "incomplete"
+        || value === "failed") {
+        return value;
+    }
+    throw new HttpError(400, `${param} is not supported.`, "invalid_request_error", param);
+}
+function chatReasoningItems(message, messageIndex) {
+    if (message.role !== "assistant")
+        return [];
+    const readable = [message.reasoning_content, message.reasoning, message.reasoning_text]
+        .find((value) => typeof value === "string" && value.length > 0);
+    const continuations = (message.reasoning_details ?? []).map((detail, detailIndex) => {
+        if (detail.type !== "reasoning.encrypted" || typeof detail.data !== "string") {
+            throw invalidChatContinuation(messageIndex, detailIndex);
+        }
+        const continuation = decodeUntrustedProviderContinuationState(detail.data);
+        if (!continuation)
+            throw invalidChatContinuation(messageIndex, detailIndex);
+        return continuation;
+    });
+    if (continuations.length === 0) {
+        return readable
+            ? [{ type: "reasoning", summary: [readable], content: [] }]
+            : [];
+    }
+    return continuations.map((continuation, index) => ({
+        type: "reasoning",
+        summary: index === 0 && readable ? [readable] : [],
+        content: [],
+        source: continuation.source,
+        continuation,
+    }));
+}
+function invalidChatContinuation(messageIndex, detailIndex) {
+    const param = `messages.${messageIndex}.reasoning_details.${detailIndex}.data`;
+    return new HttpError(400, `${param} must be a Dari provider continuation envelope; raw provider state has no recoverable provider/model provenance.`, "invalid_provider_continuation_state", param);
+}
+function contentShape(content) {
+    if (content === undefined)
+        return "absent";
+    if (content === null)
+        return "null";
+    return typeof content === "string" ? "string" : "parts";
+}
+function messageContent(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    if (!Array.isArray(content))
+        return [];
+    return content.map((part) => {
+        if (part.type === "text")
+            return { type: "text", text: String(part.text) };
+        if (part.type === "tool_reference") {
+            return { type: "text", text: `Referenced tool: ${String(part.tool_name)}` };
+        }
+        const imageUrl = part.image_url;
+        const detail = imageUrl.detail;
+        return {
+            type: "image",
+            url: String(imageUrl.url),
+            ...(detail === "auto" || detail === "low" || detail === "high" || detail === "original"
+                ? { detail }
+                : {}),
+        };
+    });
+}
+function chatTools(tools) {
+    return (tools ?? []).map((tool) => {
+        const fn = tool.function;
+        return {
+            kind: "function",
+            name: String(fn.name),
+            description: typeof fn.description === "string" ? fn.description : undefined,
+            parameters: isRecord(fn.parameters) ? fn.parameters : undefined,
+            strict: typeof fn.strict === "boolean" ? fn.strict : undefined,
+        };
+    });
+}
+function chatToolChoice(choice) {
+    if (typeof choice === "string")
+        return choice;
+    if (!isRecord(choice) || !isRecord(choice.function))
+        return undefined;
+    return { kind: "function", name: String(choice.function.name) };
+}
+function toInteractionResponseFormat(format) {
+    if (format === undefined || format.type !== "json_schema")
+        return format;
+    return { type: "json_schema", ...format.json_schema };
+}

package/dist/protocol/input/chat_completions_validation.d.ts

@@ -0,0 +1,2 @@
+import { type ChatCompletionRequest } from "@mupt-ai/dari-router/policy-engine";
+export declare function validateChatCompletionsRequest(request: ChatCompletionRequest): void;

package/dist/protocol/input/chat_completions_validation.js

@@ -0,0 +1,257 @@
+import { isReasoningEffort, isRecord } from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../../http/errors.js";
+import { parseDataImageUrl } from "../../interaction/image.js";
+import { CANONICAL_ROUTER_MODEL, explicitModelId, unsupportedModelMessage } from "./router_model.js";
+import { isProtocolToolCallId, TOOL_CALL_ID_MAX_LENGTH, } from "../../interaction/tool_identity.js";
+export function validateChatCompletionsRequest(request) {
+    if (request.model !== CANONICAL_ROUTER_MODEL && explicitModelId(request.model) === null) {
+        throw new HttpError(400, unsupportedModelMessage(), "unsupported_model", "model");
+    }
+    if (!Array.isArray(request.messages) || request.messages.length === 0) {
+        throw new HttpError(400, "messages must include at least one message.", "invalid_request_error", "messages");
+    }
+    validateMessages(request.messages);
+    validateRequestOptions(request);
+    const responsesBridge = request.source_protocol === "openai_responses";
+    validateTools(request.tools, responsesBridge);
+    validateToolChoice(request.tool_choice, responsesBridge);
+    validateResponseFormat(request.response_format);
+    validateReasoning(request);
+}
+function validateMessages(messages) {
+    const pendingToolCallIds = new Set();
+    messages.forEach((message, messageIndex) => {
+        if (!isRecord(message)) {
+            throw new HttpError(400, `messages[${messageIndex}] must be an object.`, "invalid_request_error", `messages.${messageIndex}`);
+        }
+        if (typeof message.role !== "string" || !["system", "developer", "user", "assistant", "tool"].includes(message.role)) {
+            throw new HttpError(400, `Unsupported message role at messages[${messageIndex}].role.`, "invalid_request_error", `messages.${messageIndex}.role`);
+        }
+        validateMessageContent(message.content, messageIndex, message.role);
+        validateMessageToolCalls(message.tool_calls, messageIndex, message.role);
+        validateMessageReasoning(message, messageIndex);
+        if (message.role === "tool") {
+            if (!isProtocolToolCallId(message.tool_call_id)) {
+                throw new HttpError(400, `messages[${messageIndex}].tool_call_id is required for tool messages and must not exceed ${TOOL_CALL_ID_MAX_LENGTH} characters.`, "invalid_request_error", `messages.${messageIndex}.tool_call_id`);
+            }
+            if (!pendingToolCallIds.delete(message.tool_call_id)) {
+                throw new HttpError(400, `messages[${messageIndex}].tool_call_id does not match any tool_call.id in the preceding assistant tool-call exchange.`, "invalid_request_error", `messages.${messageIndex}.tool_call_id`);
+            }
+        }
+        else {
+            pendingToolCallIds.clear();
+            if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
+                for (const toolCall of message.tool_calls) {
+                    if (isRecord(toolCall) && isProtocolToolCallId(toolCall.id)) {
+                        pendingToolCallIds.add(toolCall.id);
+                    }
+                }
+            }
+        }
+        if (message.role !== "tool" && message.tool_call_id !== undefined) {
+            throw new HttpError(400, `messages[${messageIndex}].tool_call_id is only supported for tool messages.`, "invalid_request_error", `messages.${messageIndex}.tool_call_id`);
+        }
+    });
+}
+function validateMessageReasoning(message, messageIndex) {
+    const reasoningFields = ["reasoning_content", "reasoning", "reasoning_text"];
+    for (const field of reasoningFields) {
+        if (message[field] === undefined)
+            continue;
+        if (message.role !== "assistant" || typeof message[field] !== "string") {
+            throw new HttpError(400, `messages[${messageIndex}].${field} is only supported as a string on assistant messages.`, "invalid_request_error", `messages.${messageIndex}.${field}`);
+        }
+    }
+    if (message.reasoning_details === undefined)
+        return;
+    if (message.role !== "assistant" || !Array.isArray(message.reasoning_details)) {
+        throw new HttpError(400, `messages[${messageIndex}].reasoning_details must be an array on an assistant message.`, "invalid_request_error", `messages.${messageIndex}.reasoning_details`);
+    }
+    for (const [detailIndex, detail] of message.reasoning_details.entries()) {
+        if (!isRecord(detail) ||
+            detail.type !== "reasoning.encrypted" ||
+            typeof detail.id !== "string" ||
+            !detail.id ||
+            typeof detail.data !== "string" ||
+            !detail.data) {
+            throw new HttpError(400, `messages[${messageIndex}].reasoning_details[${detailIndex}] is not a supported encrypted reasoning detail.`, "invalid_request_error", `messages.${messageIndex}.reasoning_details.${detailIndex}`);
+        }
+    }
+}
+function validateMessageContent(content, messageIndex, role) {
+    if (content === undefined || content === null || typeof content === "string")
+        return;
+    if (!Array.isArray(content)) {
+        throw new HttpError(400, `messages[${messageIndex}].content must be a string, an array, or null.`, "invalid_request_error", `messages.${messageIndex}.content`);
+    }
+    content.forEach((part, partIndex) => {
+        if (!isRecord(part)) {
+            throw new HttpError(400, `Unsupported content part at messages[${messageIndex}].content[${partIndex}].`, "invalid_request_error", `messages.${messageIndex}.content.${partIndex}`);
+        }
+        if (part.type === "text") {
+            if (typeof part.text !== "string") {
+                throw new HttpError(400, `messages[${messageIndex}].content[${partIndex}].text must be a string.`, "invalid_request_error", `messages.${messageIndex}.content.${partIndex}.text`);
+            }
+            return;
+        }
+        if (part.type === "tool_reference") {
+            if (role !== "tool") {
+                throw new HttpError(400, `messages[${messageIndex}].content[${partIndex}] tool_reference blocks are only supported on tool messages.`, "invalid_request_error", `messages.${messageIndex}.content.${partIndex}.type`);
+            }
+            if (typeof part.tool_name !== "string" || !part.tool_name) {
+                throw new HttpError(400, `messages[${messageIndex}].content[${partIndex}].tool_name must be a non-empty string.`, "invalid_request_error", `messages.${messageIndex}.content.${partIndex}.tool_name`);
+            }
+            return;
+        }
+        if (part.type === "image_url") {
+            const imageUrl = part.image_url;
+            const url = isRecord(imageUrl) && typeof imageUrl.url === "string" ? imageUrl.url : "";
+            const detail = isRecord(imageUrl) ? imageUrl.detail : undefined;
+            if (detail !== undefined &&
+                detail !== null &&
+                detail !== "auto" &&
+                detail !== "low" &&
+                detail !== "high" &&
+                detail !== "original") {
+                throw new HttpError(400, `messages[${messageIndex}].content[${partIndex}].image_url.detail is not supported.`, "invalid_request_error", `messages.${messageIndex}.content.${partIndex}.image_url.detail`);
+            }
+            if (!parseDataImageUrl(url)) {
+                throw new HttpError(400, `Unsupported image_url at messages[${messageIndex}].content[${partIndex}]; use a base64 data URL.`, "invalid_request_error", `messages.${messageIndex}.content.${partIndex}.image_url`);
+            }
+            return;
+        }
+        throw new HttpError(400, `Unsupported content part at messages[${messageIndex}].content[${partIndex}].`, "invalid_request_error", `messages.${messageIndex}.content.${partIndex}.type`);
+    });
+}
+function validateMessageToolCalls(toolCalls, messageIndex, role) {
+    if (toolCalls === undefined)
+        return;
+    if (role !== "assistant") {
+        throw new HttpError(400, `messages[${messageIndex}].tool_calls is only supported for assistant messages.`, "invalid_request_error", `messages.${messageIndex}.tool_calls`);
+    }
+    if (!Array.isArray(toolCalls)) {
+        throw new HttpError(400, `messages[${messageIndex}].tool_calls must be an array.`, "invalid_request_error", `messages.${messageIndex}.tool_calls`);
+    }
+    toolCalls.forEach((toolCall, toolCallIndex) => {
+        if (!isRecord(toolCall)) {
+            throw new HttpError(400, `messages[${messageIndex}].tool_calls[${toolCallIndex}] must be an object.`, "invalid_request_error", `messages.${messageIndex}.tool_calls.${toolCallIndex}`);
+        }
+        if (toolCall.type !== undefined && toolCall.type !== "function") {
+            throw new HttpError(400, `Unsupported tool call type at messages[${messageIndex}].tool_calls[${toolCallIndex}].type.`, "invalid_request_error", `messages.${messageIndex}.tool_calls.${toolCallIndex}.type`);
+        }
+        if (!isProtocolToolCallId(toolCall.id)) {
+            throw new HttpError(400, `messages[${messageIndex}].tool_calls[${toolCallIndex}].id must be a non-empty string no longer than ${TOOL_CALL_ID_MAX_LENGTH} characters.`, "invalid_request_error", `messages.${messageIndex}.tool_calls.${toolCallIndex}.id`);
+        }
+        const fn = toolCall.function;
+        if (!isRecord(fn) || typeof fn.name !== "string" || fn.name.trim() === "") {
+            throw new HttpError(400, `messages[${messageIndex}].tool_calls[${toolCallIndex}].function.name must be a non-empty string.`, "invalid_request_error", `messages.${messageIndex}.tool_calls.${toolCallIndex}.function.name`);
+        }
+        if (fn.arguments !== undefined && typeof fn.arguments !== "string" && !isRecord(fn.arguments)) {
+            throw new HttpError(400, `messages[${messageIndex}].tool_calls[${toolCallIndex}].function.arguments must be a JSON string or object.`, "invalid_request_error", `messages.${messageIndex}.tool_calls.${toolCallIndex}.function.arguments`);
+        }
+    });
+}
+function validateRequestOptions(request) {
+    if (request.stream !== undefined && typeof request.stream !== "boolean") {
+        throw new HttpError(400, "stream must be a boolean.", "invalid_request_error", "stream");
+    }
+    if (request.prompt_cache_key !== undefined && typeof request.prompt_cache_key !== "string") {
+        throw new HttpError(400, "prompt_cache_key must be a string.", "invalid_request_error", "prompt_cache_key");
+    }
+    if (request.parallel_tool_calls !== undefined && typeof request.parallel_tool_calls !== "boolean") {
+        throw new HttpError(400, "parallel_tool_calls must be a boolean.", "invalid_request_error", "parallel_tool_calls");
+    }
+    validateNumberOption(request.temperature, "temperature");
+    validateNumberOption(request.top_p, "top_p");
+    validateNumberOption(request.max_tokens, "max_tokens");
+    validateNumberOption(request.max_completion_tokens, "max_completion_tokens");
+    if (request.stop !== undefined && typeof request.stop !== "string" && (!Array.isArray(request.stop) || request.stop.some((item) => typeof item !== "string"))) {
+        throw new HttpError(400, "stop must be a string or an array of strings.", "invalid_request_error", "stop");
+    }
+    if (request.metadata !== undefined && !isRecord(request.metadata)) {
+        throw new HttpError(400, "metadata must be an object.", "invalid_request_error", "metadata");
+    }
+    if (request.user !== undefined && typeof request.user !== "string") {
+        throw new HttpError(400, "user must be a string.", "invalid_request_error", "user");
+    }
+    const raw = request;
+    if (raw.n !== undefined && raw.n !== 1) {
+        throw new HttpError(400, "Only n=1 is supported.", "invalid_request_error", "n");
+    }
+}
+function validateReasoning(request) {
+    const raw = request;
+    if (raw.reasoning !== undefined) {
+        throw new HttpError(400, "reasoning is not supported; use reasoning_effort.", "invalid_request_error", "reasoning");
+    }
+    if (request.reasoning_effort !== undefined && !isReasoningEffort(request.reasoning_effort)) {
+        throw new HttpError(400, "reasoning_effort is not supported.", "unsupported_reasoning_effort", "reasoning_effort");
+    }
+}
+function validateNumberOption(value, param) {
+    if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value))) {
+        throw new HttpError(400, `${param} must be a number.`, "invalid_request_error", param);
+    }
+}
+function validateTools(tools, allowResponsesHostedTools) {
+    if (tools === undefined)
+        return;
+    if (!Array.isArray(tools)) {
+        throw new HttpError(400, "tools must be an array.", "invalid_request_error", "tools");
+    }
+    tools.forEach((tool, index) => {
+        if (allowResponsesHostedTools &&
+            isRecord(tool) &&
+            (tool.type === "web_search" || tool.type === "web_search_preview"))
+            return;
+        if (!isRecord(tool) || tool.type !== "function" || !isRecord(tool.function)) {
+            throw new HttpError(400, `tools[${index}] must be an OpenAI function tool.`, "invalid_request_error", `tools.${index}`);
+        }
+        const fn = tool.function;
+        if (typeof fn.name !== "string" || fn.name.trim() === "") {
+            throw new HttpError(400, `tools[${index}].function.name must be a non-empty string.`, "invalid_request_error", `tools.${index}.function.name`);
+        }
+        if (fn.description !== undefined && typeof fn.description !== "string") {
+            throw new HttpError(400, `tools[${index}].function.description must be a string.`, "invalid_request_error", `tools.${index}.function.description`);
+        }
+        if (fn.parameters !== undefined && !isRecord(fn.parameters)) {
+            throw new HttpError(400, `tools[${index}].function.parameters must be a JSON schema object.`, "invalid_request_error", `tools.${index}.function.parameters`);
+        }
+        if (fn.strict !== undefined && typeof fn.strict !== "boolean") {
+            throw new HttpError(400, `tools[${index}].function.strict must be a boolean.`, "invalid_request_error", `tools.${index}.function.strict`);
+        }
+    });
+}
+function validateToolChoice(toolChoice, allowResponsesHostedTools) {
+    if (toolChoice === undefined)
+        return;
+    if (typeof toolChoice === "string") {
+        if (["auto", "none", "required", "any"].includes(toolChoice))
+            return;
+        throw new HttpError(400, "tool_choice must be 'auto', 'none', 'required', 'any', or a function choice object.", "invalid_request_error", "tool_choice");
+    }
+    if (isRecord(toolChoice) && toolChoice.type === "function" && isRecord(toolChoice.function) && typeof toolChoice.function.name === "string" && toolChoice.function.name.trim() !== "") {
+        return;
+    }
+    if (allowResponsesHostedTools &&
+        isRecord(toolChoice) &&
+        (toolChoice.type === "web_search" || toolChoice.type === "web_search_preview"))
+        return;
+    throw new HttpError(400, "tool_choice must be 'auto', 'none', 'required', 'any', or a function choice object.", "invalid_request_error", "tool_choice");
+}
+function validateResponseFormat(format) {
+    if (format === undefined)
+        return;
+    if (!isRecord(format) || typeof format.type !== "string") {
+        throw new HttpError(400, "response_format must be an object with a supported type.", "invalid_request_error", "response_format");
+    }
+    if (format.type === "text" || format.type === "json_object")
+        return;
+    if (format.type !== "json_schema") {
+        throw new HttpError(400, "response_format.type is not supported.", "invalid_request_error", "response_format.type");
+    }
+    const jsonSchema = format.json_schema;
+    if (!isRecord(jsonSchema) || typeof jsonSchema.name !== "string" || jsonSchema.name.trim() === "" || !isRecord(jsonSchema.schema)) {
+        throw new HttpError(400, "response_format.json_schema must include name and schema.", "invalid_request_error", "response_format.json_schema");
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { InteractionRequest } from "../../interaction/types.js";
+export declare function openAIResponsesToInteraction(payload: Record<string, unknown>): InteractionRequest;