@agent-native/core 0.5.0-dev.b51eaae → 0.7.1

package/dist/agent/production-agent.js

@@ -1,6 +1,12 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { defineEventHandler, readBody, setResponseHeader, setResponseStatus, getMethod, } from "h3";
+import { defineEventHandler, setResponseHeader, setResponseStatus, getMethod, } from "h3";
+import { resolveEngine, registerBuiltinEngines } from "./engine/index.js";
+import { ASSISTANT_CONTENT_KEY } from "./engine/anthropic-engine.js";
+import { readAppState } from "../application-state/script-helpers.js";
 import { startRun, subscribeToRun, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, } from "./run-manager.js";
+import { readBody } from "../server/h3-helpers.js";
+import { getRequestUserEmail } from "../server/request-context.js";
+// Register built-in engines on first import
+registerBuiltinEngines();
 const MAX_ITERATIONS = 40;
 const MAX_RETRIES = 3;
 const RETRY_BASE_DELAY_MS = 2000;
@@ -37,6 +43,7 @@ function enrichMessage(message, references) {
         return message;
     const fileRefs = references.filter((r) => r.type === "file");
     const skillRefs = references.filter((r) => r.type === "skill");
+    const customAgentRefs = references.filter((r) => r.type === "custom-agent");
     const mentionRefs = references.filter((r) => r.type === "mention");
     const parts = [];
     if (fileRefs.length > 0) {
@@ -51,6 +58,12 @@ function enrichMessage(message, references) {
                 .map((r) => `- ${r.name} (${r.path})${r.source === "resource" ? " — read with resource-read" : " — read with read-file"}`)
                 .join("\n"));
     }
+    if (customAgentRefs.length > 0) {
+        parts.push("Requested custom agents:\n" +
+            customAgentRefs
+                .map((r) => `- ${r.name}${r.refId ? ` (id: ${r.refId})` : ""}${r.path ? ` (path: ${r.path})` : ""}`)
+                .join("\n"));
+    }
     if (mentionRefs.length > 0) {
         parts.push("Referenced items:\n" +
             mentionRefs
@@ -60,11 +73,32 @@ function enrichMessage(message, references) {
     return `${parts.join("\n\n")}\n\n${message}`;
 }
 /**
- * The core agent loop — calls Claude iteratively until no more tool calls.
+ * Convert ActionEntry registry to EngineTool array.
+ */
+export function actionsToEngineTools(actions) {
+    return Object.entries(actions).map(([name, entry]) => ({
+        name,
+        description: entry.tool.description,
+        inputSchema: (entry.tool.parameters ?? {
+            type: "object",
+            properties: {},
+        }),
+    }));
+}
+/**
+ * The core agent loop — calls the engine iteratively until no more tool calls.
  * Decoupled from HTTP transport so it can run in the background.
+ * Returns accumulated token usage for cost tracking.
  */
-async function runAgentLoop(opts) {
-    const { client, model, systemPrompt, tools, messages, actions, send, signal, } = opts;
+export async function runAgentLoop(opts) {
+    const { engine, model, systemPrompt, tools, messages, actions, send, signal, } = opts;
+    const usage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        model,
+    };
     let iterations = 0;
     while (true) {
         if (signal.aborted)
@@ -74,23 +108,52 @@ async function runAgentLoop(opts) {
             break;
         }
         let assistantContent;
+        let hasToolCalls = false;
         for (let retry = 0;; retry++) {
             try {
-                const apiStream = client.messages.stream({
+                const streamOpts = {
                     model,
-                    max_tokens: 16384,
-                    system: systemPrompt,
-                    tools,
+                    systemPrompt,
                     messages,
-                }, { signal });
-                for await (const chunk of apiStream) {
-                    if (chunk.type === "content_block_delta" &&
-                        chunk.delta.type === "text_delta") {
-                        send({ type: "text", text: chunk.delta.text });
+                    tools,
+                    abortSignal: signal,
+                    providerOptions: opts.providerOptions,
+                };
+                const eventStream = engine.stream(streamOpts);
+                let thinkingBuffer = "";
+                for await (const event of eventStream) {
+                    if (event.type === "text-delta") {
+                        send({ type: "text", text: event.text });
+                    }
+                    else if (event.type === "thinking-delta") {
+                        thinkingBuffer += event.text;
+                        // Thinking deltas are not forwarded to the SSE client yet —
+                        // we accumulate them. In a future iteration, we can surface
+                        // them as a collapsible "reasoning" section in the UI.
+                    }
+                    else if (event.type === "tool-call") {
+                        hasToolCalls = true;
+                    }
+                    else if (event.type === "usage") {
+                        usage.inputTokens += event.inputTokens;
+                        usage.outputTokens += event.outputTokens;
+                        usage.cacheReadTokens += event.cacheReadTokens ?? 0;
+                        usage.cacheWriteTokens += event.cacheWriteTokens ?? 0;
                     }
+                    else if (event.type === "stop" && event.reason === "error") {
+                        throw new Error(event.error ?? "Engine stream error");
+                    }
+                }
+                // Retrieve the assistant content blocks stored by the engine.
+                // AnthropicEngine sets streamOpts[ASSISTANT_CONTENT_KEY] after streaming.
+                assistantContent = streamOpts[ASSISTANT_CONTENT_KEY];
+                // If engine didn't populate assistant content (e.g. AI SDK engine),
+                // rebuild it from the messages state we tracked via tool-call events.
+                // The AI SDK engine stores it under AISDK_ASSISTANT_CONTENT_KEY.
+                if (!assistantContent) {
+                    const { AISDK_ASSISTANT_CONTENT_KEY } = await import("./engine/ai-sdk-engine.js");
+                    assistantContent = streamOpts[AISDK_ASSISTANT_CONTENT_KEY];
                 }
-                const finalMessage = await apiStream.finalMessage();
-                assistantContent = finalMessage.content;
                 break;
             }
             catch (err) {
@@ -110,63 +173,67 @@ async function runAgentLoop(opts) {
                 throw err;
             }
         }
-        if (!assistantContent)
+        if (!assistantContent) {
+            // No content — done
             break;
+        }
         messages.push({ role: "assistant", content: assistantContent });
-        const toolUseBlocks = assistantContent.filter((b) => b.type === "tool_use");
-        if (toolUseBlocks.length === 0)
+        const toolCallParts = assistantContent.filter((p) => p.type === "tool-call");
+        if (toolCallParts.length === 0)
             break;
-        const toolResults = [];
-        for (const toolUse of toolUseBlocks) {
-            const actionEntry = actions[toolUse.name];
+        // Run all tool calls in parallel — engines often return multiple tool-call
+        // blocks in one turn. Running them concurrently saves wall-clock time.
+        const toolResultParts = await Promise.all(toolCallParts.map(async (toolCall) => {
+            const actionEntry = actions[toolCall.name];
             if (!actionEntry) {
-                const result = `Error: Unknown tool "${toolUse.name}"`;
+                const result = `Error: Unknown tool "${toolCall.name}"`;
                 send({
                     type: "tool_start",
-                    tool: toolUse.name,
-                    input: toolUse.input,
+                    tool: toolCall.name,
+                    input: toolCall.input,
                 });
-                send({ type: "tool_done", tool: toolUse.name, result });
-                toolResults.push({
-                    type: "tool_result",
-                    tool_use_id: toolUse.id,
+                send({ type: "tool_done", tool: toolCall.name, result });
+                return {
+                    type: "tool-result",
+                    toolCallId: toolCall.id,
                     content: result,
-                });
-                continue;
+                    isError: true,
+                };
             }
             send({
                 type: "tool_start",
-                tool: toolUse.name,
-                input: toolUse.input,
+                tool: toolCall.name,
+                input: toolCall.input,
             });
             let result;
+            let isError = false;
             try {
-                result = await actionEntry.run(toolUse.input, { send });
+                const raw = await actionEntry.run(toolCall.input, { send });
+                result = typeof raw === "string" ? raw : JSON.stringify(raw, null, 2);
             }
             catch (err) {
-                result = `Error running ${toolUse.name}: ${err?.message ?? String(err)}`;
+                result = `Error running ${toolCall.name}: ${err?.message ?? String(err)}`;
+                isError = true;
             }
-            send({ type: "tool_done", tool: toolUse.name, result });
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: toolUse.id,
+            send({ type: "tool_done", tool: toolCall.name, result });
+            return {
+                type: "tool-result",
+                toolCallId: toolCall.id,
                 content: result,
-            });
-        }
-        messages.push({ role: "user", content: toolResults });
+                ...(isError ? { isError } : {}),
+            };
+        }));
+        messages.push({ role: "user", content: toolResultParts });
     }
     send({ type: "done" });
+    return usage;
 }
 export function createProductionAgentHandler(options) {
     const model = options.model ?? "claude-sonnet-4-6";
     // Resolve actions — prefer `actions`, fall back to deprecated `scripts`
     const resolvedActions = options.actions ?? options.scripts ?? {};
-    // Build Anthropic tool definitions from action registry
-    const tools = Object.entries(resolvedActions).map(([name, entry]) => ({
-        name,
-        description: entry.tool.description,
-        input_schema: entry.tool.parameters,
-    }));
+    // Build engine tools from action registry
+    const engineTools = actionsToEngineTools(resolvedActions);
     return defineEventHandler(async (event) => {
         if (getMethod(event) !== "POST") {
             setResponseStatus(event, 405);
@@ -185,9 +252,23 @@ export function createProductionAgentHandler(options) {
             setResponseStatus(event, 400);
             return { error: "message is required" };
         }
-        // Check for API key before starting a run
+        // Resolve engine (async — reads settings if needed)
+        let engine;
+        try {
+            engine = await resolveEngine({
+                engineOption: options.engine,
+                apiKey: options.apiKey ?? process.env.ANTHROPIC_API_KEY,
+                model,
+            });
+        }
+        catch {
+            engine = await resolveEngine({
+                apiKey: options.apiKey ?? process.env.ANTHROPIC_API_KEY,
+            });
+        }
+        // Check for API key before starting a run (only for anthropic engine)
         const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) {
+        if (engine.name === "anthropic" && !apiKey) {
             setResponseHeader(event, "Content-Type", "text/event-stream");
             setResponseHeader(event, "Cache-Control", "no-cache");
             setResponseHeader(event, "Connection", "keep-alive");
@@ -199,6 +280,31 @@ export function createProductionAgentHandler(options) {
                 },
             });
         }
+        // Check usage limit before starting a run (production hosted mode)
+        if (options.trackUsage && options.resolveOwnerEmail) {
+            try {
+                const ownerEmail = await options.resolveOwnerEmail(event);
+                if (ownerEmail && ownerEmail !== "local@localhost") {
+                    const { checkUsageLimit } = await import("../usage/store.js");
+                    const result = await checkUsageLimit(ownerEmail, options.usageLimitCents);
+                    if (!result.allowed) {
+                        setResponseHeader(event, "Content-Type", "text/event-stream");
+                        setResponseHeader(event, "Cache-Control", "no-cache");
+                        setResponseHeader(event, "Connection", "keep-alive");
+                        const encoder = new TextEncoder();
+                        return new ReadableStream({
+                            start(controller) {
+                                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "usage_limit_reached", usageCents: result.usageCents, limitCents: result.limitCents })}\n\n`));
+                                controller.close();
+                            },
+                        });
+                    }
+                }
+            }
+            catch {
+                // Usage check failed — allow the request to proceed
+            }
+        }
         // Resolve system prompt before starting the run
         let systemPrompt;
         try {
@@ -218,10 +324,96 @@ export function createProductionAgentHandler(options) {
                 },
             });
         }
-        const client = new Anthropic({ apiKey });
         const enrichedMessage = enrichMessage(message, references);
+        // Auto-inject current screen context so the agent always knows what
+        // the user is looking at without needing to call view-screen first.
+        let screenContext = "";
+        try {
+            const viewScreenAction = resolvedActions["view-screen"];
+            if (viewScreenAction) {
+                const result = await viewScreenAction.run({});
+                if (result && result !== "(no output)") {
+                    screenContext = `\n\n<current-screen>\n${result}\n</current-screen>`;
+                }
+            }
+            else {
+                const navigation = await readAppState("navigation");
+                if (navigation) {
+                    screenContext = `\n\n<current-screen>\n${JSON.stringify(navigation, null, 2)}\n</current-screen>`;
+                }
+            }
+        }
+        catch {
+            // DB not ready or no navigation state — skip silently
+        }
+        // On the first message of a conversation, inject workspace inventory
+        // so the agent knows what files, skills, jobs, and custom agents exist.
+        let filesContext = "";
+        if (history.length === 0) {
+            try {
+                const { resourceListAccessible, SHARED_OWNER, resourceGet } = await import("../resources/store.js");
+                const { getResourceKind, parseCustomAgentProfile, parseRemoteAgentManifest, parseSkillMetadata, } = await import("../resources/metadata.js");
+                const ownerEmail = getRequestUserEmail() || "local@localhost";
+                const allResources = await resourceListAccessible(ownerEmail);
+                if (allResources.length > 0) {
+                    const fileLines = [];
+                    const skillLines = [];
+                    const agentLines = [];
+                    const jobLines = [];
+                    for (const r of allResources) {
+                        const scope = r.owner === SHARED_OWNER ? "shared" : "personal";
+                        const kind = getResourceKind(r.path);
+                        if (kind === "file") {
+                            fileLines.push(`  ${r.path} (${scope})`);
+                            continue;
+                        }
+                        if (kind === "job") {
+                            jobLines.push(`  ${r.path} (${scope})`);
+                            continue;
+                        }
+                        if (kind === "skill" ||
+                            kind === "agent" ||
+                            kind === "remote-agent") {
+                            const full = await resourceGet(r.id);
+                            if (!full)
+                                continue;
+                            if (kind === "skill") {
+                                const skill = parseSkillMetadata(full.content, r.path);
+                                skillLines.push(`  ${skill?.name || r.path} — ${skill?.description || r.path} (${scope}, ${r.path})`);
+                            }
+                            else if (kind === "agent") {
+                                const agent = parseCustomAgentProfile(full.content, r.path);
+                                agentLines.push(`  ${agent?.name || r.path} — ${agent?.description || "Custom workspace agent"} (${scope}, ${r.path}${agent?.model ? `, model: ${agent.model}` : ""})`);
+                            }
+                            else {
+                                const agent = parseRemoteAgentManifest(full.content, r.path);
+                                agentLines.push(`  ${agent?.name || r.path} — ${agent?.description || "Connected A2A agent"} (${scope}, remote via ${r.path})`);
+                            }
+                        }
+                    }
+                    const blocks = [];
+                    if (fileLines.length > 0) {
+                        blocks.push(`<available-files>\nFiles in the workspace:\n${fileLines.join("\n")}\n\nTo read a file's contents, use the resource-read action with the file path.\n</available-files>`);
+                    }
+                    if (skillLines.length > 0) {
+                        blocks.push(`<available-skills>\nSkills in the workspace:\n${skillLines.join("\n")}\n</available-skills>`);
+                    }
+                    if (agentLines.length > 0) {
+                        blocks.push(`<available-agents>\nCustom and connected agents in the workspace:\n${agentLines.join("\n")}\n\nCustom agents under agents/*.md can be mentioned or used via spawn-task with the agent parameter.\n</available-agents>`);
+                    }
+                    if (jobLines.length > 0) {
+                        blocks.push(`<available-jobs>\nScheduled tasks in the workspace:\n${jobLines.join("\n")}\n</available-jobs>`);
+                    }
+                    filesContext = blocks.length > 0 ? `\n\n${blocks.join("\n\n")}` : "";
+                }
+            }
+            catch {
+                // Resources not available — skip silently
+            }
+        }
         // Pre-compute agent references for A2A resolution inside the run
         const agentRefs = references.filter((r) => r.type === "agent");
+        const customAgentRefs = references.filter((r) => r.type === "custom-agent");
         // Build user content: text + any image attachments
         const userContent = [];
         if (attachments?.length) {
@@ -231,33 +423,113 @@ export function createProductionAgentHandler(options) {
                     if (match) {
                         userContent.push({
                             type: "image",
-                            source: {
-                                type: "base64",
-                                media_type: match[1],
-                                data: match[2],
-                            },
+                            data: match[2],
+                            mediaType: match[1],
                         });
                     }
                 }
             }
         }
-        userContent.push({ type: "text", text: enrichedMessage });
+        userContent.push({
+            type: "text",
+            text: enrichedMessage + screenContext + filesContext,
+        });
         const messages = [
             ...history
                 .filter((m) => m.content.trim())
                 .map((m) => ({
                 role: m.role,
-                content: m.content,
+                content: [{ type: "text", text: m.content }],
             })),
             { role: "user", content: userContent },
         ];
         // Start agent loop in background via run-manager
         const runId = generateRunId();
         startRun(runId, threadId ?? runId, async (send, signal) => {
-            // Resolve agent @-mentions via A2A calls (inside run so we can emit SSE events)
+            // Notify listeners that a run has started (used by agent teams)
+            if (options.onRunStart) {
+                options.onRunStart(send, threadId ?? runId);
+            }
+            // Resolve custom workspace agent mentions first.
+            if (customAgentRefs.length > 0) {
+                const ownerEmail = getRequestUserEmail() || "local@localhost";
+                const { findAccessibleCustomAgent } = await import("../resources/agents.js");
+                const customResults = await Promise.allSettled(customAgentRefs.map(async (ref) => {
+                    send({
+                        type: "agent_call",
+                        agent: ref.name,
+                        status: "start",
+                    });
+                    try {
+                        const profile = await findAccessibleCustomAgent(ownerEmail, ref.refId || ref.path || ref.name);
+                        if (!profile) {
+                            throw new Error("Profile not found");
+                        }
+                        const profilePrompt = `${systemPrompt}\n\n<custom-agent-profile name="${profile.name}" path="${profile.path}">\n` +
+                            (profile.description ? `${profile.description}\n\n` : "") +
+                            `${profile.instructions}\n</custom-agent-profile>`;
+                        let responseText = "";
+                        await runAgentLoop({
+                            engine,
+                            model: profile.model ?? model,
+                            systemPrompt: profilePrompt,
+                            tools: engineTools,
+                            messages: [
+                                {
+                                    role: "user",
+                                    content: [
+                                        { type: "text", text: enrichedMessage + screenContext },
+                                    ],
+                                },
+                            ],
+                            actions: resolvedActions,
+                            send: (event) => {
+                                if (event.type === "text") {
+                                    responseText += event.text;
+                                    send({
+                                        type: "agent_call_text",
+                                        agent: ref.name,
+                                        text: event.text,
+                                    });
+                                }
+                            },
+                            signal,
+                            providerOptions: options.providerOptions,
+                        });
+                        send({
+                            type: "agent_call",
+                            agent: ref.name,
+                            status: "done",
+                        });
+                        return `<agent-response name="${ref.name}" id="${ref.refId}" type="custom-agent">\n${responseText}\n</agent-response>`;
+                    }
+                    catch (err) {
+                        send({
+                            type: "agent_call",
+                            agent: ref.name,
+                            status: "error",
+                        });
+                        return `<agent-response name="${ref.name}" id="${ref.refId}" type="custom-agent" error="true">\nFailed to run ${ref.name}: ${err?.message}\n</agent-response>`;
+                    }
+                }));
+                const customResponses = customResults
+                    .filter((result) => result.status === "fulfilled")
+                    .map((result) => result.value);
+                if (customResponses.length > 0) {
+                    const agentContext = "Responses from custom workspace agents:\n\n" +
+                        customResponses.join("\n\n");
+                    const lastMsg = messages[messages.length - 1];
+                    if (lastMsg?.role === "user" && Array.isArray(lastMsg.content)) {
+                        const textPart = lastMsg.content.find((p) => p.type === "text");
+                        if (textPart) {
+                            textPart.text = agentContext + "\n\n" + textPart.text;
+                        }
+                    }
+                }
+            }
+            // Resolve connected agent @-mentions via A2A calls.
             if (agentRefs.length > 0) {
                 const { A2AClient, callAgent } = await import("../a2a/client.js");
-                const agentResponses = [];
                 const results = await Promise.allSettled(agentRefs.map(async (ref) => {
                     send({
                         type: "agent_call",
@@ -265,14 +537,11 @@ export function createProductionAgentHandler(options) {
                         status: "start",
                     });
                     try {
-                        // Try streaming first — shows progressive text in the UI
-                        const client = new A2AClient(ref.path);
-                        const callerEmail = process.env.AGENT_USER_EMAIL;
-                        // Build A2A metadata with identity info
+                        const a2aClient = new A2AClient(ref.path);
+                        const callerEmail = getRequestUserEmail();
                         const a2aMetadata = {};
                         if (callerEmail)
                             a2aMetadata.userEmail = callerEmail;
-                        // In prod, include Google token for verification
                         if (process.env.NODE_ENV === "production" && callerEmail) {
                             try {
                                 const { listOAuthAccountsByOwner } = await import("../oauth-tokens/store.js");
@@ -287,9 +556,14 @@ export function createProductionAgentHandler(options) {
                         let responseText = "";
                         let lastSentLength = 0;
                         try {
-                            for await (const task of client.stream({
+                            for await (const task of a2aClient.stream({
                                 role: "user",
-                                parts: [{ type: "text", text: message }],
+                                parts: [
+                                    {
+                                        type: "text",
+                                        text: enrichedMessage + screenContext,
+                                    },
+                                ],
                             }, Object.keys(a2aMetadata).length > 0
                                 ? { metadata: a2aMetadata }
                                 : undefined)) {
@@ -309,9 +583,8 @@ export function createProductionAgentHandler(options) {
                             }
                         }
                         catch {
-                            // Streaming failed — fall back to blocking call
                             if (!responseText) {
-                                responseText = await callAgent(ref.path, message);
+                                responseText = await callAgent(ref.path, enrichedMessage + screenContext);
                             }
                         }
                         send({
@@ -330,33 +603,50 @@ export function createProductionAgentHandler(options) {
                         return `<agent-response name="${ref.name}" id="${ref.refId}" error="true">\nFailed to reach ${ref.name}: ${err?.message}\n</agent-response>`;
                     }
                 }));
+                const agentResponses_local = [];
                 for (const result of results) {
                     if (result.status === "fulfilled") {
-                        agentResponses.push(result.value);
+                        agentResponses_local.push(result.value);
                     }
                 }
-                if (agentResponses.length > 0) {
-                    const agentContext = "Responses from other agents:\n\n" + agentResponses.join("\n\n");
-                    // Prepend agent responses to the last user message's text content
+                if (agentResponses_local.length > 0) {
+                    const agentContext = "Responses from other agents:\n\n" +
+                        agentResponses_local.join("\n\n");
                     const lastMsg = messages[messages.length - 1];
                     if (lastMsg?.role === "user" && Array.isArray(lastMsg.content)) {
-                        const textBlock = lastMsg.content.find((b) => b.type === "text");
-                        if (textBlock) {
-                            textBlock.text = agentContext + "\n\n" + textBlock.text;
+                        const textPart = lastMsg.content.find((p) => p.type === "text");
+                        if (textPart) {
+                            textPart.text = agentContext + "\n\n" + textPart.text;
                         }
                     }
                 }
             }
-            return runAgentLoop({
-                client,
+            const loopUsage = await runAgentLoop({
+                engine,
                 model,
                 systemPrompt,
-                tools,
+                tools: engineTools,
                 messages,
                 actions: resolvedActions,
                 send,
                 signal,
+                providerOptions: options.providerOptions,
             });
+            // Record token usage for cost tracking (production hosted mode)
+            if (options.trackUsage && options.resolveOwnerEmail) {
+                try {
+                    const ownerEmail = await options.resolveOwnerEmail(event);
+                    if (ownerEmail &&
+                        ownerEmail !== "local@localhost" &&
+                        (loopUsage.inputTokens > 0 || loopUsage.outputTokens > 0)) {
+                        const { recordUsage } = await import("../usage/store.js");
+                        await recordUsage(ownerEmail, loopUsage.inputTokens, loopUsage.outputTokens, loopUsage.model);
+                    }
+                }
+                catch {
+                    // Usage recording failed — don't break the run
+                }
+            }
         }, options.onRunComplete
             ? (run) => options.onRunComplete(run, threadId)
             : undefined);