@agentforge-io/core 2.3.0 → 3.0.0

package/dist/services/agent.service.js

@@ -379,6 +379,11 @@ class AgentService {
         const filter = params.overrides?.extraToolsFilter;
         const fromConnectors = filter && resolvedExtras ? filter(resolvedExtras) : resolvedExtras;
         const extraTools = mergeExtraTools(params.overrides?.extraTools, fromConnectors);
+        // Hoisted accumulators so the post-loop persistence (after the
+        // try) can see the final list. Defined here, populated inside
+        // the for-await loop below.
+        const toolCallStartByUseId = new Map();
+        const accumulatedToolCalls = [];
         try {
             // Team orchestrators route through OrchestratorService.stream()
             // so the synthetic `delegate_to_*` tools the orchestrator was
@@ -403,11 +408,56 @@ class AgentService {
                     messageId: 'streaming',
                     agent: { timezone: agent.timezone },
                 }, { ...(params.overrides ?? {}), extraTools });
+            // Accumulate tool_use / tool_result chunks during streaming so
+            // we can persist them on the assistant message row (line ~700).
+            // Without this, `getHistory` returns the assistant's text but
+            // loses the tool calls — which means clients that render
+            // proposal cards (Recording Assist) or generic tool rows from
+            // history have nothing to rehydrate. FIFO matching mirrors the
+            // runner's heuristic so the shape stays consistent whether the
+            // turn streamed or used `run()`.
             for await (const chunk of stream) {
                 if (chunk.type === 'text_delta')
                     fullContent += chunk.delta;
                 if (chunk.type === 'usage')
                     finalUsage = chunk.usage;
+                if (chunk.type === 'tool_use_start') {
+                    toolCallStartByUseId.set(chunk.toolUseId, {
+                        name: chunk.toolName,
+                        start: Date.now(),
+                    });
+                }
+                if (chunk.type === 'tool_result') {
+                    // Match by toolUseId when present; otherwise FIFO on toolName
+                    // (matches AgentRunner.run's heuristic). Older runners that
+                    // don't emit `toolUseId` on result chunks still produce a
+                    // usable record.
+                    let entry = null;
+                    const useId = chunk.toolUseId;
+                    if (useId && toolCallStartByUseId.has(useId)) {
+                        const v = toolCallStartByUseId.get(useId);
+                        entry = { id: useId, name: v.name, start: v.start };
+                        toolCallStartByUseId.delete(useId);
+                    }
+                    else {
+                        const fifo = Array.from(toolCallStartByUseId.entries()).find(([, v]) => v.name === chunk.toolName);
+                        if (fifo) {
+                            entry = { id: fifo[0], name: fifo[1].name, start: fifo[1].start };
+                            toolCallStartByUseId.delete(fifo[0]);
+                        }
+                    }
+                    if (entry) {
+                        accumulatedToolCalls.push({
+                            toolName: entry.name,
+                            toolUseId: entry.id,
+                            input: {},
+                            output: typeof chunk.result === 'string'
+                                ? chunk.result
+                                : JSON.stringify(chunk.result),
+                            durationMs: Date.now() - entry.start,
+                        });
+                    }
+                }
                 yield chunk;
             }
         }
