@agentforge-io/core 2.0.24 → 2.1.1

package/dist/factory.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAgentForge = createAgentForge;
 const in_memory_1 = require("./adapters/rate-limiter/in-memory");
@@ -22,9 +55,29 @@ function createAgentForge(opts) {
     // ─── Tool registry + runner + orchestrator ───────────────────────────────
     const toolRegistry = new tool_registry_service_1.ToolRegistryService({ logger, initialTools: tools });
     const runner = new agent_runner_service_1.AgentRunnerService(config.anthropic, toolRegistry, { logger });
+    // Bridge the host-supplied AgentResolver into the orchestrator's
+    // dynamic-lookup hook. The orchestrator only needs `AgentDefinition`,
+    // so we wrap the resolver's record-shaped result with the same
+    // `toAgentDefinition` adapter the AgentService uses internally.
+    // When no resolver is wired the orchestrator only sees the static
+    // `config.agents` map — preserving legacy behaviour.
+    const orchestratorResolver = adapters.agentResolver
+        ? async (id) => {
+            const rec = await adapters.agentResolver.findById(id);
+            if (!rec || !rec.isActive)
+                return null;
+            // `toAgentDefinition` is the internal adapter — exposing it
+            // via the agent.service module keeps it private to the SDK.
+            // We dynamically require it here to dodge a circular import
+            // between factory.ts and agent.service.ts.
+            const { toAgentDefinition } = await Promise.resolve().then(() => __importStar(require('./services/agent.service')));
+            return toAgentDefinition(rec);
+        }
+        : undefined;
     const orchestrator = new orchestrator_service_1.OrchestratorService(config.anthropic, runner, {
         agents: config.agents ?? [],
         logger,
+        resolveAgent: orchestratorResolver,
     });
     // ─── Prepared-stream store + service ─────────────────────────────────────
     const preparedStreamStore = adapters.preparedStreamStore ?? new in_memory_prepared_stream_store_1.InMemoryPreparedStreamStore();
@@ -33,7 +86,9 @@ function createAgentForge(opts) {
     const rateLimiter = adapters.rateLimiter ?? new in_memory_1.InMemoryRateLimiter();
     // ─── Conversations + agents ──────────────────────────────────────────────
     const conversations = new conversation_service_1.ConversationService(repositories.conversations, repositories.messages);
-    const agents = new agent_service_1.AgentService(config.agents ?? [], runner, conversations, adapters.agentResolver, hooks);
+    const agents = new agent_service_1.AgentService(config.agents ?? [], runner, conversations, adapters.agentResolver, hooks, undefined, // connectorRegistry — wired by Nest binding when present
+    undefined, // copywriter — same
+    orchestrator);
     // ─── Background-job worker + queue (in-memory default) ───────────────────
     const agentJobWorker = new agent_job_worker_1.AgentJobWorker(orchestrator, conversations, {
         logger,

package/dist/index.d.ts

@@ -11,4 +11,5 @@ export { JOB_QUEUE, type JobQueue, type JobStatus, type JobState, type JobContex
 export { InMemoryJobQueue, type InMemoryJobQueueOptions, } from './adapters/job-queue/in-memory';
 export * from './services';
 export type { AgentResolver, AgentRecord, AgentResolveParams, } from './services/agent.service';
+export { toAgentDefinition } from './services/agent.service';
 export { createAgentForge, type CreateAgentForgeOptions, type AgentForgeContainer, type AgentForgeRepositories, type AgentForgeAdapters, } from './factory';

package/dist/index.js

@@ -27,7 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAgentForge = exports.InMemoryJobQueue = exports.JOB_QUEUE = exports.RedisRateLimiter = exports.InMemoryRateLimiter = exports.RATE_LIMITER = exports.PREPARED_STREAM_STORE = exports.CURRENT_USER = exports.AGENT_QUEUE_NAME = exports.AGENT_FORGE_CONFIG = void 0;
+exports.createAgentForge = exports.toAgentDefinition = exports.InMemoryJobQueue = exports.JOB_QUEUE = exports.RedisRateLimiter = exports.InMemoryRateLimiter = exports.RATE_LIMITER = exports.PREPARED_STREAM_STORE = exports.CURRENT_USER = exports.AGENT_QUEUE_NAME = exports.AGENT_FORGE_CONFIG = void 0;
 // ─── Constants ──────────────────────────────────────────────────────────────
 var constants_1 = require("./constants");
 Object.defineProperty(exports, "AGENT_FORGE_CONFIG", { enumerable: true, get: function () { return constants_1.AGENT_FORGE_CONFIG; } });
@@ -54,6 +54,12 @@ var in_memory_2 = require("./adapters/job-queue/in-memory");
 Object.defineProperty(exports, "InMemoryJobQueue", { enumerable: true, get: function () { return in_memory_2.InMemoryJobQueue; } });
 // ─── Services (framework-free) ──────────────────────────────────────────────
 __exportStar(require("./services"), exports);
+// `toAgentDefinition` is the adapter from the host's `AgentRecord` shape
+// to the SDK's runtime `AgentDefinition`. Exposed so the Nest binding
+// can bridge an `AgentResolver` into the orchestrator's dynamic-lookup
+// hook for Team flows.
+var agent_service_1 = require("./services/agent.service");
+Object.defineProperty(exports, "toAgentDefinition", { enumerable: true, get: function () { return agent_service_1.toAgentDefinition; } });
 // ─── Container factory ──────────────────────────────────────────────────────
 var factory_1 = require("./factory");
 Object.defineProperty(exports, "createAgentForge", { enumerable: true, get: function () { return factory_1.createAgentForge; } });

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

@@ -11,6 +11,38 @@ const model_strategy_1 = require("../types/model-strategy");
 const noopLogger = {
     log: () => { }, warn: () => { }, debug: () => { }, error: () => { },
 };
+/**
+ * Anthropic's newer model families deprecated the `temperature` parameter
+ * entirely — they auto-tune sampling internally and return 400
+ * `invalid_request_error: \`temperature\` is deprecated for this model` if
+ * the caller still sends one. Older families (3.x, the original 4.0
+ * releases) accept it fine.
+ *
+ * Detection by string match on the model id rather than a hard-coded
+ * allowlist: new model ids land between SDK releases, and we don't want
+ * to break temperature on legacy agents the day a new family ships.
+ * Pattern: anything that contains `-4-5`, `-4-6`, `-4-7`, …, `-5-*`,
+ * `-6-*`, etc. counts as "newer." Old 4-0 / 4-1 / 3-x ids are unaffected.
+ *
+ * Heuristic, not exhaustive — if a future family lands with a different
+ * naming convention we'll have to extend this. The cost of being wrong
+ * is a single 400 the operator can fix by clearing the temperature in
+ * the editor; the cost of NOT filtering is the same 400 today.
+ */
+function modelRejectsTemperature(model) {
+    if (!model)
+        return false;
+    // Normalize: ignore vendor prefixes like "anthropic/claude-..." and
+    // bracket suffixes like "claude-opus-4-7[1m]" (long-context variant).
+    const m = model.toLowerCase().replace(/\[[^\]]*\]/g, '');
+    // claude-*-4-5, 4-6, 4-7, 4-8 …
+    if (/claude-[a-z]+-4-([5-9])\b/.test(m))
+        return true;
+    // claude-*-5-x, claude-*-6-x, … (future major bumps)
+    if (/claude-[a-z]+-([5-9])-/.test(m))
+        return true;
+    return false;
+}
 /**
  * Framework-free runner for Claude. Handles the agentic loop (tool calls) for
  * sync runs and exposes streaming as an `AsyncGenerator<StreamChunk>` so any
@@ -33,7 +65,13 @@ class AgentRunnerService {
         const runnerDefault = this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
         const baseModel = overrides?.model ?? agent.model ?? runnerDefault;
         const maxTokens = overrides?.maxTokens ?? agent.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
-        const temperature = overrides?.temperature ?? agent.temperature ?? 1;
+        // Anthropic's newer models (Sonnet 4.6+, Haiku 4.5+) reject
+        // `temperature` when tools are present — they auto-tune sampling for
+        // tool use. Only forward it when the operator/caller declared one
+        // explicitly; never inject a default. Old models that required it
+        // accept its absence too (they fall back to their own internal
+        // default of 1.0).
+        const temperature = overrides?.temperature ?? agent.temperature;
         const { tools, extras } = this.buildToolList(agent, overrides);
         const systemPrompt = this.buildSystemPrompt(agent, tools, overrides);
         const toolCalls = [];
@@ -68,10 +106,17 @@ class AgentRunnerService {
             if (this.logger && selection.reason !== 'default' && selection.reason !== 'forced') {
                 this.logger.debug(`[modelRouter] agent=${agent.id} ${selection.reason}=${selection.trigger} → ${model}`);
             }
+            // Per-turn temperature gating. The PER-MODEL filter runs INSIDE
+            // the loop because `model` can change between turns (model
+            // strategy can route a long-context turn to a different family
+            // than the short turns above it). Computing once outside would
+            // either over-strip (drop temperature for a legacy follow-up
+            // model) or under-strip (forward it to a new-family upgrade).
+            const includeTemperature = typeof temperature === 'number' && !modelRejectsTemperature(model);
             const response = await this.client.messages.create({
                 model,
                 max_tokens: maxTokens,
-                temperature,
+                ...(includeTemperature ? { temperature } : {}),
                 system: systemPrompt,
                 messages: currentMessages,
                 tools: tools,
@@ -160,7 +205,13 @@ class AgentRunnerService {
         const runnerDefault = this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
         const baseModel = overrides?.model ?? agent.model ?? runnerDefault;
         const maxTokens = overrides?.maxTokens ?? agent.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
-        const temperature = overrides?.temperature ?? agent.temperature ?? 1;
+        // Anthropic's newer models (Sonnet 4.6+, Haiku 4.5+) reject
+        // `temperature` when tools are present — they auto-tune sampling for
+        // tool use. Only forward it when the operator/caller declared one
+        // explicitly; never inject a default. Old models that required it
+        // accept its absence too (they fall back to their own internal
+        // default of 1.0).
+        const temperature = overrides?.temperature ?? agent.temperature;
         const { tools, extras } = this.buildToolList(agent, overrides);
         const systemPrompt = this.buildSystemPrompt(agent, tools, overrides);
         let currentMessages = [...messages];
@@ -179,10 +230,12 @@ class AgentRunnerService {
             if (this.logger && selection.reason !== 'default' && selection.reason !== 'forced') {
                 this.logger.debug(`[modelRouter] agent=${agent.id} ${selection.reason}=${selection.trigger} → ${model}`);
             }
+            // Per-turn temperature gating — see `run()` above for rationale.
+            const includeTemperature = typeof temperature === 'number' && !modelRejectsTemperature(model);
             const stream = this.client.messages.stream({
                 model,
                 max_tokens: maxTokens,
-                temperature,
+                ...(includeTemperature ? { temperature } : {}),
                 system: systemPrompt,
                 messages: currentMessages,
                 tools: tools,

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

@@ -115,6 +115,11 @@ export declare class AgentService {
      *  meta-only render on the client when unwired or when generation
      *  fails. */
     private readonly copywriter?;
+    /** When wired, agents flagged `canOrchestrate=true` route through
+     *  the orchestrator's `stream()` instead of the bare runner so the
+     *  `delegate_to_*` synthetic tools fire. Standalone agents always
+     *  go straight to the runner. */
+    private readonly orchestrator?;
     constructor(agents: AgentDefinition[], runner: AgentRunnerService, conversations: ConversationService, 
     /** When wired, agents created via the admin UI are looked up here first;
      *  the hardcoded `agents` array remains a fallback for legacy installs. */
@@ -130,7 +135,12 @@ export declare class AgentService {
      *  microcopy shown in the in-chat approval bubble. Falls back to a
      *  meta-only render on the client when unwired or when generation
      *  fails. */
-    copywriter?: ApprovalCopywriterService | undefined);
+    copywriter?: ApprovalCopywriterService | undefined, 
+    /** When wired, agents flagged `canOrchestrate=true` route through
+     *  the orchestrator's `stream()` instead of the bare runner so the
+     *  `delegate_to_*` synthetic tools fire. Standalone agents always
+     *  go straight to the runner. */
+    orchestrator?: import("./orchestrator.service").OrchestratorService | undefined);
     /**
      * Look up the human-friendly connector name + tool description for a
      * given tool slug. Powers the friendly copy in `awaiting_approval` /
@@ -227,3 +237,13 @@ export declare class AgentService {
         chunk: StreamChunk;
     }>;
 }
+/**
+ * Map a persisted `AgentRecord` to the runtime `AgentDefinition` the runner
+ * expects. The `context` column (plain-text knowledge) is prepended to the
+ * system prompt — the cheapest path before RAG is implemented.
+ *
+ * Extra host fields (`appearance`, `slug`) are passed through as opaque
+ * properties so callers like `PublicChatController` can surface them to the
+ * widget. The runner ignores anything it doesn't recognize.
+ */
+export declare function toAgentDefinition(record: AgentRecord): AgentDefinition;

package/dist/services/agent.service.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentService = exports.AgentForbiddenError = void 0;
+exports.toAgentDefinition = toAgentDefinition;
 const tool_approval_gate_1 = require("./tool-approval-gate");
 class AgentForbiddenError extends Error {
     constructor(reason) {
@@ -26,7 +27,12 @@ class AgentService {
      *  microcopy shown in the in-chat approval bubble. Falls back to a
      *  meta-only render on the client when unwired or when generation
      *  fails. */
-    copywriter) {
+    copywriter, 
+    /** When wired, agents flagged `canOrchestrate=true` route through
+     *  the orchestrator's `stream()` instead of the bare runner so the
+     *  `delegate_to_*` synthetic tools fire. Standalone agents always
+     *  go straight to the runner. */
+    orchestrator) {
         this.agents = agents;
         this.runner = runner;
         this.conversations = conversations;
@@ -34,6 +40,7 @@ class AgentService {
         this.hooks = hooks;
         this.connectorRegistry = connectorRegistry;
         this.copywriter = copywriter;
+        this.orchestrator = orchestrator;
     }
     /**
      * Look up the human-friendly connector name + tool description for a
@@ -286,13 +293,30 @@ class AgentService {
         const fromConnectors = filter && resolvedExtras ? filter(resolvedExtras) : resolvedExtras;
         const extraTools = mergeExtraTools(params.overrides?.extraTools, fromConnectors);
         try {
-            for await (const chunk of this.runner.stream(agent, messages, {
-                userId: params.userId,
-                conversationId: params.conversationId,
-                agentId: conv.agentId,
-                messageId: 'streaming',
-                agent: { timezone: agent.timezone },
-            }, { ...(params.overrides ?? {}), extraTools })) {
+            // Team orchestrators route through OrchestratorService.stream()
+            // so the synthetic `delegate_to_*` tools the orchestrator was
+            // built with can fire. Standalone agents (or any orchestrator
+            // without an SDK that wired the service) go straight to the
+            // runner — the legacy path stays untouched for them.
+            const useOrchestrator = this.orchestrator &&
+                agent.canOrchestrate &&
+                (agent.subAgents?.length ?? 0) > 0;
+            const stream = useOrchestrator
+                ? this.orchestrator.stream(agent.id, messages, {
+                    userId: params.userId,
+                    conversationId: params.conversationId,
+                    agentId: conv.agentId,
+                    messageId: 'streaming',
+                    agent: { timezone: agent.timezone },
+                })
+                : this.runner.stream(agent, messages, {
+                    userId: params.userId,
+                    conversationId: params.conversationId,
+                    agentId: conv.agentId,
+                    messageId: 'streaming',
+                    agent: { timezone: agent.timezone },
+                }, { ...(params.overrides ?? {}), extraTools });
+            for await (const chunk of stream) {
                 if (chunk.type === 'text_delta')
                     fullContent += chunk.delta;
                 if (chunk.type === 'usage')
@@ -511,6 +535,16 @@ function toAgentDefinition(record) {
         // from the host's resolver to the SDK and every agent reads as
         // `undefined` (i.e. public).
         visibility: record.visibility,
+        // Team orchestrators need these to drive the delegation tool list
+        // the runner injects at run time. Standalone agents won't have
+        // them; the orchestrator service treats absence as "not an
+        // orchestrator" and falls through to the runner directly.
+        ...(extra.canOrchestrate !== undefined
+            ? { canOrchestrate: extra.canOrchestrate }
+            : {}),
+        ...(Array.isArray(extra.subAgents)
+            ? { subAgents: extra.subAgents }
+            : {}),
         ...(record.slug !== undefined ? { slug: record.slug } : {}),
         ...(extra.appearance !== undefined ? { appearance: extra.appearance } : {}),
     };

package/dist/services/orchestrator.service.d.ts

@@ -1,4 +1,4 @@
-import type { AgentResponse, AnthropicMessage, SubAgentDelegation, ToolExecutionContext } from '../types/agent.types';
+import type { AgentResponse, AnthropicMessage, StreamChunk, SubAgentDelegation, ToolExecutionContext } from '../types/agent.types';
 import type { AgentDefinition, AnthropicConfig } from '../types/config.types';
 import type { AgentRunnerService } from './agent-runner.service';
 import type { Logger } from './tool-registry.service';
@@ -13,6 +13,19 @@ export declare class OrchestratorError extends Error {
 export interface OrchestratorServiceOptions {
     agents: AgentDefinition[];
     logger?: Logger;
+    /**
+     * Optional dynamic resolver. When the orchestrator references a
+     * sub-agent that wasn't in the constructor's `agents[]` (typical for
+     * Team orchestrators whose members live in the database and change
+     * per-tenant), the service calls this to load it on demand. Returning
+     * `null` is treated as "member is gone" — the orchestrator emits an
+     * apology delegation_result and continues.
+     *
+     * The framework-free SDK doesn't know about the host's persistence,
+     * so this hook is the seam where the platform wires
+     * `AgentConfigService` + `toAgentDefinition` adapter in.
+     */
+    resolveAgent?(agentId: string): Promise<AgentDefinition | null> | AgentDefinition | null;
 }
 /**
  * Multi-agent workflows. Orchestrator agents can delegate tasks to specialized
@@ -29,7 +42,18 @@ export declare class OrchestratorService {
     private readonly agentsMap;
     private readonly client;
     private readonly logger;
+    private readonly resolveAgentHook?;
     constructor(anthropicConfig: AnthropicConfig, runner: AgentRunnerService, opts: OrchestratorServiceOptions);
+    /**
+     * Lookup with dynamic-resolver fallback. Hits the static map first
+     * (built from the constructor's `agents` list — covers the bootstrap
+     * use case), then falls back to the host-supplied `resolveAgent`
+     * hook (used by Team orchestrators whose members are loaded from
+     * the database per-tenant). Resolved agents are cached in the map
+     * for the lifetime of the service to avoid re-fetching across a
+     * multi-turn conversation.
+     */
+    private resolveAgentDynamic;
     /**
      * Run an agent. Orchestrators automatically get delegation tools injected.
      * Non-orchestrator agents fall straight through to the runner.
@@ -37,6 +61,21 @@ export declare class OrchestratorService {
     run(agentId: string, messages: AnthropicMessage[], context: ToolExecutionContext): Promise<AgentResponse & {
         delegations?: SubAgentDelegation[];
     }>;
+    /**
+     * Streaming variant. Orchestrators emit `delegation_start` /
+     * `delegation_result` chunks around each sub-agent invocation; the
+     * sub-agent's own chunks are forwarded byte-by-byte with their
+     * `actingAgentId` set so the client renders the member's avatar /
+     * name on the right bubble. Non-orchestrator agents short-circuit
+     * to the runner's stream.
+     *
+     * Implementation note: we drive the same Anthropic agentic loop as
+     * `runOrchestratorLoop` (no shortcut — the orchestrator's reasoning
+     * about WHO to delegate to is still a non-streamed messages.create
+     * call). The streaming part is the SUB-AGENT'S response, which is
+     * the part the visitor actually cares about seeing in real time.
+     */
+    stream(agentId: string, messages: AnthropicMessage[], context: ToolExecutionContext): AsyncGenerator<StreamChunk>;
     private runOrchestratorLoop;
     private buildDelegationTools;
     private getAgent;

package/dist/services/orchestrator.service.js

@@ -39,10 +39,32 @@ class OrchestratorService {
             baseURL: anthropicConfig.baseURL,
         });
         this.logger = opts.logger ?? noopLogger;
+        this.resolveAgentHook = opts.resolveAgent;
         for (const agent of opts.agents) {
             this.agentsMap.set(agent.id, agent);
         }
     }
+    /**
+     * Lookup with dynamic-resolver fallback. Hits the static map first
+     * (built from the constructor's `agents` list — covers the bootstrap
+     * use case), then falls back to the host-supplied `resolveAgent`
+     * hook (used by Team orchestrators whose members are loaded from
+     * the database per-tenant). Resolved agents are cached in the map
+     * for the lifetime of the service to avoid re-fetching across a
+     * multi-turn conversation.
+     */
+    async resolveAgentDynamic(agentId) {
+        const cached = this.agentsMap.get(agentId);
+        if (cached)
+            return cached;
+        if (!this.resolveAgentHook)
+            return undefined;
+        const resolved = await this.resolveAgentHook(agentId);
+        if (!resolved)
+            return undefined;
+        this.agentsMap.set(resolved.id, resolved);
+        return resolved;
+    }
     /**
      * Run an agent. Orchestrators automatically get delegation tools injected.
      * Non-orchestrator agents fall straight through to the runner.
@@ -55,6 +77,204 @@ class OrchestratorService {
         this.logger.debug(`Running orchestrator "${agentId}" with subagents: ${agent.subAgents.join(', ')}`);
         return this.runOrchestratorLoop(agent, messages, context);
     }
+    /**
+     * Streaming variant. Orchestrators emit `delegation_start` /
+     * `delegation_result` chunks around each sub-agent invocation; the
+     * sub-agent's own chunks are forwarded byte-by-byte with their
+     * `actingAgentId` set so the client renders the member's avatar /
+     * name on the right bubble. Non-orchestrator agents short-circuit
+     * to the runner's stream.
+     *
+     * Implementation note: we drive the same Anthropic agentic loop as
+     * `runOrchestratorLoop` (no shortcut — the orchestrator's reasoning
+     * about WHO to delegate to is still a non-streamed messages.create
+     * call). The streaming part is the SUB-AGENT'S response, which is
+     * the part the visitor actually cares about seeing in real time.
+     */
+    async *stream(agentId, messages, context) {
+        const agent = (await this.resolveAgentDynamic(agentId)) ?? null;
+        if (!agent) {
+            throw new OrchestratorError('agent_not_found', `Agent "${agentId}" not found`);
+        }
+        if (!agent.canOrchestrate || !agent.subAgents?.length) {
+            // No-op orchestration — fall straight through. The runner's
+            // chunks won't carry `actingAgentId`, which is exactly what we
+            // want: this conversation is bound to one agent.
+            yield* this.runner.stream(agent, messages, context);
+            return;
+        }
+        this.logger.debug(`Streaming orchestrator "${agentId}" with subagents: ${agent.subAgents.join(', ')}`);
+        const delegationTools = this.buildDelegationTools(agent);
+        const model = agent.model ?? this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
+        const maxTokens = agent.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
+        const anthropicTools = delegationTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.inputSchema,
+        }));
+        let currentMessages = [...messages];
+        let totalUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+        };
+        const messageId = (0, crypto_1.randomUUID)();
+        // Hard cap on orchestrator loops. Without one, a misbehaving model
+        // could ping-pong delegate → think → delegate forever. Three hops
+        // is enough for any well-formed team flow; the system prompt also
+        // discourages chaining so this is mostly defense in depth.
+        const MAX_LOOPS = 3;
+        let loopCount = 0;
+        while (true) {
+            if (loopCount++ > MAX_LOOPS) {
+                yield {
+                    type: 'text_delta',
+                    delta: '\n\n(Orchestrator stopped: too many delegations in one turn.)',
+                };
+                break;
+            }
+            // Orchestrator's planning step — non-streamed. The model picks a
+            // member, we forward its prose as a single text_delta so the
+            // chat shows the "Routing to …" reasoning, then we drain the
+            // tool_use blocks one by one.
+            const response = await this.client.messages.create({
+                model,
+                max_tokens: maxTokens,
+                system: agent.systemPrompt,
+                messages: currentMessages,
+                tools: anthropicTools,
+            });
+            totalUsage = {
+                inputTokens: totalUsage.inputTokens + response.usage.input_tokens,
+                outputTokens: totalUsage.outputTokens + response.usage.output_tokens,
+                totalTokens: totalUsage.totalTokens +
+                    response.usage.input_tokens +
+                    response.usage.output_tokens,
+            };
+            // Emit orchestrator's own prose (the "Routing to Ana…" line).
+            // No actingAgentId — that means "this is the team speaking as
+            // itself", which the client renders with the team's branding.
+            for (const block of response.content) {
+                if (block.type === 'text' && block.text.trim()) {
+                    yield { type: 'text_delta', delta: block.text };
+                }
+            }
+            if (response.stop_reason !== 'tool_use') {
+                // No delegation this turn — we're done.
+                break;
+            }
+            // Append the orchestrator's tool-use turn so the next loop sees
+            // it as part of the planning history.
+            const assistantMsg = {
+                role: 'assistant',
+                content: response.content,
+            };
+            currentMessages = [...currentMessages, assistantMsg];
+            const toolResults = [];
+            for (const block of response.content) {
+                if (block.type !== 'tool_use')
+                    continue;
+                const delegateTool = delegationTools.find((t) => t.name === block.name);
+                if (!delegateTool)
+                    continue;
+                const { task } = block.input;
+                const { subAgentId } = delegateTool;
+                const subAgent = await this.resolveAgentDynamic(subAgentId);
+                // delegation_start carries the member's identity so the client
+                // can render the routing hint AND swap the active bubble's
+                // avatar before the first text_delta arrives.
+                yield {
+                    type: 'delegation_start',
+                    subAgentId,
+                    subAgentName: subAgent?.name,
+                    subAgentAvatarUrl: undefined,
+                    task,
+                };
+                if (!subAgent) {
+                    // Member was deleted between team config + the orchestrator
+                    // call. Synthesize a tool_result so the orchestrator can
+                    // apologize on its next loop.
+                    const errMsg = `Sub-agent "${subAgentId}" is no longer available.`;
+                    yield {
+                        type: 'delegation_result',
+                        subAgentId,
+                        result: errMsg,
+                    };
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: block.id,
+                        content: errMsg,
+                    });
+                    continue;
+                }
+                // Stream the sub-agent's reply through the runner, tagging every
+                // chunk with the member's id so the client renders it with the
+                // member's identity. We accumulate the text body so the
+                // orchestrator's next loop can see what the member said.
+                const subMessages = [{ role: 'user', content: task }];
+                let assembled = '';
+                let subUsage = {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    totalTokens: 0,
+                };
+                for await (const chunk of this.runner.stream(subAgent, subMessages, {
+                    ...context,
+                    agentId: subAgentId,
+                })) {
+                    // text_delta is the only chunk type whose body we accumulate
+                    // for the orchestrator's tool_result. Other chunks (tool
+                    // calls inside the member, usage updates) we forward to the
+                    // visitor but don't feed back to the orchestrator.
+                    if (chunk.type === 'text_delta') {
+                        assembled += chunk.delta;
+                        yield { ...chunk, actingAgentId: subAgentId };
+                        continue;
+                    }
+                    if (chunk.type === 'usage') {
+                        subUsage = chunk.usage;
+                        yield { ...chunk, actingAgentId: subAgentId };
+                        continue;
+                    }
+                    if (chunk.type === 'done') {
+                        // Swallow the inner `done` — the OUTER loop emits its own
+                        // when the whole orchestrator turn ends.
+                        continue;
+                    }
+                    // Pass-through with identity tag (tool_use_start, tool_result,
+                    // awaiting_approval, tool_blocked, etc.).
+                    yield { ...chunk, actingAgentId: subAgentId };
+                }
+                totalUsage.inputTokens += subUsage.inputTokens;
+                totalUsage.outputTokens += subUsage.outputTokens;
+                totalUsage.totalTokens += subUsage.totalTokens;
+                yield {
+                    type: 'delegation_result',
+                    subAgentId,
+                    result: assembled,
+                };
+                toolResults.push({
+                    type: 'tool_result',
+                    tool_use_id: block.id,
+                    // Anthropic rejects empty user-message content with a 400. A
+                    // sub-agent can produce zero text_deltas legitimately (it ran
+                    // only tools and never spoke) — when that happens we feed a
+                    // sentinel string back into the orchestrator's next loop so
+                    // the conversation stays well-formed. The sentinel doubles as
+                    // a signal the orchestrator can interpret ("the member acted
+                    // silently — decide whether to ask the user for confirmation").
+                    content: assembled || '(member completed silently — no textual response)',
+                });
+            }
+            // Feed the tool results back into the orchestrator's next loop.
+            currentMessages = [
+                ...currentMessages,
+                { role: 'user', content: toolResults },
+            ];
+        }
+        yield { type: 'usage', usage: totalUsage };
+        yield { type: 'done', messageId };
+    }
     async runOrchestratorLoop(orchestrator, messages, context) {
         const delegations = [];
         const delegationTools = this.buildDelegationTools(orchestrator);