@agentforge-io/core 3.3.0 → 3.4.0

package/dist/domain/connector.d.ts

@@ -16,6 +16,19 @@ export interface ConnectorToolContext {
     /** Returns a valid (non-expired) access token. Refreshes transparently
      *  if the cached one is within the refresh window. */
     getAccessToken: () => Promise<string>;
+    /**
+     * Per-installation context captured at OAuth-time and persisted on
+     * `ConnectorAuth.metadata`. Today only used by Shopify (`metadata.shop`
+     * holds the per-store domain), but kept generic so future per-install
+     * providers (Atlassian cloudId, Intercom region) can read theirs
+     * without another field on the context.
+     *
+     * Undefined for connectors that didn't stamp anything (Google, HubSpot,
+     * etc.). Tools that need a key here must throw a clear error when
+     * absent so a missing-metadata regression surfaces at the tool call
+     * rather than mid-API-request.
+     */
+    metadata?: Record<string, unknown>;
 }
 /**
  * A connector tool is an AgentForge tool that needs an authenticated user
@@ -117,4 +130,38 @@ export interface ConnectorDefinition {
      * historical whitelist semantics).
      */
     defaultToolPermissions?: ConnectorToolDefault[];
+    /**
+     * Platform-level secrets this connector needs to be operational. The
+     * platform surfaces these on `/connectors/:id/secrets` so an operator
+     * can see exactly what's missing and fill it inline instead of hunting
+     * through the global secrets vault.
+     *
+     * Each entry is a static declaration owned by the connector author;
+     * runtime values still live in `af_platform_secrets` and are resolved
+     * by the SecretsService as always.
+     *
+     * Optional. When omitted, the secrets tab is hidden for that connector.
+     */
+    requiredSecrets?: ConnectorRequiredSecret[];
+}
+/**
+ * A platform secret the connector needs at runtime. The connector author
+ * declares these so the host platform can render a per-connector secrets
+ * tab — no central hardcoded list, no drift between SDK and host.
+ */
+export interface ConnectorRequiredSecret {
+    /** Vault key (e.g. `META_APP_SECRET`). Matches what `secrets.resolve()` will look up. */
+    key: string;
+    /** Short label shown above the input in the UI. */
+    label: string;
+    /** Operator-facing explanation: where to find this value, what it's used for. */
+    description: string;
+    /** Drives the masking + audit treatment in the secrets vault. */
+    sensitivity: 'low' | 'medium' | 'high';
+    /**
+     * When true, the connector can still register without this value (e.g.
+     * webhook verify tokens that are only needed once webhooks are wired).
+     * Defaults to false — assume required.
+     */
+    optional?: boolean;
 }

package/dist/providers/anthropic-provider.js