@@ -507,6 +557,12 @@ class AgentService {
                 role: 'assistant',
                 content: fullContent,
                 usage: finalUsage,
+                // Persist the accumulated tool calls so `getHistory` can
+                // surface them on reload — without this, proposal cards
+                // (Recording Assist) and other tool-result-driven UI
+                // disappear after refresh. Empty arrays drop to undefined
+                // so we don't pollute the column with `[]`.
+                toolCalls: accumulatedToolCalls.length > 0 ? accumulatedToolCalls : undefined,
             });
             const now = new Date();
             await this.dispatchUsage({

package/dist/services/orchestrator.service.js

@@ -142,6 +142,11 @@ class OrchestratorService {
             return;
         }
         this.logger.debug(`Streaming orchestrator "${agentId}" with subagents: ${agent.subAgents.join(', ')}`);
+        // Pre-resolve all sub-agents so `buildDelegationTools` sees their
+        // name/description/slug — without this, the agentsMap only has the
+        // orchestrator and the tool-name builder falls back to the UUID
+        // form, defeating the slug→name match the model relies on.
+        await Promise.all(agent.subAgents.map((id) => this.resolveAgentDynamic(id)));
         const delegationTools = this.buildDelegationTools(agent);
         const model = agent.model ?? this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
         const maxTokens = agent.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
@@ -213,8 +218,14 @@ class OrchestratorService {
                 if (block.type !== 'tool_use')
                     continue;
                 const delegateTool = delegationTools.find((t) => t.name === block.name);
-                if (!delegateTool)
+                if (!delegateTool) {
+                    // The model called a tool name we didn't expose. Log loudly
+                    // so we can spot drift between the prompt's slug references
+                    // and the actual tool surface.
+                    this.logger.warn(`Orchestrator "${agent.id}" called unknown tool "${block.name}". ` +
+                        `Available tools: ${delegationTools.map((t) => t.name).join(', ')}`);
                     continue;
+                }
                 const { task } = block.input;
                 const { subAgentId } = delegateTool;
                 const subAgent = await this.resolveAgentDynamic(subAgentId);
@@ -333,6 +344,9 @@ class OrchestratorService {
     }
     async runOrchestratorLoop(orchestrator, messages, context) {
         const delegations = [];
+        // Pre-resolve subagents so buildDelegationTools sees their
+        // slug/name/description (same fix as the stream path).
+        await Promise.all((orchestrator.subAgents ?? []).map((id) => this.resolveAgentDynamic(id)));
         const delegationTools = this.buildDelegationTools(orchestrator);
         const model = orchestrator.model ?? this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
         const maxTokens = orchestrator.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
@@ -439,13 +453,43 @@ class OrchestratorService {
     }
     // ─── Helpers ───────────────────────────────────────────────────────────────
     buildDelegationTools(orchestrator) {
+        // First pass: collect the slug/uuid-name candidates so we can
+        // detect collisions across the team. Anthropic requires `tool.name`
+        // to be unique within a single request; two subagents with the
+        // same slug (rare but legal at the platform layer in different
+        // tenant scopes) must not collapse into one tool.
+        const namesUsed = new Set();
         return (orchestrator.subAgents ?? []).map((subAgentId) => {
             const sub = this.agentsMap.get(subAgentId);
+            const subSlug = sub?.slug;
+            // Tool name strategy: prefer `delegate_to_<slug>` because the model
+            // already SEES `@<slug>` in its system prompt; matching it to the
+            // tool name eliminates the two-namespace gap that caused
+            // wrong-tool calls. Fall back to a sanitized UUID-derived name
+            // when no slug is available or when the slug name is already
+            // taken by an earlier subagent in this build pass.
+            const slugName = subSlug
+                ? `delegate_to_${subSlug.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 50)}`
+                : null;
+            const uuidName = `delegate_to_${subAgentId.replace(/[^a-zA-Z0-9]/g, '_')}`;
+            let name;
+            if (slugName && !namesUsed.has(slugName)) {
+                name = slugName;
+            }
+            else {
+                name = uuidName;
+            }
+            namesUsed.add(name);
+            // Description still calls out the slug explicitly — belt and
+            // suspenders against models that pattern-match on text more
+            // than on tool names.
             const description = sub
-                ? `Delegate a task to the "${sub.name}" specialist agent. ${sub.description ?? ''}`
+                ? `Delegate a task to the "${sub.name}" specialist agent` +
+                    (subSlug ? ` (mention slug: @${subSlug})` : '') +
+                    `. ${sub.description ?? ''}`
                 : `Delegate a task to subagent "${subAgentId}"`;
             return {
-                name: `delegate_to_${subAgentId.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                name,
                 description,
                 subAgentId,
                 inputSchema: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentforge-io/core",
-  "version": "2.3.0",
-  "description": "Framework-free AI runtime SDK. Owns: agent loop (pluggable LLM provider — Anthropic by default, LangChain-backed providers as drop-ins), conversations, tools, streaming, agent-job queue, SdkHooks. Identity, billing, infra (email/uploads/secrets) live in the host's modules — not here.",
+  "version": "3.0.0",
+  "description": "Framework-free AI runtime SDK. Owns: agent loop (Anthropic), conversations, tools, streaming, agent-job queue, SdkHooks. Identity, billing, infra (email/uploads/secrets) live in the host's modules \u2014 not here.",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,4 +33,4 @@
     "tsx": "^4.19.0",
     "typescript": "^5.0.0"
   }
-}
+}