runbios-mcp 0.2.8-dev.210 → 0.2.8-dev.213

package/dist/http/assistant.js

@@ -0,0 +1,679 @@
+import { BiosClient } from "../api-client.js";
+import { sessionLaunchGates } from "../config.js";
+import { consumeApprovalToken, issueApprovalToken, verifyApprovalToken, } from "../assistant/approval.js";
+import { AssistantUpstreamError, streamAssistantModel, } from "../assistant/model.js";
+import { createAssistantToolRuntime, openAITool, rankTools, toolRisk, } from "../assistant/tool-runtime.js";
+const DEFAULT_MODEL = "bios-adaptive";
+const MAX_MESSAGES = 1_000;
+const MAX_TOOL_ROUNDS = 8;
+const MAX_TOOL_CALLS = 12;
+const MAX_TOOL_RESULT_CHARS = 64_000;
+const EXCLUDED_ASSISTANT_TOOLS = new Set(["get_platform_guide", "chat_with_inference", "upload_dataset"]);
+const SEARCH_TOOL_NAME = "search_platform_tools";
+class AssistantRequestError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+function jsonError(res, status, code, message) {
+    res.status(status).json({ error: { code, message } });
+}
+function contentParts(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 32)
+        return null;
+    const parts = [];
+    for (const raw of value) {
+        if (!raw || typeof raw !== "object")
+            return null;
+        const part = raw;
+        if (part.type === "text" && typeof part.text === "string") {
+            parts.push({ type: "text", text: part.text });
+            continue;
+        }
+        if (part.type === "image_url" && part.image_url && typeof part.image_url === "object") {
+            const url = part.image_url.url;
+            if (typeof url !== "string" || !(url.startsWith("https://") || url.startsWith("data:image/")))
+                return null;
+            parts.push({ type: "image_url", image_url: { url } });
+            continue;
+        }
+        if (part.type === "video_url" && part.video_url && typeof part.video_url === "object") {
+            const url = part.video_url.url;
+            if (typeof url !== "string" || !(url.startsWith("https://") || url.startsWith("data:video/")))
+                return null;
+            parts.push({ type: "video_url", video_url: { url } });
+            continue;
+        }
+        return null;
+    }
+    return parts;
+}
+function toolCalls(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 16)
+        return null;
+    const calls = [];
+    for (const raw of value) {
+        if (!raw || typeof raw !== "object")
+            return null;
+        const call = raw;
+        const fn = call.function && typeof call.function === "object"
+            ? call.function
+            : null;
+        if (typeof call.id !== "string" || call.id.length < 1 || call.id.length > 256
+            || !fn || typeof fn.name !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(fn.name)
+            || typeof fn.arguments !== "string")
+            return null;
+        calls.push({ id: call.id, type: "function", function: { name: fn.name, arguments: fn.arguments } });
+    }
+    return calls;
+}
+export function normalizeAssistantMessages(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > MAX_MESSAGES) {
+        throw new AssistantRequestError(400, "invalid_messages", `messages must contain between 1 and ${MAX_MESSAGES} entries.`);
+    }
+    const messages = [];
+    for (const raw of value) {
+        if (!raw || typeof raw !== "object")
+            throw new AssistantRequestError(400, "invalid_messages", "Every message must be an object.");
+        const message = raw;
+        if (message.role === "user") {
+            if (typeof message.content === "string")
+                messages.push({ role: "user", content: message.content });
+            else {
+                const parts = contentParts(message.content);
+                if (!parts)
+                    throw new AssistantRequestError(400, "invalid_messages", "User content parts must be text, image_url, or video_url values.");
+                messages.push({ role: "user", content: parts });
+            }
+            continue;
+        }
+        if (message.role === "assistant") {
+            if (message.content !== null && typeof message.content !== "string") {
+                throw new AssistantRequestError(400, "invalid_messages", "Assistant content must be text or null.");
+            }
+            const calls = message.tool_calls === undefined ? undefined : toolCalls(message.tool_calls);
+            if (message.tool_calls !== undefined && !calls)
+                throw new AssistantRequestError(400, "invalid_messages", "Assistant tool calls are malformed.");
+            messages.push({ role: "assistant", content: message.content, ...(calls ? { tool_calls: calls } : {}) });
+            continue;
+        }
+        if (message.role === "tool") {
+            if (typeof message.content !== "string" || typeof message.tool_call_id !== "string" || !message.tool_call_id) {
+                throw new AssistantRequestError(400, "invalid_messages", "Tool messages require text content and a tool_call_id.");
+            }
+            messages.push({ role: "tool", content: message.content, tool_call_id: message.tool_call_id });
+            continue;
+        }
+        throw new AssistantRequestError(400, "invalid_messages", "Only user, assistant, and tool messages are accepted.");
+    }
+    return messages;
+}
+function mediaCounts(messages) {
+    let images = 0;
+    let videos = 0;
+    for (const message of messages) {
+        if (!Array.isArray(message.content))
+            continue;
+        for (const part of message.content) {
+            if (part.type === "image_url")
+                images++;
+            if (part.type === "video_url")
+                videos++;
+        }
+    }
+    return { images, videos };
+}
+function latestUserText(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== "user")
+            continue;
+        if (typeof message.content === "string")
+            return message.content;
+        if (!Array.isArray(message.content))
+            return "";
+        return message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+    }
+    return "";
+}
+function systemPrompt(toolsEnabled) {
+    return [
+        "You are Run BiOS Assistant. Answer general questions normally and help the signed-in user operate the Run BiOS platform.",
+        "Every platform action is restricted to the authenticated organization and workspace. Never invent, infer, or substitute an account or resource ID.",
+        "Resource references use @dataset:<id>, @training:<id>, @deployment:<id>, @checkpoint:<id>, and @integration:<id>. Resolve ambiguous resources with list/search tools instead of guessing.",
+        toolsEnabled
+            ? `Only claim access to tools provided in this request. If the needed tool is not present, call ${SEARCH_TOOL_NAME}; never claim a hidden or unavailable capability.`
+            : "No platform tools are available in this turn. Do not claim that an action was performed; explain that platform actions require both a tool-capable model and authorized tools in the current workspace.",
+        "Use preflight and status tools before paid operations. State concrete prices, GPU choices, queue terms, and irreversible effects from tool results only.",
+        "Ask a concise normal-chat question when required information is missing. Do not call a mutation with guessed values.",
+        "A tool request is not success. Report an operation as complete only after its tool result confirms it, and include returned resource IDs.",
+        "Web search and third-party connectors are not available unless a corresponding tool is explicitly present. Do not pretend to browse or access email.",
+        "Use clear GitHub-flavored Markdown. Tables, fenced code, links, and LaTeX are supported.",
+    ].join("\n");
+}
+function resolveEffort(model, requested) {
+    const mode = model.reasoning_mode ?? "none";
+    if (mode === "none") {
+        if (requested && requested !== "none")
+            throw new AssistantRequestError(400, "unsupported_effort", "This model does not expose reasoning effort controls.");
+        return undefined;
+    }
+    const advertised = (model.available_efforts ?? []).map((value) => value.toLowerCase());
+    const ladder = advertised.length > 0 ? advertised : ["low", "medium", "high"];
+    const fallback = model.default_effort && ladder.includes(model.default_effort.toLowerCase())
+        ? model.default_effort.toLowerCase()
+        : ladder.includes("medium") ? "medium" : ladder[Math.floor((ladder.length - 1) / 2)];
+    const effort = (requested || fallback).toLowerCase();
+    if (effort === "none" && mode === "optional")
+        return "none";
+    if (!ladder.includes(effort))
+        throw new AssistantRequestError(400, "unsupported_effort", `This model supports: ${ladder.join(", ")}.`);
+    return effort;
+}
+function maxTokens(model, effort) {
+    const thinking = { minimal: 1_024, low: 4_096, medium: 8_192, high: 16_384, xhigh: 24_576, max: 32_768 };
+    const requested = (thinking[effort ?? ""] ?? 0) + 8_192;
+    const advertised = Number(model.output_tokens?.max ?? 0);
+    if (advertised > 0)
+        return Math.max(1, Math.min(advertised, requested || 8_192));
+    return requested || 8_192;
+}
+function parseArguments(call) {
+    try {
+        const value = JSON.parse(call.function.arguments || "{}");
+        return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function truncateToolResult(value) {
+    if (value.length <= MAX_TOOL_RESULT_CHARS)
+        return value;
+    return `${value.slice(0, MAX_TOOL_RESULT_CHARS)}\n\n[Result truncated by Run BiOS Assistant after ${MAX_TOOL_RESULT_CHARS} characters.]`;
+}
+function resourceKind(toolName, key) {
+    const normalized = key.toLowerCase();
+    if (normalized.includes("dataset"))
+        return "dataset";
+    if (normalized.includes("checkpoint"))
+        return "checkpoint";
+    if (normalized.includes("training") || normalized === "job_id")
+        return "training";
+    if (normalized.includes("deployment") || normalized.includes("inference"))
+        return "deployment";
+    if (normalized.includes("integration"))
+        return "integration";
+    if (normalized.includes("booking") || normalized === "handle")
+        return "booking";
+    if (normalized !== "id")
+        return null;
+    if (toolName.includes("dataset"))
+        return "dataset";
+    if (toolName.includes("checkpoint"))
+        return "checkpoint";
+    if (toolName.includes("training"))
+        return "training";
+    if (toolName.includes("inference") || toolName.includes("deployment"))
+        return "deployment";
+    if (toolName.includes("integration"))
+        return "integration";
+    if (toolName.includes("booking"))
+        return "booking";
+    return null;
+}
+export function extractResourceReferences(toolName, text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const found = new Map();
+    const visit = (node, depth) => {
+        if (depth > 6 || found.size >= 24 || !node)
+            return;
+        if (Array.isArray(node)) {
+            for (const child of node)
+                visit(child, depth + 1);
+            return;
+        }
+        if (typeof node !== "object")
+            return;
+        const object = node;
+        const label = [object.name, object.display_name, object.label].find((item) => typeof item === "string");
+        for (const [key, child] of Object.entries(object)) {
+            const kind = resourceKind(toolName, key);
+            if (kind && typeof child === "string" && child.length > 0 && child.length <= 512) {
+                found.set(`${kind}:${child}`, { kind, id: child, ...(label ? { label } : {}) });
+            }
+            visit(child, depth + 1);
+        }
+    };
+    visit(value, 0);
+    return [...found.values()];
+}
+function unresolvedToolCalls(messages) {
+    const calls = new Map();
+    const answered = new Set();
+    for (const message of messages) {
+        for (const call of message.tool_calls ?? [])
+            calls.set(call.id, call);
+        if (message.role === "tool" && message.tool_call_id)
+            answered.add(message.tool_call_id);
+    }
+    for (const id of answered)
+        calls.delete(id);
+    return calls;
+}
+function approvalMatchesTranscript(payload, messages) {
+    const unresolved = unresolvedToolCalls(messages);
+    return payload.calls.every((approved) => {
+        const call = unresolved.get(approved.id);
+        const args = call ? parseArguments(call) : null;
+        return !!call
+            && call.function.name === approved.name
+            && !!args
+            && JSON.stringify(args) === JSON.stringify(approved.arguments)
+            && toolRisk(approved.name) === approved.risk;
+    });
+}
+function addUsage(total, next) {
+    if (!next)
+        return;
+    total.prompt_tokens = (total.prompt_tokens ?? 0) + (next.prompt_tokens ?? 0);
+    total.completion_tokens = (total.completion_tokens ?? 0) + (next.completion_tokens ?? 0);
+    total.total_tokens = (total.total_tokens ?? 0) + (next.total_tokens ?? 0);
+}
+function searchTool() {
+    return {
+        type: "function",
+        function: {
+            name: SEARCH_TOOL_NAME,
+            description: "Find additional Run BiOS platform tools that are authorized for this user. Use this when the current tools do not cover the requested platform operation.",
+            parameters: {
+                type: "object",
+                properties: { query: { type: "string", description: "The capability or operation to find." } },
+                required: ["query"],
+                additionalProperties: false,
+            },
+        },
+    };
+}
+function sse(res, event, data) {
+    if (res.writableEnded)
+        return;
+    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+async function runTool(runtime, toolMap, call, args, res) {
+    sse(res, "tool.start", { id: call.id, name: call.function.name, arguments: args });
+    let ok = false;
+    let text;
+    if (!toolMap.has(call.function.name)) {
+        text = JSON.stringify({ code: "TOOL_UNAVAILABLE", message: "This tool is not available to this user in the current workspace." });
+    }
+    else {
+        try {
+            const result = await runtime.call(call.function.name, args);
+            ok = result.ok;
+            text = truncateToolResult(result.text);
+        }
+        catch (error) {
+            text = JSON.stringify({
+                code: "TOOL_FAILED",
+                message: error instanceof Error ? error.message : "The platform tool failed.",
+            });
+        }
+    }
+    const resources = extractResourceReferences(call.function.name, text);
+    sse(res, "tool.result", { id: call.id, name: call.function.name, ok, content: text, resources });
+    return { role: "tool", tool_call_id: call.id, content: text };
+}
+function setupStream(res) {
+    res.status(200);
+    res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+}
+export function createAssistantChatHandler(deps) {
+    return async function assistantChat(req, res) {
+        if (req.header("x-gateway-auth") !== deps.cfg.internalServiceKey
+            || req.header("x-auth-type") !== "jwt"
+            || !req.header("x-user-id")) {
+            jsonError(res, 401, "unauthorized", "A valid console session is required.");
+            return;
+        }
+        const authorization = req.header("authorization") ?? "";
+        const userId = req.header("x-user-id") ?? "";
+        const workspaceId = req.header("x-workspace-id") ?? "";
+        const orgId = req.header("x-org-id") ?? "";
+        if (!/^Bearer\s+\S+$/i.test(authorization) || !workspaceId || !orgId) {
+            jsonError(res, 400, "workspace_required", "Choose an organization and workspace before using the assistant.");
+            return;
+        }
+        let body;
+        let messages;
+        let approvalPayload = null;
+        try {
+            body = (req.body ?? {});
+            messages = normalizeAssistantMessages(body.messages);
+            const model = (body.model || DEFAULT_MODEL).trim();
+            if (!/^[A-Za-z0-9._:/-]{1,200}$/.test(model))
+                throw new AssistantRequestError(400, "invalid_model", "Choose a valid serverless model.");
+            body.model = model;
+            if (body.approval) {
+                if (body.approval.decision !== "approve" && body.approval.decision !== "reject") {
+                    throw new AssistantRequestError(400, "invalid_approval", "Choose approve or reject for the pending action.");
+                }
+                approvalPayload = verifyApprovalToken(body.approval.token ?? "", deps.cfg.internalServiceKey, { userId, workspaceId, orgId });
+                if (!approvalPayload || !approvalMatchesTranscript(approvalPayload, messages)) {
+                    throw new AssistantRequestError(409, "approval_invalid", "This approval is expired, already used, or no longer matches the pending action.");
+                }
+            }
+            else if (!messages.some((message) => message.role === "user")) {
+                throw new AssistantRequestError(400, "user_message_required", "Send a user message to start the assistant.");
+            }
+        }
+        catch (error) {
+            if (error instanceof AssistantRequestError)
+                jsonError(res, error.status, error.code, error.message);
+            else
+                jsonError(res, 400, "invalid_request", "The assistant request is malformed.");
+            return;
+        }
+        const client = new BiosClient({
+            baseUrl: `http://${deps.cfg.apiGatewayHost}:${deps.cfg.apiGatewayPort}`,
+            authHeaders: { Authorization: authorization },
+            orgId,
+            workspaceId,
+            userAgent: "bios-assistant/1.0",
+        });
+        let modelDetail;
+        let resolvedEffort;
+        let runtime = null;
+        try {
+            modelDetail = await client.api(`/api/serverless/catalog/models/${encodeURIComponent(body.model)}`);
+            if (!modelDetail?.slug)
+                throw new Error("model unavailable");
+            const counts = mediaCounts(messages);
+            if (counts.images > 0 && modelDetail.supports_vision !== true) {
+                throw new AssistantRequestError(400, "vision_unsupported", "The selected model does not support image input.");
+            }
+            if (counts.videos > 0 && modelDetail.supports_video !== true) {
+                throw new AssistantRequestError(400, "video_unsupported", "The selected model does not support video input.");
+            }
+            if (counts.images > 10 || counts.videos > 8) {
+                throw new AssistantRequestError(400, "too_many_attachments", "Use at most 10 images and 8 videos in one conversation request.");
+            }
+            resolvedEffort = resolveEffort(modelDetail, body.effort);
+            if (approvalPayload && modelDetail.supports_tools !== true) {
+                throw new AssistantRequestError(409, "approval_model_changed", "Switch back to a tool-capable model or cancel the pending action.");
+            }
+            if (modelDetail.supports_tools === true) {
+                try {
+                    const [identity, gates] = await Promise.all([
+                        client.api("/api/api-keys/introspect"),
+                        sessionLaunchGates(orgId, () => client.api(`/api/organizations/${encodeURIComponent(orgId)}/features`)),
+                    ]);
+                    const allowedTools = new Set((identity.allowed_mcp_tools ?? []).filter((name) => !EXCLUDED_ASSISTANT_TOOLS.has(name)));
+                    runtime = await createAssistantToolRuntime({
+                        client,
+                        launchGates: gates,
+                        allowedTools,
+                        hooks: {
+                            onToolCall: (info) => deps.audit.emit("assistant_tool_call", {
+                                tool: info.tool,
+                                ok: info.ok,
+                                ms: info.ms,
+                                user_id: userId,
+                                workspace_id: workspaceId,
+                                ...(info.error ? { error: info.error } : {}),
+                            }),
+                        },
+                    });
+                    if (runtime.tools.length === 0) {
+                        await runtime.close();
+                        runtime = null;
+                    }
+                }
+                catch {
+                    runtime = null;
+                    deps.audit.emit("assistant_tool_visibility_failed_closed", { user_id: userId, workspace_id: workspaceId });
+                    if (approvalPayload) {
+                        throw new AssistantRequestError(503, "tool_access_unavailable", "Tool access could not be verified. Nothing was changed; retry shortly.");
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof AssistantRequestError)
+                jsonError(res, error.status, error.code, error.message);
+            else
+                jsonError(res, 400, "model_unavailable", "This serverless model is not available in the selected workspace.");
+            return;
+        }
+        const controller = new AbortController();
+        req.once("aborted", () => controller.abort());
+        res.once("close", () => { if (!res.writableEnded)
+            controller.abort(); });
+        setupStream(res);
+        const heartbeat = setInterval(() => { if (!res.writableEnded)
+            res.write(": keepalive\n\n"); }, 15_000);
+        heartbeat.unref();
+        const appended = [];
+        const transcript = [
+            { role: "system", content: systemPrompt(runtime !== null) },
+            ...messages,
+        ];
+        const usage = {};
+        const toolMap = new Map((runtime?.tools ?? []).map((tool) => [tool.name, tool]));
+        const activeTools = new Map();
+        for (const tool of rankTools(runtime?.tools ?? [], latestUserText(messages), 24))
+            activeTools.set(tool.name, tool);
+        const signatures = new Set();
+        const toolCallIds = new Set(messages.flatMap((message) => (message.tool_calls ?? []).map((call) => call.id)));
+        let toolCallsMade = 0;
+        let rounds = 0;
+        let pendingApproval = null;
+        const appendToolMessage = (message) => {
+            transcript.push(message);
+            appended.push(message);
+        };
+        try {
+            if (approvalPayload && body.approval) {
+                const consumed = await consumeApprovalToken(deps.store, approvalPayload, body.approval.decision);
+                if (!consumed)
+                    throw new AssistantRequestError(409, "approval_used", "This approval has already been used or expired.");
+                deps.audit.emit("assistant_approval_decision", {
+                    decision: body.approval.decision,
+                    tools: approvalPayload.calls.map((call) => call.name),
+                    user_id: userId,
+                    workspace_id: workspaceId,
+                });
+                for (const approved of approvalPayload.calls) {
+                    const wireCall = {
+                        id: approved.id,
+                        type: "function",
+                        function: { name: approved.name, arguments: JSON.stringify(approved.arguments) },
+                    };
+                    if (body.approval.decision === "reject") {
+                        const result = JSON.stringify({ code: "USER_DECLINED", message: "The user declined this action. Nothing was changed." });
+                        sse(res, "tool.result", { id: approved.id, name: approved.name, ok: false, content: result, resources: [] });
+                        appendToolMessage({ role: "tool", tool_call_id: approved.id, content: result });
+                    }
+                    else {
+                        appendToolMessage(await runTool(runtime, toolMap, wireCall, approved.arguments, res));
+                    }
+                }
+            }
+            for (; rounds < MAX_TOOL_ROUNDS; rounds++) {
+                const offered = new Set(activeTools.keys());
+                const modelTools = runtime
+                    ? [searchTool(), ...[...activeTools.values()].map(openAITool)]
+                    : [];
+                let transformSent = false;
+                sse(res, "assistant.start", { round: rounds + 1 });
+                const modelResult = await streamAssistantModel({
+                    baseUrl: `http://${deps.cfg.apiGatewayHost}:${deps.cfg.apiGatewayPort}`,
+                    authorization,
+                    orgId,
+                    workspaceId,
+                    model: modelDetail.slug,
+                    effort: resolvedEffort,
+                    maxTokens: maxTokens(modelDetail, resolvedEffort),
+                    messages: transcript,
+                    tools: modelTools,
+                    signal: controller.signal,
+                    fetchImpl: deps.fetchImpl,
+                    onTextDelta: (text) => sse(res, "assistant.delta", { round: rounds + 1, text }),
+                    onContextTransform: (value) => {
+                        if (transformSent)
+                            return;
+                        transformSent = true;
+                        sse(res, "context.compacted", value);
+                    },
+                });
+                for (const [index, call] of (modelResult.message.tool_calls ?? []).entries()) {
+                    const base = call.id || `call_${rounds + 1}_${index}`;
+                    let unique = base;
+                    let suffix = 1;
+                    while (toolCallIds.has(unique))
+                        unique = `${base}_${rounds + 1}_${suffix++}`;
+                    call.id = unique;
+                    toolCallIds.add(unique);
+                }
+                addUsage(usage, modelResult.usage);
+                transcript.push(modelResult.message);
+                appended.push(modelResult.message);
+                sse(res, "assistant.finish", {
+                    round: rounds + 1,
+                    message: modelResult.message,
+                    finish_reason: modelResult.finishReason,
+                    usage: modelResult.usage,
+                });
+                const calls = modelResult.message.tool_calls ?? [];
+                if (calls.length === 0 || !runtime)
+                    break;
+                const protectedCalls = [];
+                for (const call of calls) {
+                    toolCallsMade++;
+                    const args = parseArguments(call);
+                    if (!args) {
+                        const result = JSON.stringify({ code: "INVALID_TOOL_ARGUMENTS", message: "The model produced invalid JSON arguments. No tool was called." });
+                        sse(res, "tool.result", { id: call.id, name: call.function.name, ok: false, content: result, resources: [] });
+                        appendToolMessage({ role: "tool", tool_call_id: call.id, content: result });
+                        continue;
+                    }
+                    if (toolCallsMade > MAX_TOOL_CALLS) {
+                        const result = JSON.stringify({ code: "TOOL_LIMIT_REACHED", message: "The assistant reached the per-request tool-call limit. No additional tool was called." });
+                        sse(res, "tool.result", { id: call.id, name: call.function.name, ok: false, content: result, resources: [] });
+                        appendToolMessage({ role: "tool", tool_call_id: call.id, content: result });
+                        continue;
+                    }
+                    const signature = `${call.function.name}:${JSON.stringify(args)}`;
+                    if (signatures.has(signature)) {
+                        const result = JSON.stringify({ code: "DUPLICATE_TOOL_CALL", message: "The same tool call already ran in this request. Read its prior result instead of repeating it." });
+                        sse(res, "tool.result", { id: call.id, name: call.function.name, ok: false, content: result, resources: [] });
+                        appendToolMessage({ role: "tool", tool_call_id: call.id, content: result });
+                        continue;
+                    }
+                    signatures.add(signature);
+                    if (call.function.name === SEARCH_TOOL_NAME) {
+                        const query = typeof args.query === "string" ? args.query : "";
+                        const matches = rankTools(runtime.tools, query, 12);
+                        for (const match of matches)
+                            activeTools.set(match.name, match);
+                        const result = JSON.stringify({
+                            tools: matches.map((tool) => ({ name: tool.name, description: tool.description })),
+                            instruction: "These authorized tools will be available on the next model turn. Use an exact returned name and its provided schema.",
+                        });
+                        sse(res, "tool.result", { id: call.id, name: call.function.name, ok: true, content: result, resources: [] });
+                        appendToolMessage({ role: "tool", tool_call_id: call.id, content: result });
+                        continue;
+                    }
+                    if (!offered.has(call.function.name)) {
+                        const result = JSON.stringify({ code: "TOOL_NOT_OFFERED", message: `Call ${SEARCH_TOOL_NAME} to discover this capability before using it.` });
+                        sse(res, "tool.result", { id: call.id, name: call.function.name, ok: false, content: result, resources: [] });
+                        appendToolMessage({ role: "tool", tool_call_id: call.id, content: result });
+                        continue;
+                    }
+                    const risk = toolRisk(call.function.name);
+                    if (risk !== "read") {
+                        protectedCalls.push({ id: call.id, name: call.function.name, arguments: args, risk });
+                        continue;
+                    }
+                    appendToolMessage(await runTool(runtime, toolMap, call, args, res));
+                }
+                if (protectedCalls.length > 0) {
+                    const approval = await issueApprovalToken(deps.store, deps.cfg.internalServiceKey, {
+                        userId,
+                        workspaceId,
+                        orgId,
+                        calls: protectedCalls,
+                    });
+                    pendingApproval = {
+                        token: approval.token,
+                        expires_at: new Date(approval.expiresAt).toISOString(),
+                        calls: protectedCalls,
+                    };
+                    deps.audit.emit("assistant_approval_requested", {
+                        tools: protectedCalls.map((call) => call.name),
+                        risks: protectedCalls.map((call) => call.risk),
+                        user_id: userId,
+                        workspace_id: workspaceId,
+                    });
+                    sse(res, "approval.required", pendingApproval);
+                    break;
+                }
+            }
+            if (rounds >= MAX_TOOL_ROUNDS && !pendingApproval) {
+                sse(res, "error", {
+                    status: 409,
+                    code: "tool_loop_limit",
+                    message: "The assistant stopped after too many tool rounds. Review the tool results and continue with a narrower request.",
+                });
+            }
+            sse(res, "usage", usage);
+            sse(res, "done", { messages: appended, usage, pending_approval: pendingApproval });
+            deps.audit.emit("assistant_chat_completed", {
+                model: modelDetail.slug,
+                rounds: Math.min(rounds + 1, MAX_TOOL_ROUNDS),
+                tool_calls: toolCallsMade,
+                approval_required: pendingApproval !== null,
+                prompt_tokens: usage.prompt_tokens ?? 0,
+                completion_tokens: usage.completion_tokens ?? 0,
+                user_id: userId,
+                workspace_id: workspaceId,
+            });
+        }
+        catch (error) {
+            if (!controller.signal.aborted) {
+                const status = error instanceof AssistantUpstreamError || error instanceof AssistantRequestError ? error.status : 500;
+                const code = error instanceof AssistantUpstreamError || error instanceof AssistantRequestError ? error.code : "assistant_error";
+                const message = error instanceof Error ? error.message : "The assistant request failed.";
+                sse(res, "error", {
+                    status,
+                    code,
+                    message,
+                    ...(status === 402 || code === "insufficient_funds" ? { action: "add_funds" } : {}),
+                });
+                sse(res, "done", { messages: appended, usage, pending_approval: null });
+            }
+        }
+        finally {
+            clearInterval(heartbeat);
+            if (runtime)
+                await runtime.close();
+            if (!res.writableEnded)
+                res.end();
+        }
+    };
+}
+//# sourceMappingURL=assistant.js.map