@@ -63,13 +63,45 @@ class AnthropicProvider {
     async *stream(params) {
         const includeTemperature = typeof params.temperature === 'number' &&
             !modelRejectsTemperature(params.model);
+        // Prompt caching: mark the system prompt as `ephemeral` so Anthropic
+        // reuses it across turns. Conversations longer than one turn pay ~10%
+        // of the input-token cost on turns 2+, which is the dominant spend
+        // for our system assistants (each turn re-pays the same ~700k-token
+        // system + tools otherwise). Same `ephemeral` marker on the LAST
+        // tool so tool schemas also cache — combined with the system
+        // breakpoint that uses 2 of the 4 allowed cache slots, leaving 2
+        // for the model to mark hot message ranges itself.
+        //
+        // Cost reference (Claude Sonnet 4.6):
+        //   - write: $3.75 / MTok  (1.25x base)
+        //   - read:  $0.30 / MTok  (0.1x base)
+        // First turn pays the write; every subsequent turn in the same
+        // 5-minute window reads from cache. Net effect on a 4-turn test
+        // conversation was $2.53 → $0.31.
+        const cachedSystem = params.systemPrompt
+            ? [
+                {
+                    type: 'text',
+                    text: params.systemPrompt,
+                    cache_control: { type: 'ephemeral' },
+                },
+            ]
+            : undefined;
+        const cachedTools = (params.tools ?? []).map((tool, i, arr) => ({
+            ...tool,
+            ...(i === arr.length - 1
+                ? { cache_control: { type: 'ephemeral' } }
+                : {}),
+        }));
         const stream = this.client.messages.stream({
             model: params.model,
             max_tokens: params.maxTokens,
             ...(includeTemperature ? { temperature: params.temperature } : {}),
-            system: params.systemPrompt,
+            ...(cachedSystem ? { system: cachedSystem } : {}),
             messages: toAnthropicMessages(params.messages),
-            tools: params.tools,
+            ...(cachedTools.length > 0
+                ? { tools: cachedTools }
+                : {}),
         });
         // Mid-stream events — text deltas land here; tool_use blocks are
         // recognised at `content_block_start` so the runner can yield a

package/dist/services/agent-runner.service.d.ts

@@ -59,6 +59,14 @@ export declare class AgentRunnerService {
         approvalGate?: ToolApprovalGate;
     });
     run(agent: AgentDefinition, messages: AnthropicMessage[], context: ToolExecutionContext, overrides?: AgentOverrides): Promise<AgentResponse>;
+    /**
+     * Track tools recently used in this conversation, so we don't
+     * accidentally filter them out mid-workflow. Stores a weak ref
+     * set per agent+conversation combo (cleared when the runner
+     * instance is GC'd — acceptable since runners are request-scoped).
+     */
+    private readonly recentTools;
+    private getRecentToolsKey;
     stream(agent: AgentDefinition, messages: AnthropicMessage[], context: ToolExecutionContext, overrides?: AgentOverrides): AsyncGenerator<StreamChunk>;
     /**
      * Compose the system prompt for a single Anthropic call:

package/dist/services/agent-runner.service.js

@@ -32,6 +32,14 @@ class AgentRunnerService {
      */
     constructor(providerOrLegacyConfig, toolRegistry, opts = {}) {
         this.toolRegistry = toolRegistry;
+        // ─── Run (streaming) ──────────────────────────────────────────────────────
+        /**
+         * Track tools recently used in this conversation, so we don't
+         * accidentally filter them out mid-workflow. Stores a weak ref
+         * set per agent+conversation combo (cleared when the runner
+         * instance is GC'd — acceptable since runners are request-scoped).
+         */
+        this.recentTools = new Map();
         if (isRunnerProviderConfig(providerOrLegacyConfig)) {
             this.provider = providerOrLegacyConfig.provider;
             this.defaultModel = providerOrLegacyConfig.defaultModel ?? 'claude-opus-4-6';
@@ -112,7 +120,9 @@ class AgentRunnerService {
             createdAt: new Date(),
         };
     }
-    // ─── Run (streaming) ──────────────────────────────────────────────────────
+    getRecentToolsKey(agentId, conversationId) {
+        return `${agentId}:${conversationId}`;
+    }
     async *stream(agent, messages, context, overrides) {
         const messageId = (0, crypto_1.randomUUID)();
         const baseModel = overrides?.model ?? agent.model ?? this.defaultModel;
@@ -121,7 +131,19 @@ class AgentRunnerService {
             this.defaultMaxTokens ??
             4096;
         const temperature = overrides?.temperature ?? agent.temperature;
-        const { tools, extras } = this.buildToolList(agent, overrides);
+        const { tools: allTools, extras } = this.buildToolList(agent, overrides);
+        // ── Contextual tool filtering ─────────────────────────────────────────────
+        // Only pass the most relevant tools to the LLM to avoid:
+        //   (a) Massive system prompts (80+ tools × ~200 tokens = 16K tokens)
+        //   (b) LLM confusion from an overwhelming tool list
+        // AlwaysOn tools + recently used tools are never filtered out.
+        const recentKey = this.getRecentToolsKey(agent.id, context.conversationId);
+        const recentlyUsed = this.recentTools.get(recentKey) ?? new Set();
+        const lastUserMessage = extractLastUserMessage(messages);
+        const extraMeta = buildExtraMeta(allTools ?? [], extras);
+        const tools = filterToolsByContext(allTools ?? [], extraMeta, lastUserMessage, recentlyUsed);
+        this.logger.debug(`[toolFilter] ${(allTools ?? []).length} total → ${tools.length} passed (context: "${lastUserMessage.slice(0, 80)}…")`);
+        // ─────────────────────────────────────────────────────────────────────────
         const systemPrompt = this.buildSystemPrompt(agent, tools, overrides);
         // Re-shape Anthropic-typed tool schemas to the provider-agnostic
         // ones. The two shapes are identical today — Anthropic's `Tool`
@@ -202,9 +224,27 @@ class AgentRunnerService {
                     { role: 'assistant', content: finalContent },
                 ];
                 const toolResults = [];
+                // Track how many of the requested tools weren't actually
+                // registered. When ALL fail this way the agent is stuck in a
+                // dead-end loop: tier-translated providers (Groq llama, etc.)
+                // sometimes hallucinate tool names that exist in their training
+                // data but were never registered in this deployment. Without
+                // this counter the agent retries the same dead tools every turn
+                // until the conversation falls off the message window.
+                let unregisteredCount = 0;
+                let toolUseCount = 0;
+                // Track recently used tools so the next turn doesn't accidentally
+                // filter them out mid-workflow (e.g. user asks a follow-up about
+                // the email just fetched).
+                const recentKey = this.getRecentToolsKey(agent.id, context.conversationId);
+                const seenInThisTurn = new Set();
                 for (const block of finalContent) {
                     if (block.type !== 'tool_use')
                         continue;
+                    toolUseCount++;
+                    if (seenInThisTurn.has(block.name))
+                        continue;
+                    seenInThisTurn.add(block.name);
                     let output = '';
                     try {
                         output = await this.dispatchTool(block.name, block.input, context, extras);
@@ -216,7 +256,11 @@ class AgentRunnerService {
                             err instanceof tool_approval_gate_1.ToolBlockedError) {
                             throw err;
                         }
-                        output = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                        const msg = err instanceof Error ? err.message : String(err);
+                        if (msg.includes('not found in registry')) {
+                            unregisteredCount++;
+                        }
+                        output = `Error: ${msg}`;
                     }
                     yield { type: 'tool_result', toolName: block.name, result: output };
                     toolResults.push({
@@ -231,10 +275,45 @@ class AgentRunnerService {
                     this.logger.warn(`Agent "${agent.id}" reported tool_use but emitted no resolvable tool calls. Closing the turn.`);
                     break;
                 }
+                // ALL tool calls in this turn hit "not registered" → the model
+                // is hallucinating tools. Append a one-shot system nudge inside
+                // the same user turn (Anthropic enforces strict user/assistant
+                // alternation; two user blocks in a row would 400) so the next
+                // iteration produces a text-only reply instead of looping on
+                // the same dead tools forever.
+                if (toolUseCount > 0 && unregisteredCount === toolUseCount) {
+                    this.logger.warn(`Agent "${agent.id}" requested ${toolUseCount} tool(s), none registered — forcing text-only fallback.`);
+                    currentMessages = [
+                        ...currentMessages,
+                        {
+                            role: 'user',
+                            content: [
+                                ...toolResults,
+                                {
+                                    type: 'text',
+                                    text: 'NOTA DEL SISTEMA: Las herramientas que intentaste usar no están disponibles en este momento. Responde al usuario directamente con la información que ya tienes, sin intentar herramientas adicionales.',
+                                },
+                            ],
+                        },
+                    ];
+                    continue;
+                }
                 currentMessages = [
                     ...currentMessages,
                     { role: 'user', content: toolResults },
                 ];
+                // Persist recently used tools for the next turn's filtering pass.
+                const stored = this.recentTools.get(recentKey) ?? new Set();
+                for (const name of seenInThisTurn)
+                    stored.add(name);
+                // Keep only the last 10 to avoid unbounded growth.
+                if (stored.size > 10) {
+                    const arr = Array.from(stored).slice(-10);
+                    this.recentTools.set(recentKey, new Set(arr));
+                }
+                else {
+                    this.recentTools.set(recentKey, stored);
+                }
             }
             else {
                 break;
@@ -303,10 +382,10 @@ class AgentRunnerService {
      * for example. The shadowing only lasts for this call.
      */
     buildToolList(agent, overrides) {
-        // Always invoke the registry — even when the agent has no whitelist —
-        // because alwaysOn tools (e.g. `current_time`) get folded in there and
-        // need to reach an agent whose `tools[]` is empty.
-        const fromRegistry = this.toolRegistry.getToolsForAgent(agent.id, agent.tools ?? []);
+        // Build the extras map first so we can tell the registry which names
+        // are satisfied elsewhere — keeps it from warning about connector tools
+        // it legitimately doesn't know about (they live in the host's
+        // tenant-scoped connector registry, not the global ToolRegistry).
         const allowed = new Set(agent.tools ?? []);
         const extras = new Map();
         const extrasSchema = [];
@@ -320,6 +399,10 @@ class AgentRunnerService {
                 input_schema: t.inputSchema,
             });
         }
+        // Always invoke the registry — even when the agent has no whitelist —
+        // because alwaysOn tools (e.g. `current_time`) get folded in there and
+        // need to reach an agent whose `tools[]` is empty.
+        const fromRegistry = this.toolRegistry.getToolsForAgent(agent.id, agent.tools ?? [], new Set(extras.keys()));
         const tools = [...fromRegistry, ...extrasSchema];
         return { tools: tools.length ? tools : undefined, extras };
     }
@@ -396,6 +479,153 @@ function hasApprovalGatedTool(agent) {
     }
     return false;
 }
+const MAX_TOOLS_PER_CATEGORY = 8;
+const MAX_TOTAL_TOOLS = 20;
+const ALWAYS_ON_TOOLS = new Set(['current_time', 'noop', 'http_request']);
+function extractTopicWords(message) {
+    const lower = message.toLowerCase();
+    const words = lower.split(/[\s.,;:!?()\[\]{}'"<>]+/).filter(Boolean);
+    const stopWords = new Set([
+        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+        'should', 'may', 'might', 'must', 'can', 'to', 'of', 'in', 'for',
+        'on', 'with', 'at', 'by', 'from', 'as', 'or', 'and', 'it', 'its',
+        'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'we',
+        'they', 'what', 'which', 'who', 'how', 'when', 'where', 'why',
+        'not', 'but', 'if', 'then', 'so', 'just', 'about', 'my', 'your',
+        'our', 'their', 'me', 'him', 'her', 'us', 'them', 'want', 'need',
+        'like', 'know', 'think', 'use', 'using', 'thanks', 'please', 'help',
+        'hi', 'hello', 'hey', 'de', 'la', 'el', 'los', 'las', 'un', 'una',
+        'y', 'en', 'que', 'es', 'por', 'con', 'para', 'del', 'al', 'se',
+    ]);
+    const topics = new Set();
+    for (const word of words) {
+        if (word.length < 3 || stopWords.has(word))
+            continue;
+        topics.add(word);
+        // Add bigrams (two-word phrases like "google calendar")
+        const idx = words.indexOf(word);
+        if (idx < words.length - 1) {
+            const next = words[idx + 1];
+            if (next.length >= 2 && !stopWords.has(next)) {
+                topics.add(`${word}_${next}`);
+            }
+        }
+    }
+    return topics;
+}
+function scoreTool(tool, topics) {
+    if (ALWAYS_ON_TOOLS.has(tool.name))
+        return 100;
+    if (tool.alwaysOn)
+        return 80;
+    let score = 0;
+    const name = tool.name.toLowerCase();
+    const desc = tool.description.toLowerCase();
+    for (const topic of topics) {
+        const clean = topic.replace(/_/g, ' ');
+        if (name.includes(clean))
+            score += 10;
+        if (desc.includes(clean))
+            score += 3;
+        if (clean.includes(name))
+            score += 5;
+        // Partial matches for connector names (e.g. "calendar" in "google calendar")
+        if (tool.connectorName) {
+            const cn = tool.connectorName.toLowerCase();
+            if (cn.includes(clean) || clean.includes(cn))
+                score += 8;
+        }
+    }
+    return score;
+}
+function filterToolsByContext(tools, extraMeta, lastUserMessage, recentlyUsedTools) {
+    if (tools.length <= MAX_TOTAL_TOOLS)
+        return tools;
+    const topics = extractTopicWords(lastUserMessage);
+    // If the message is too generic (< 3 meaningful topics), skip filtering
+    // to avoid accidentally hiding relevant tools.
+    if (topics.size < 3)
+        return tools;
+    const scored = tools.map((t) => {
+        const meta = extraMeta.get(t.name) ?? {
+            name: t.name,
+            description: t.description ?? '',
+            alwaysOn: false,
+        };
+        let score = scoreTool(meta, topics);
+        // Boost recently used tools so multi-step workflows aren't disrupted
+        if (recentlyUsedTools.has(t.name))
+            score += 15;
+        return { tool: t, score, connectorId: meta.connectorId ?? '__global' };
+    });
+    // Sort by score descending
+    scored.sort((a, b) => b.score - a.score);
+    // Always-on tools always make it through
+    const alwaysOn = scored.filter((s) => s.score >= 80);
+    const rest = scored.filter((s) => s.score < 80);
+    // Budget: MAX_TOTAL_TOOLS, with per-category cap
+    const result = [...alwaysOn];
+    const categoryCount = new Map();
+    for (const item of rest) {
+        if (result.length >= MAX_TOTAL_TOOLS)
+            break;
+        const cat = item.connectorId ?? '__global';
+        const count = categoryCount.get(cat) ?? 0;
+        if (count >= MAX_TOOLS_PER_CATEGORY)
+            continue;
+        categoryCount.set(cat, count + 1);
+        result.push(item);
+    }
+    return result.map((s) => s.tool);
+}
+/**
+ * Pull the most recent user text from the message history.
+ * Used by `filterToolsByContext` to score tools for relevance.
+ */
+function extractLastUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== 'user')
+            continue;
+        if (typeof msg.content === 'string')
+            return msg.content;
+        for (let j = msg.content.length - 1; j >= 0; j--) {
+            const block = msg.content[j];
+            if (block?.type === 'text' && typeof block.text === 'string') {
+                return block.text;
+            }
+        }
+    }
+    return '';
+}
+/**
+ * Build a name → scoring metadata map for all tools.
+ * Merges data from both the registry tools and the extras map so
+ * connector tools (which live in extras) also get scored correctly.
+ */
+function buildExtraMeta(registryTools, extras) {
+    const map = new Map();
+    for (const t of registryTools) {
+        map.set(t.name, {
+            name: t.name,
+            description: t.description ?? '',
+            alwaysOn: false,
+            connectorId: t.connectorId,
+            connectorName: t.connectorName,
+        });
+    }
+    for (const [name, def] of extras) {
+        map.set(name, {
+            name: def.name,
+            description: def.description ?? '',
+            alwaysOn: false,
+            connectorId: def.connectorId,
+            connectorName: def.connectorName,
+        });
+    }
+    return map;
+}
 // ─── Message-shape translation ───────────────────────────────────────────────
 /**
  * The runner's public API still accepts `AnthropicMessage[]` (kept for

package/dist/services/agent.service.js

@@ -387,6 +387,8 @@ class AgentService {
     }
     // ─── Streaming ────────────────────────────────────────────────────────────
     async *streamMessage(params) {
+        // eslint-disable-next-line no-console
+        console.log(`[chunk-debug] streamMessage ENTER conv=${params.conversationId.slice(0, 8)}`);
         const history = await this.conversations.getAnthropicMessages(params.conversationId, params.userId);
         const conv = await this.conversations.ensureOwned(params.conversationId, params.userId);
         if (conv.status === 'completed') {
@@ -448,17 +450,33 @@ class AgentService {
             // history have nothing to rehydrate. FIFO matching mirrors the
             // runner's heuristic so the shape stays consistent whether the
             // turn streamed or used `run()`.
+            // eslint-disable-next-line no-console
+            console.log(`[chunk-debug] streamMessage about to iterate stream (useOrchestrator=${useOrchestrator}, extraTools=${extraTools?.length ?? 0})`);
+            let chunkCount = 0;
             for await (const chunk of stream) {
+                chunkCount += 1;
+                if (chunkCount <= 3 || chunk.type === 'tool_use_start') {
+                    // eslint-disable-next-line no-console
+                    console.log(`[chunk-debug] chunk #${chunkCount} type=${chunk.type}`);
+                }
                 if (chunk.type === 'text_delta')
                     fullContent += chunk.delta;
                 if (chunk.type === 'usage')
                     finalUsage = chunk.usage;
                 if (chunk.type === 'tool_use_start') {
+                    // eslint-disable-next-line no-console
+                    console.log(`[chunk-debug] tool_use_start: name=${chunk.toolName} useId=${chunk.toolUseId}`);
                     toolCallStartByUseId.set(chunk.toolUseId, {
                         name: chunk.toolName,
                         start: Date.now(),
                     });
                 }
+                if (chunk.type === 'text_delta') {
+                    if (chunk.delta) {
+                        // eslint-disable-next-line no-console
+                        console.log(`[chunk-debug] text_delta: ${JSON.stringify(chunk.delta).slice(0, 200)}`);
+                    }
+                }
                 if (chunk.type === 'tool_result') {
                     // Match by toolUseId when present; otherwise FIFO on toolName
                     // (matches AgentRunner.run's heuristic). Older runners that
@@ -492,8 +510,12 @@ class AgentService {
                 }
                 yield chunk;
             }
+            // eslint-disable-next-line no-console
+            console.log(`[chunk-debug] streamMessage LOOP DONE chunks=${chunkCount} fullContentLen=${fullContent.length}`);
         }
         catch (err) {
+            // eslint-disable-next-line no-console
+            console.log(`[chunk-debug] streamMessage CATCH err=${err.message?.slice(0, 200) ?? '(no msg)'} type=${err.constructor?.name ?? 'Unknown'}`);
             // Tool-approval gate decisions surface as typed exceptions. We
             // intercept them HERE so the SSE consumer sees a structured
             // chunk instead of a torn-down generator. Each branch also

package/dist/services/connector-registry.service.js

@@ -323,6 +323,7 @@ class ConnectorRegistryService {
     }
     synthesizeTools(authed, contextUserId) {
         const tools = [];
+        const seen = new Set();
         for (const a of authed) {
             if (!a.isActive)
                 continue;
@@ -339,8 +340,15 @@ class ConnectorRegistryService {
                 userId: contextUserId,
                 connectorId: a.connectorId,
                 getAccessToken: () => this.getAccessToken(a),
+                metadata: a.metadata,
             };
             for (const factory of def.tools) {
+                // Deduplicate by tool name: if multiple connectors expose the same
+                // tool (e.g. both `google` combo AND `google-gmail` are authorized),
+                // only keep the first occurrence. The LLM rejects duplicate tool names.
+                if (seen.has(factory.definition.name))
+                    continue;
+                seen.add(factory.definition.name);
                 tools.push({ ...factory.definition, execute: factory.build(ctx) });
             }
         }

package/dist/services/tool-registry.service.d.ts

@@ -23,7 +23,7 @@ export declare class ToolRegistryService {
      *  actually removed — false when the name was unknown. Used by
      *  McpClientService to clean up tools when an MCP server is unregistered. */
     unregister(name: string): boolean;
-    getToolsForAgent(agentId: string, toolNames: string[]): AnthropicTool[];
+    getToolsForAgent(agentId: string, toolNames: string[], knownElsewhere?: ReadonlySet<string>): AnthropicTool[];
     execute(toolName: string, input: Record<string, unknown>, context: ToolExecutionContext): Promise<string>;
     has(name: string): boolean;
     list(): string[];

package/dist/services/tool-registry.service.js

@@ -43,7 +43,7 @@ class ToolRegistryService {
             this.logger.debug(`Unregistered tool: ${name}`);
         return existed;
     }
-    getToolsForAgent(agentId, toolNames) {
+    getToolsForAgent(agentId, toolNames, knownElsewhere) {
         // Always-on tools (e.g. `current_time`) are offered to every agent
         // regardless of the whitelist — they're runtime essentials the model
         // needs to answer correctly. Per-agent allowlists still apply.
@@ -59,7 +59,13 @@ class ToolRegistryService {
             .filter((name) => {
             const tool = this.tools.get(name);
             if (!tool) {
-                this.logger.warn(`Tool "${name}" requested by agent "${agentId}" is not registered`);
+                // Connector tools live in the host's connector registry, not this
+                // global one — the runner injects them via `extraTools`. When the
+                // caller tells us which names will be satisfied by extras, skip
+                // the warning for those; they're not really "missing".
+                if (!knownElsewhere?.has(name)) {
+                    this.logger.warn(`Tool "${name}" requested by agent "${agentId}" is not registered`);
+                }
                 return false;
             }
             if (tool.agents && tool.agents.length > 0 && !tool.agents.includes(agentId)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge-io/core",
-  "version": "3.3.0",
+  "version": "3.4.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 — not here.",
   "license": "MIT",
   "main": "dist/index.js",