@bolt-foundry/gambit 0.8.6-rc.6 → 0.8.6

package/esm/src/server_openresponses.js

@@ -1,687 +0,0 @@
-const jsonResponse = (body, status = 200) => new Response(JSON.stringify(body), {
-    status,
-    headers: { "content-type": "application/json" },
-});
-function parseBodyObject(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("Request body must be a JSON object");
-    }
-    return value;
-}
-function toTextPart(role, value) {
-    if (typeof value === "string") {
-        return {
-            type: role === "assistant" ? "output_text" : "input_text",
-            text: value,
-        };
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return null;
-    const record = value;
-    const text = typeof record.text === "string" ? record.text : "";
-    if (!text)
-        return null;
-    const type = typeof record.type === "string" ? record.type : "";
-    if (type === "output_text")
-        return { type: "output_text", text };
-    if (type === "input_text")
-        return { type: "input_text", text };
-    return {
-        type: role === "assistant" ? "output_text" : "input_text",
-        text,
-    };
-}
-function normalizeMessageItem(item) {
-    const role = item.role;
-    if (role !== "system" && role !== "user" && role !== "assistant") {
-        throw new Error("message.role must be system, user, or assistant");
-    }
-    const rawContent = item.content;
-    const content = Array.isArray(rawContent)
-        ? rawContent.map((part) => toTextPart(role, part)).filter((part) => Boolean(part))
-        : [toTextPart(role, rawContent)].filter((part) => Boolean(part));
-    if (content.length === 0) {
-        throw new Error("message.content must include text");
-    }
-    return {
-        type: "message",
-        role,
-        content,
-        id: typeof item.id === "string" ? item.id : undefined,
-    };
-}
-function asJsonValue(value) {
-    if (value === null || typeof value === "string" || typeof value === "number" ||
-        typeof value === "boolean") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => asJsonValue(entry));
-    }
-    if (value && typeof value === "object") {
-        const out = {};
-        for (const [key, entry] of Object.entries(value)) {
-            out[key] = asJsonValue(entry);
-        }
-        return out;
-    }
-    return String(value);
-}
-function normalizeInputItems(input) {
-    if (typeof input === "string") {
-        return [{
-                type: "message",
-                role: "user",
-                content: [{ type: "input_text", text: input }],
-            }];
-    }
-    const arr = Array.isArray(input) ? input : [input];
-    const items = [];
-    for (const raw of arr) {
-        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-            throw new Error("input items must be objects");
-        }
-        const item = raw;
-        const type = typeof item.type === "string" ? item.type : "";
-        if (type === "message") {
-            const normalized = normalizeMessageItem(item);
-            if (normalized)
-                items.push(normalized);
-            continue;
-        }
-        if (type === "function_call") {
-            const callId = item.call_id;
-            const name = item.name;
-            const args = item.arguments;
-            if (typeof callId !== "string" || typeof name !== "string" ||
-                typeof args !== "string") {
-                throw new Error("function_call requires call_id, name, and arguments strings");
-            }
-            items.push({
-                type: "function_call",
-                call_id: callId,
-                name,
-                arguments: args,
-                id: typeof item.id === "string" ? item.id : undefined,
-            });
-            continue;
-        }
-        if (type === "function_call_output") {
-            const callId = item.call_id;
-            const output = item.output;
-            if (typeof callId !== "string" || typeof output !== "string") {
-                throw new Error("function_call_output requires call_id and output strings");
-            }
-            items.push({
-                type: "function_call_output",
-                call_id: callId,
-                output,
-                id: typeof item.id === "string" ? item.id : undefined,
-            });
-            continue;
-        }
-        if (type.includes(":")) {
-            const data = Object.hasOwn(item, "data")
-                ? asJsonValue(item.data)
-                : Object.entries(item)
-                    .filter(([key]) => key !== "type" && key !== "id")
-                    .reduce((acc, [key, value]) => {
-                    acc[key] = asJsonValue(value);
-                    return acc;
-                }, {});
-            items.push({
-                type: type,
-                id: typeof item.id === "string" ? item.id : undefined,
-                data,
-                // this predates the lint rule
-            });
-            continue;
-        }
-        throw new Error(`Unsupported input item type: ${type || "(missing type)"}`);
-    }
-    return items;
-}
-function normalizeTools(tools) {
-    if (!Array.isArray(tools) || tools.length === 0)
-        return undefined;
-    const out = [];
-    for (const raw of tools) {
-        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-            throw new Error("tools entries must be objects");
-        }
-        const item = raw;
-        const type = typeof item.type === "string" ? item.type : "";
-        if (type !== "function")
-            continue;
-        const nested = item.function;
-        if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-            const fn = nested;
-            const name = fn.name;
-            if (typeof name !== "string" || !name) {
-                throw new Error("tool.function.name is required");
-            }
-            out.push({
-                type: "function",
-                function: {
-                    name,
-                    description: typeof fn.description === "string"
-                        ? fn.description
-                        : undefined,
-                    parameters: (fn.parameters &&
-                        typeof fn.parameters === "object" &&
-                        !Array.isArray(fn.parameters))
-                        ? fn.parameters
-                        : {},
-                },
-            });
-            continue;
-        }
-        const name = item.name;
-        if (typeof name !== "string" || !name) {
-            throw new Error("tool.name is required");
-        }
-        out.push({
-            type: "function",
-            function: {
-                name,
-                description: typeof item.description === "string"
-                    ? item.description
-                    : undefined,
-                parameters: (item.parameters &&
-                    typeof item.parameters === "object" &&
-                    !Array.isArray(item.parameters))
-                    ? item.parameters
-                    : {},
-            },
-        });
-    }
-    return out.length ? out : undefined;
-}
-function normalizeToolChoice(choice) {
-    if (!choice)
-        return undefined;
-    if (choice === "none" || choice === "auto" || choice === "required") {
-        return choice;
-    }
-    if (!choice || typeof choice !== "object" || Array.isArray(choice)) {
-        return undefined;
-    }
-    const record = choice;
-    if (record.type === "allowed_tools" && Array.isArray(record.tools)) {
-        const tools = record.tools
-            .map((entry) => {
-            if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-                return null;
-            }
-            const tool = entry;
-            if (tool.type !== "function" || typeof tool.name !== "string") {
-                return null;
-            }
-            return { type: "function", name: tool.name };
-        })
-            .filter((entry) => Boolean(entry));
-        if (tools.length === 0)
-            return undefined;
-        const mode = record.mode === "none" || record.mode === "auto" ||
-            record.mode === "required"
-            ? record.mode
-            : undefined;
-        return { type: "allowed_tools", tools, mode };
-    }
-    if (record.type !== "function")
-        return undefined;
-    if (record.function && typeof record.function === "object") {
-        const fn = record.function;
-        if (typeof fn.name === "string" && fn.name.length > 0) {
-            return { type: "function", function: { name: fn.name } };
-        }
-    }
-    if (typeof record.name === "string" && record.name.length > 0) {
-        return { type: "function", function: { name: record.name } };
-    }
-    return undefined;
-}
-function sseFrame(event) {
-    const encoder = new TextEncoder();
-    const type = event && typeof event === "object" && !Array.isArray(event) &&
-        typeof event.type === "string"
-        ? event.type
-        : null;
-    if (type) {
-        return encoder.encode(`event: ${type}\ndata: ${JSON.stringify(event)}\n\n`);
-    }
-    return encoder.encode(`data: ${JSON.stringify(event)}\n\n`);
-}
-function toStrictContentPart(part) {
-    if (part.type === "output_text") {
-        return {
-            type: "output_text",
-            text: part.text,
-            annotations: [],
-            logprobs: [],
-        };
-    }
-    return {
-        type: part.type,
-        text: part.text,
-    };
-}
-function toStrictResponseItem(item, index) {
-    if (item.type === "message") {
-        return {
-            type: "message",
-            id: item.id ?? `msg_${index + 1}`,
-            status: "completed",
-            role: item.role,
-            content: item.content.map((part) => toStrictContentPart(part)),
-        };
-    }
-    if (item.type === "function_call") {
-        return {
-            type: "function_call",
-            id: item.id ?? item.call_id,
-            call_id: item.call_id,
-            name: item.name,
-            arguments: item.arguments,
-            status: "completed",
-        };
-    }
-    if (item.type === "function_call_output") {
-        return {
-            type: "function_call_output",
-            id: item.id ?? `${item.call_id}_out`,
-            call_id: item.call_id,
-            output: item.output,
-            status: "completed",
-        };
-    }
-    if (item.type === "reasoning") {
-        return {
-            type: "reasoning",
-            id: item.id ?? `rs_${index + 1}`,
-            content: (item.content ?? []).map((part) => toStrictContentPart(part)),
-            summary: item.summary.map((part) => toStrictContentPart(part)),
-            encrypted_content: item.encrypted_content ?? null,
-        };
-    }
-    return {
-        type: item.type,
-        id: item.id ?? `ext_${index + 1}`,
-        data: item.data,
-        status: "completed",
-    };
-}
-function toStrictTools(tools) {
-    if (!tools || tools.length === 0)
-        return [];
-    return tools.map((tool) => ({
-        type: "function",
-        name: tool.function.name,
-        description: tool.function.description ?? null,
-        parameters: tool.function.parameters ?? null,
-        strict: false,
-    }));
-}
-function toStrictToolChoice(choice) {
-    if (!choice)
-        return "auto";
-    if (choice === "none" || choice === "auto" || choice === "required") {
-        return choice;
-    }
-    if (choice.type === "allowed_tools") {
-        return {
-            type: "allowed_tools",
-            tools: choice.tools,
-            mode: choice.mode ?? "auto",
-        };
-    }
-    return { type: "function", name: choice.function.name };
-}
-function toStrictResponseResource(args) {
-    const now = Math.floor(Date.now() / 1000);
-    const createdAt = args.response.created_at ?? args.response.created ?? now;
-    const status = args.statusOverride ?? args.response.status ?? "completed";
-    const usage = args.response.usage
-        ? {
-            input_tokens: args.response.usage.promptTokens ?? 0,
-            output_tokens: args.response.usage.completionTokens ?? 0,
-            total_tokens: args.response.usage.totalTokens ?? 0,
-            input_tokens_details: {
-                cached_tokens: 0,
-            },
-            output_tokens_details: {
-                reasoning_tokens: args.response.usage.reasoningTokens ?? 0,
-            },
-        }
-        : null;
-    return {
-        id: args.response.id,
-        object: "response",
-        created_at: createdAt,
-        completed_at: status === "completed" ? now : null,
-        status,
-        incomplete_details: null,
-        model: args.response.model ?? args.request.model,
-        previous_response_id: args.request.previous_response_id ?? null,
-        instructions: args.request.instructions ?? null,
-        output: (args.response.output ?? []).map((item, idx) => toStrictResponseItem(item, idx)),
-        error: args.response.error ?? null,
-        tools: toStrictTools(args.request.tools),
-        tool_choice: toStrictToolChoice(args.request.tool_choice),
-        truncation: args.response.truncation ?? args.request.truncation ??
-            "disabled",
-        parallel_tool_calls: args.response.parallel_tool_calls ??
-            args.request.parallel_tool_calls ?? false,
-        text: args.response.text
-            ? asJsonValue(args.response.text)
-            : args.request.text
-                ? asJsonValue(args.request.text)
-                : { format: { type: "text" } },
-        top_p: args.response.top_p ?? args.request.top_p ?? 1,
-        presence_penalty: args.response.presence_penalty ??
-            args.request.presence_penalty ?? 0,
-        frequency_penalty: args.response.frequency_penalty ??
-            args.request.frequency_penalty ?? 0,
-        top_logprobs: args.response.top_logprobs ?? args.request.top_logprobs ?? 0,
-        temperature: args.response.temperature ?? args.request.temperature ?? 1,
-        reasoning: args.request.reasoning
-            ? {
-                effort: args.request.reasoning.effort ?? null,
-                summary: args.request.reasoning.summary ?? null,
-            }
-            : null,
-        usage,
-        max_output_tokens: args.request.max_output_tokens ?? null,
-        max_tool_calls: args.request.max_tool_calls ?? null,
-        store: args.response.store ?? args.request.store ?? false,
-        background: args.response.background ?? args.request.background ?? false,
-        service_tier: args.response.service_tier ?? args.request.service_tier ??
-            "default",
-        metadata: args.request.metadata ? asJsonValue(args.request.metadata) : {},
-        safety_identifier: args.response.safety_identifier ??
-            args.request.safety_identifier ?? null,
-        prompt_cache_key: args.response.prompt_cache_key ??
-            args.request.prompt_cache_key ?? null,
-    };
-}
-export async function handleOpenResponsesRequest(args) {
-    const url = new URL(args.req.url);
-    if (url.pathname !== "/v1/responses")
-        return null;
-    if (args.req.method !== "POST") {
-        return new Response("Method not allowed", { status: 405 });
-    }
-    if (!args.modelProvider.responses) {
-        return jsonResponse({ error: "Configured provider does not support responses." }, 501);
-    }
-    try {
-        const body = parseBodyObject(await args.req.json());
-        const model = typeof body.model === "string" ? body.model : undefined;
-        if (!model) {
-            throw new Error("model is required");
-        }
-        const input = normalizeInputItems(body.input);
-        const stream = body.stream === true;
-        const instructions = typeof body.instructions === "string"
-            ? body.instructions
-            : undefined;
-        const previousResponseId = typeof body.previous_response_id === "string"
-            ? body.previous_response_id
-            : undefined;
-        const store = typeof body.store === "boolean" ? body.store : undefined;
-        const tools = normalizeTools(body.tools);
-        const toolChoice = normalizeToolChoice(body.tool_choice);
-        const reasoning = (body.reasoning &&
-            typeof body.reasoning === "object" &&
-            !Array.isArray(body.reasoning))
-            ? body.reasoning
-            : undefined;
-        const parallelToolCalls = typeof body.parallel_tool_calls === "boolean"
-            ? body.parallel_tool_calls
-            : undefined;
-        const maxToolCalls = typeof body.max_tool_calls === "number"
-            ? body.max_tool_calls
-            : undefined;
-        const temperature = typeof body.temperature === "number"
-            ? body.temperature
-            : undefined;
-        const topP = typeof body.top_p === "number" ? body.top_p : undefined;
-        const frequencyPenalty = typeof body.frequency_penalty === "number"
-            ? body.frequency_penalty
-            : undefined;
-        const presencePenalty = typeof body.presence_penalty === "number"
-            ? body.presence_penalty
-            : undefined;
-        const maxOutputTokens = typeof body.max_output_tokens === "number"
-            ? body.max_output_tokens
-            : undefined;
-        const topLogprobs = typeof body.top_logprobs === "number"
-            ? body.top_logprobs
-            : undefined;
-        const truncation = body.truncation === "auto" ||
-            body.truncation === "disabled"
-            ? body.truncation
-            : undefined;
-        const text = (body.text && typeof body.text === "object" &&
-            !Array.isArray(body.text))
-            ? body.text
-            : undefined;
-        const streamOptions = (body.stream_options &&
-            typeof body.stream_options === "object" &&
-            !Array.isArray(body.stream_options))
-            ? body.stream_options
-            : undefined;
-        const background = typeof body.background === "boolean"
-            ? body.background
-            : undefined;
-        const include = Array.isArray(body.include)
-            ? body.include.filter((entry) => typeof entry === "string")
-            : undefined;
-        const serviceTier = body.service_tier === "auto" ||
-            body.service_tier === "default" || body.service_tier === "flex" ||
-            body.service_tier === "priority"
-            ? body.service_tier
-            : undefined;
-        const metadata = (body.metadata &&
-            typeof body.metadata === "object" &&
-            !Array.isArray(body.metadata))
-            ? body.metadata
-            : undefined;
-        const safetyIdentifier = typeof body.safety_identifier === "string"
-            ? body.safety_identifier
-            : undefined;
-        const promptCacheKey = typeof body.prompt_cache_key === "string"
-            ? body.prompt_cache_key
-            : undefined;
-        const passthrough = {};
-        for (const [key, value] of Object.entries(body)) {
-            if (key === "model" || key === "input" || key === "stream" ||
-                key === "instructions" || key === "tools" ||
-                key === "tool_choice" || key === "max_output_tokens" ||
-                key === "previous_response_id" || key === "store" ||
-                key === "reasoning" || key === "parallel_tool_calls" ||
-                key === "max_tool_calls" || key === "temperature" ||
-                key === "top_p" || key === "frequency_penalty" ||
-                key === "presence_penalty" || key === "include" ||
-                key === "text" || key === "stream_options" ||
-                key === "background" || key === "truncation" ||
-                key === "service_tier" || key === "top_logprobs" ||
-                key === "metadata" || key === "safety_identifier" ||
-                key === "prompt_cache_key" || key === "params") {
-                continue;
-            }
-            passthrough[key] = value;
-        }
-        const explicitParams = (body.params &&
-            typeof body.params === "object" &&
-            !Array.isArray(body.params))
-            ? body.params
-            : undefined;
-        const params = explicitParams || Object.keys(passthrough).length > 0
-            ? { ...(explicitParams ?? {}), ...passthrough }
-            : undefined;
-        const requestBody = {
-            model,
-            input,
-            instructions,
-            previous_response_id: previousResponseId,
-            store,
-            tools,
-            tool_choice: toolChoice,
-            reasoning,
-            parallel_tool_calls: parallelToolCalls,
-            max_tool_calls: maxToolCalls,
-            temperature,
-            top_p: topP,
-            frequency_penalty: frequencyPenalty,
-            presence_penalty: presencePenalty,
-            stream,
-            stream_options: streamOptions,
-            max_output_tokens: maxOutputTokens,
-            top_logprobs: topLogprobs,
-            truncation,
-            text,
-            include,
-            background,
-            service_tier: serviceTier,
-            metadata,
-            safety_identifier: safetyIdentifier,
-            prompt_cache_key: promptCacheKey,
-            params,
-        };
-        if (!stream) {
-            const response = await args.modelProvider.responses({
-                request: requestBody,
-            });
-            return jsonResponse(toStrictResponseResource({
-                request: requestBody,
-                response,
-            }));
-        }
-        const streamBody = new ReadableStream({
-            start: async (controller) => {
-                let sequence = 1;
-                const itemIdByOutputIndex = new Map();
-                const streamRequest = {
-                    ...requestBody,
-                    stream: true,
-                };
-                try {
-                    const result = await args.modelProvider.responses({
-                        request: streamRequest,
-                        onStreamEvent: (event) => {
-                            if (event.type === "response.created") {
-                                controller.enqueue(sseFrame({
-                                    type: "response.created",
-                                    sequence_number: sequence++,
-                                    response: toStrictResponseResource({
-                                        request: streamRequest,
-                                        response: event.response,
-                                        statusOverride: "in_progress",
-                                    }),
-                                }));
-                                return;
-                            }
-                            if (event.type === "response.output_text.delta") {
-                                const itemId = event.item_id ??
-                                    itemIdByOutputIndex.get(event.output_index) ??
-                                    `msg_${event.output_index + 1}`;
-                                itemIdByOutputIndex.set(event.output_index, itemId);
-                                controller.enqueue(sseFrame({
-                                    type: "response.output_text.delta",
-                                    sequence_number: sequence++,
-                                    output_index: event.output_index,
-                                    item_id: itemId,
-                                    content_index: event.content_index ?? 0,
-                                    delta: event.delta,
-                                    logprobs: event.logprobs ?? [],
-                                }));
-                                return;
-                            }
-                            if (event.type === "response.output_text.done") {
-                                const itemId = event.item_id ??
-                                    itemIdByOutputIndex.get(event.output_index) ??
-                                    `msg_${event.output_index + 1}`;
-                                itemIdByOutputIndex.set(event.output_index, itemId);
-                                controller.enqueue(sseFrame({
-                                    type: "response.output_text.done",
-                                    sequence_number: sequence++,
-                                    output_index: event.output_index,
-                                    item_id: itemId,
-                                    content_index: event.content_index ?? 0,
-                                    text: event.text,
-                                    logprobs: [],
-                                }));
-                                return;
-                            }
-                            if (event.type === "response.completed") {
-                                controller.enqueue(sseFrame({
-                                    type: "response.completed",
-                                    sequence_number: sequence++,
-                                    response: toStrictResponseResource({
-                                        request: streamRequest,
-                                        response: event.response,
-                                        statusOverride: "completed",
-                                    }),
-                                }));
-                                return;
-                            }
-                            if (event.type === "response.failed") {
-                                controller.enqueue(sseFrame({
-                                    type: "response.failed",
-                                    sequence_number: sequence++,
-                                    response: {
-                                        ...toStrictResponseResource({
-                                            request: streamRequest,
-                                            response: {
-                                                id: `resp_${crypto.randomUUID().slice(0, 8)}`,
-                                                object: "response",
-                                                output: [],
-                                                status: "failed",
-                                                error: event.error ??
-                                                    { message: "Unknown error" },
-                                            },
-                                            statusOverride: "failed",
-                                        }),
-                                        error: event.error ?? { message: "Unknown error" },
-                                    },
-                                }));
-                            }
-                        },
-                    });
-                    controller.enqueue(sseFrame({
-                        type: "response.completed",
-                        sequence_number: sequence++,
-                        response: toStrictResponseResource({
-                            request: streamRequest,
-                            response: result,
-                            statusOverride: "completed",
-                        }),
-                    }));
-                    controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"));
-                }
-                catch (err) {
-                    controller.enqueue(sseFrame({
-                        type: "error",
-                        code: "internal_error",
-                        message: err instanceof Error ? err.message : String(err),
-                        param: null,
-                    }));
-                }
-                finally {
-                    controller.close();
-                }
-            },
-        });
-        return new Response(streamBody, {
-            headers: {
-                "content-type": "text/event-stream",
-                "cache-control": "no-cache",
-                "connection": "keep-alive",
-            },
-        });
-    }
-    catch (err) {
-        return jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 400);
-    }
-}