@kuralle-agents/core 0.6.1 → 0.7.0

package/dist/runtime/select.js

@@ -1,129 +1,159 @@
 import { generateObject } from 'ai';
 import { z } from 'zod';
-const selectionSchema = z.object({
-    action: z.enum(['enterFlow', 'route', 'keep']),
+import { availableHostFlows, collectTransferTargets } from './hostControlTools.js';
+const guardSchema = z.object({
+    action: z.enum(['keep', 'enterFlow', 'transfer']),
     flowName: z.union([z.string(), z.null()]),
     agentId: z.union([z.string(), z.null()]),
     reason: z.union([z.string(), z.null()]),
+    confidence: z.union([z.number(), z.null()]),
 });
-export async function selectHostTarget(options) {
-    const { agent, run, model } = options;
+const dispatcherSchema = z.object({
+    action: z.enum(['enterFlow', 'transfer']),
+    flowName: z.union([z.string(), z.null()]),
+    agentId: z.union([z.string(), z.null()]),
+    reason: z.union([z.string(), z.null()]),
+});
+export async function classifyHostTarget(options) {
+    const { agent, run, model, allowKeep } = options;
     const flows = agent.flows ?? [];
     const routes = agent.routes ?? [];
-    if (flows.length === 0 && routes.length === 0) {
-        return { kind: 'keep' };
-    }
     const latestUser = latestUserMessage(run.messages);
     if (!latestUser) {
-        return { kind: 'keep' };
+        return { action: 'keep', confidence: 1 };
     }
     const completed = run.state.__completedFlows;
     const completedFlows = Array.isArray(completed) ? completed : [];
     const excluded = new Set(options.excludeFlowNames ?? []);
     const availableFlows = flows.filter((flow) => !completedFlows.includes(flow.name) && !excluded.has(flow.name));
-    const agentRoutes = routes.filter((route) => route.agent);
-    if (availableFlows.length === 0 && agentRoutes.length === 0) {
-        return { kind: 'keep' };
-    }
-    if (availableFlows.length === 1 && agentRoutes.length === 0) {
-        return { kind: 'enterFlow', flow: availableFlows[0] };
-    }
-    const deterministic = deterministicRouteMatch(latestUser, routes, availableFlows);
-    if (deterministic) {
-        return deterministic;
+    const transferTargets = collectTransferTargets(agent);
+    const flowRoutes = routes.filter((route) => route.flow);
+    const hasFlowTargets = availableFlows.length > 0 || flowRoutes.length > 0;
+    const hasTransferTargets = transferTargets.length > 0 || routes.some((r) => r.agent);
+    if (!hasFlowTargets && !hasTransferTargets) {
+        return { action: 'keep', confidence: 1 };
     }
     const flowLines = availableFlows
         .map((flow) => `- flow "${flow.name}": ${flow.description}`)
         .join('\n');
-    const routeLines = routes
-        .map((route, index) => formatRouteLine(route, index))
+    const routeLines = routes.map((route, index) => formatRouteLine(route, index)).join('\n');
+    const transferLines = transferTargets
+        .map((t) => `- agent "${t.id}": ${t.descriptions.join('; ')}`)
         .join('\n');
+    const schema = allowKeep ? guardSchema : dispatcherSchema;
+    const actionHint = allowKeep
+        ? 'Return keep, enterFlow with flowName, or transfer with agentId.'
+        : 'Return enterFlow with flowName or transfer with agentId. Do not return keep.';
     const { object } = await generateObject({
         model,
-        schema: selectionSchema,
+        schema,
         temperature: 0,
         system: 'You are an internal routing classifier. Choose exactly one action. ' +
             'Output schema fields only — never user-facing prose. ' +
-            'Prefer route when a route condition clearly matches; else enterFlow when a flow description matches an uncompleted flow; else keep. Never re-enter a completed flow.',
+            'Reason over semantic descriptions only; never match keywords or substrings.',
         prompt: `User message:\n${latestUser}\n\n` +
             (completedFlows.length > 0 ? `Completed flows: ${completedFlows.join(', ')}\n\n` : '') +
             (flowLines ? `Available flows:\n${flowLines}\n\n` : '') +
             (routeLines ? `Routes:\n${routeLines}\n\n` : '') +
-            'Return enterFlow with flowName, route with agentId, or keep.',
+            (transferLines ? `Transfer targets:\n${transferLines}\n\n` : '') +
+            actionHint,
     });
-    if (object.action === 'route') {
-        const matchedRoute = routes.find((candidate) => (object.agentId != null && candidate.agent === object.agentId) ||
-            (object.flowName != null && candidate.flow === object.flowName));
-        if (matchedRoute?.flow) {
-            const flow = flows.find((candidate) => candidate.name === matchedRoute.flow);
-            if (flow) {
-                return { kind: 'enterFlow', flow };
-            }
+    const rawConfidence = allowKeep && 'confidence' in object ? object.confidence : null;
+    const confidence = typeof rawConfidence === 'number' ? rawConfidence : undefined;
+    if (object.action === 'transfer') {
+        const agentId = object.agentId ?? undefined;
+        if (agentId && isValidTransferTarget(agent, agentId)) {
+            return {
+                action: 'transfer',
+                targetAgentId: agentId,
+                reason: object.reason ?? undefined,
+                confidence,
+            };
         }
+        const matchedRoute = routes.find((candidate) => (agentId != null && candidate.agent === agentId) ||
+            (object.flowName != null && candidate.flow === object.flowName));
         if (matchedRoute?.agent) {
-            return { kind: 'route', agentId: matchedRoute.agent, reason: object.reason ?? undefined };
+            return {
+                action: 'transfer',
+                targetAgentId: matchedRoute.agent,
+                reason: object.reason ?? undefined,
+                confidence,
+            };
         }
-        if (object.agentId != null) {
-            if (agent.handoffs?.includes(object.agentId) || agent.agents?.some((child) => child.id === object.agentId)) {
-                return { kind: 'route', agentId: object.agentId, reason: object.reason ?? undefined };
+        if (matchedRoute?.flow) {
+            const flow = flows.find((candidate) => candidate.name === matchedRoute.flow);
+            if (flow && availableFlows.some((f) => f.name === flow.name)) {
+                return {
+                    action: 'enterFlow',
+                    flowName: flow.name,
+                    reason: object.reason ?? undefined,
+                    confidence,
+                };
             }
         }
     }
     if (object.action === 'enterFlow' && object.flowName != null) {
         const flow = availableFlows.find((candidate) => candidate.name === object.flowName);
         if (flow) {
-            return { kind: 'enterFlow', flow };
+            return {
+                action: 'enterFlow',
+                flowName: flow.name,
+                reason: object.reason ?? undefined,
+                confidence,
+            };
         }
     }
-    if (object.action === 'enterFlow' && availableFlows.length === 1) {
-        return { kind: 'enterFlow', flow: availableFlows[0] };
+    if (!allowKeep) {
+        if (availableFlows.length === 1) {
+            return { action: 'enterFlow', flowName: availableFlows[0].name };
+        }
+        if (transferTargets.length === 1) {
+            return { action: 'transfer', targetAgentId: transferTargets[0].id };
+        }
+        throw new Error('Pure dispatcher could not resolve a valid transfer target');
     }
-    return keywordRouteFallback(latestUser, routes, availableFlows);
+    return { action: 'keep', confidence: confidence ?? 1 };
 }
-function deterministicRouteMatch(message, routes, availableFlows) {
-    const lower = message.toLowerCase();
-    const hits = [];
-    for (const route of routes) {
-        const terms = route.when
-            .toLowerCase()
-            .split(/[^a-z0-9]+/)
-            .filter((term) => term.length > 3);
-        if (!terms.some((term) => lower.includes(term))) {
-            continue;
-        }
-        if (route.flow) {
-            const flow = availableFlows.find((candidate) => candidate.name === route.flow);
-            if (flow) {
-                hits.push({ kind: 'enterFlow', flow });
-            }
+/** @deprecated Use classifyHostTarget — kept as alias for test injection. */
+export async function selectHostTarget(options) {
+    const verdict = await classifyHostTarget({ ...options, allowKeep: true });
+    if (verdict.action === 'enterFlow' && verdict.flowName) {
+        const flow = (options.agent.flows ?? []).find((f) => f.name === verdict.flowName);
+        if (flow) {
+            return { kind: 'enterFlow', flow };
         }
-        else if (route.agent) {
-            hits.push({ kind: 'route', agentId: route.agent });
+    }
+    if (verdict.action === 'transfer' && verdict.targetAgentId) {
+        return { kind: 'route', agentId: verdict.targetAgentId, reason: verdict.reason };
+    }
+    return { kind: 'keep' };
+}
+export function verdictToSelection(verdict, agent) {
+    if (verdict.action === 'keep') {
+        return { kind: 'keep' };
+    }
+    if (verdict.action === 'enterFlow' && verdict.flowName) {
+        const flow = (agent.flows ?? []).find((f) => f.name === verdict.flowName);
+        if (flow) {
+            return { kind: 'enterFlow', flow };
         }
     }
-    if (hits.length === 1) {
-        return hits[0];
+    if (verdict.action === 'transfer' && verdict.targetAgentId) {
+        return { kind: 'route', agentId: verdict.targetAgentId, reason: verdict.reason };
     }
     return undefined;
 }
-function keywordRouteFallback(message, routes, availableFlows) {
-    const lower = message.toLowerCase();
-    for (const route of routes) {
-        if (!route.flow) {
-            continue;
-        }
-        const terms = route.when
-            .toLowerCase()
-            .split(/[^a-z0-9]+/)
-            .filter((term) => term.length > 3);
-        if (terms.some((term) => lower.includes(term))) {
-            const flow = availableFlows.find((candidate) => candidate.name === route.flow);
-            if (flow) {
-                return { kind: 'enterFlow', flow };
-            }
-        }
+function isValidTransferTarget(agent, targetId) {
+    if (agent.handoffs?.includes(targetId)) {
+        return true;
     }
-    return { kind: 'keep' };
+    if (agent.agents?.some((child) => child.id === targetId)) {
+        return true;
+    }
+    if (agent.routes?.some((route) => route.agent === targetId)) {
+        return true;
+    }
+    return false;
 }
 function formatRouteLine(route, index) {
     const target = route.agent ? `agent "${route.agent}"` : route.flow ? `flow "${route.flow}"` : 'keep';
@@ -149,3 +179,4 @@ function latestUserMessage(messages) {
     }
     return undefined;
 }
+export { availableHostFlows };

package/dist/tools/enterFlow.d.ts

@@ -0,0 +1,14 @@
+import type { AnyTool } from '../types/effectTool.js';
+import type { Flow } from '../types/flow.js';
+/** Result shape emitted by the `enter_flow` control tool. `classifyControl`
+ *  recognizes it and turns it into a `TurnControl{ type: 'enterFlow' }`, so the
+ *  host loop enters the named flow — routing folded into the speaking turn
+ *  instead of a separate upfront `generateObject` selector. */
+export interface EnterFlowResult {
+    __enterFlow: true;
+    flowName: string;
+    reason?: string;
+}
+export declare function isEnterFlowResult(result: unknown): result is EnterFlowResult;
+/** Build the model-visible `enter_flow` control tool from available flows. */
+export declare function createEnterFlowTool(availableFlows: Flow[]): AnyTool;

package/dist/tools/enterFlow.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { defineTool } from './effect/defineTool.js';
+export function isEnterFlowResult(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        '__enterFlow' in result &&
+        result.__enterFlow === true &&
+        'flowName' in result);
+}
+/** Build the model-visible `enter_flow` control tool from available flows. */
+export function createEnterFlowTool(availableFlows) {
+    const names = availableFlows.map((flow) => flow.name);
+    const lines = availableFlows
+        .map((flow) => `- ${flow.name}: ${flow.description}`)
+        .join('\n');
+    return defineTool({
+        name: 'enter_flow',
+        description: 'Start a structured procedure when the user wants to do one of the tasks below. ' +
+            'Call this INSTEAD of answering in prose; do not announce the transition to the user.\n\n' +
+            `Available procedures:\n${lines}`,
+        input: z.object({
+            flowName: z.enum(names).describe('Which procedure to start'),
+            reason: z.string().describe('Why this procedure, in a few words'),
+        }),
+        execute: async ({ flowName, reason }) => ({
+            __enterFlow: true,
+            flowName,
+            reason,
+        }),
+    });
+}

package/dist/types/channel.d.ts

@@ -2,6 +2,12 @@ import type { ToolSet } from 'ai';
 import type { RunContext } from './run-context.js';
 import type { FlowNode } from './flow.js';
 import type { AnyTool } from './effectTool.js';
+import type { DispatchMode } from '../runtime/dispatchMode.js';
+export type DriverOutputCapability = 'kuralle-controlled-text' | 'kuralle-controlled-tts' | 'native-realtime';
+export interface HostControlContext {
+    dispatchMode: DispatchMode;
+    advisoryDispatch: boolean;
+}
 export interface ResolvedNode {
     node: FlowNode;
     prompt: string;
@@ -9,8 +15,10 @@ export interface ResolvedNode {
     localTools?: Record<string, AnyTool>;
     /** Free-conversation reply (host loop): keeps model control tools even when outOfBandControl is on. */
     freeConversation?: boolean;
+    hostControl?: HostControlContext;
 }
 export interface ChannelDriver {
+    readonly outputCapability?: DriverOutputCapability;
     runAgentTurn(node: ResolvedNode, ctx: RunContext): Promise<TurnResult>;
     awaitUser(ctx: RunContext): Promise<UserSignal>;
     runStructured?(node: Extract<FlowNode, {
@@ -48,6 +56,10 @@ export type TurnControl = {
     type: 'handoff';
     target: string;
     reason?: string;
+} | {
+    type: 'enterFlow';
+    flowName: string;
+    reason?: string;
 } | {
     type: 'end';
     reason: string;

package/dist/types/route.d.ts

@@ -7,9 +7,9 @@ export interface Route {
     filter?: HandoffInputFilter;
 }
 export interface RoutingPolicy {
-    mode?: 'structured' | 'llm';
+    /** Model for control-path reasoning (guard, pure-dispatcher classifier). */
     model?: LanguageModel;
-    default?: string;
-    always?: boolean;
+    /** Buffer text until guard/control resolves (compliance text). Default: relaxed cancel-on-late-control. */
+    dispatch?: 'strict';
 }
 export type { HandoffInputFilter } from '../runtime/handoffFilters.js';

package/guides/AGENTS.md

@@ -52,8 +52,6 @@ await handle;
 
 Attach one or more flows with `flows: [ defineFlow({ ... }) ]`. Build nodes with `reply`, `collect`, `decide`, and `action`. The runtime emits `node-enter`, `flow-transition`, and `flow-end` events on the turn stream.
 
-Hybrid mode (`hybrid: true` on `defineFlow`) lets the agent answer off-flow questions between steps and resume the SOP.
-
 ```ts
 import { z } from 'zod';
 
@@ -78,7 +76,6 @@ const bookingFlow = defineFlow({
   description: 'Book an appointment',
   start: collectDate,
   nodes: [collectDate, confirm],
-  hybrid: true,
 });
 
 const bookingAgent = defineAgent({
@@ -99,7 +96,7 @@ See [FLOWS.md](./FLOWS.md) for transition patterns and a full runnable example.
 
 ## Routing and triage
 
-Add `routes` and `routing: { mode: 'structured', model }` to route user input to specialist agents or flows via the invisible `handoff` tool. Nest specialists in `agents`.
+Add `routes`/`agents` to route user input to specialists. Routing is derived from shape: an agent with its own answering surface (instructions/flows/tools) folds an invisible `transfer_to_agent` tool into its turn; a routes-only agent with no answering surface becomes a silent **pure dispatcher**. Set `routing: { model }` to choose the control-reasoning model. Nest specialists in `agents`.
 
 ```ts
 const billing = defineAgent({
@@ -117,7 +114,7 @@ const support = defineAgent({
   routes: [
     { agent: 'billing', when: 'billing, payment, invoice, or refund questions' },
   ],
-  routing: { mode: 'structured', model },
+  routing: { model },
   agents: [billing],
 });
 
@@ -160,7 +157,7 @@ const lead = defineAgent({
   model,
   routes: [{ agent: 'specialist', when: 'specialist topic' }],
   agents: [specialist],
-  routing: { mode: 'structured', model },
+  routing: { model },
 });
 ```
 
@@ -251,7 +248,7 @@ await handle;
 
 ### When NOT to Use
 
-- **Routing to a different agent persona** — Use `routes` + structured routing instead
+- **Routing to a different agent persona** — Use `routes`/`agents` (derived routing) instead
 - **Simple API calls** — Use `defineTool` / `createTool` directly without the specialist framing
 
 ### Example
@@ -271,7 +268,7 @@ See [standalone-agent.ts](../examples/agents/standalone-agent.ts) (Example 4) fo
 ## Best Practices
 
 1. **Keep SOPs in flows** — If instructions exceed ~20 lines of procedure, move them into flow nodes
-2. **Use structured routing for triage** — Prevents user-visible handoff leaks
+2. **Use derived routing for triage** — Prevents user-visible handoff leaks
 3. **Tools return data only** — No conversational text in tool outputs; flow tools return transitions
 4. **Filter handoff context** — Use `handoffFilters` on routes when specialists need trimmed history
 5. **Lead agent synthesizes** — Consultation tools return structured data; the lead agent speaks to the user
@@ -281,8 +278,8 @@ See [standalone-agent.ts](../examples/agents/standalone-agent.ts) (Example 4) fo
 | Pattern | Description | Handoffs | User sees |
 |---------|-------------|----------|-----------|
 | Agent Consultation | Lead calls specialist tools, synthesizes one answer | No | One agent |
-| Structured routing | `routes` + `routing: { mode: 'structured' }` picks a specialist | Yes (invisible) | Active specialist after route |
+| Derived routing | `routes`/`agents` route to a specialist (model-reasoned over `when`) | Yes (invisible) | Active specialist after route |
 | Explicit handoffs | `handoffs: ['billing']` exposes the `handoff` tool | Yes (invisible) | Active specialist after handoff |
 | Free conversation | No `flows` or `routes` | No | Same agent throughout |
 
-**Agent consultation** keeps the customer with one lead persona. **Structured routing** transfers session control to a specialist when the topic matches.
+**Agent consultation** keeps the customer with one lead persona. **Derived routing** transfers session control to a specialist when the topic matches.

package/guides/FLOWS.md

@@ -9,8 +9,6 @@ Attach one or more flows to an agent via `defineAgent({ flows: [...] })`. The `R
 Key features:
 - Node builders: `reply`, `collect`, `decide`, `action`
 - Tool-driven transitions via `createFlowTransition()` (AI SDK tools) or `next` callbacks on `reply` nodes
-- Hybrid mode (`hybrid: true` on `defineFlow`) to answer off-topic questions and resume the flow
-
 ## Minimal flow example
 
 See `examples/flows/restaurant-reservation.ts` for a full runnable example. Sketch:
@@ -52,7 +50,6 @@ const agent = defineAgent({
       name: 'booking',
       start: greeting,
       nodes: [greeting, confirm],
-      hybrid: true,
     }),
   ],
 });
@@ -74,4 +71,3 @@ For tools that return `createFlowTransition(targetId, data)`, the runtime interp
 - Return `createFlowTransition(targetId, data)` from tool `execute` handlers that move the flow.
 - On `reply` nodes, return `{ goto: nextNode, data }` from `next` when a tool result is ready.
 - Use `createFlowUpdate(data, text, keys)` to merge state without leaving the node.
-- Set `hybrid: true` on the flow when the agent should answer off-script questions between steps.

package/guides/RUNTIME.md

@@ -104,8 +104,8 @@ For external side effects, tools receive a stable `idempotencyKey` in
 
 ## Routing & Handoffs
 
-Use `routes` + `routing: { mode: 'structured', model }` for triage without user-visible leaks.
-Use `handoffs: ['billing']` to expose the invisible `handoff` tool to specialists.
+Use `routes`/`agents` for triage without user-visible leaks — routing is derived from shape (a routes-only agent is a silent pure dispatcher; an answering agent folds `transfer_to_agent` into its turn). Set `routing: { model }` to choose the control model.
+Use `handoffs: ['billing']` to expose the invisible `transfer_to_agent` tool to specialists.
 
 ```ts
 const support = defineAgent({

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/kuralle/kuralle-agents.git",
     "directory": "packages/kuralle-core"
   },
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A framework for structured conversational AI agents",
   "publishConfig": {
     "access": "public"
@@ -103,7 +103,7 @@
     "typescript": "^5.3.0",
     "vitest": "^3.2.4",
     "zod": "^4.0.0",
-    "@kuralle-agents/realtime-audio": "0.6.1"
+    "@kuralle-agents/realtime-audio": "0.7.0"
   },
   "dependencies": {
     "chrono-node": "^2.6.0"

package/dist/capabilities/HandoffCapability.d.ts

@@ -1,18 +0,0 @@
-import type { Capability, ToolDeclaration, PromptSection, CapabilityAction } from './index.js';
-export interface HandoffTarget {
-    id: string;
-    name: string;
-    description?: string;
-}
-/**
- * Exposes a single `transfer_to_agent` tool for agents that have explicit
- * `canHandoffTo` targets. Unlike TriageCapability (one tool per route),
- * this uses a single tool with an enum parameter for the target agent.
- */
-export declare class HandoffCapability implements Capability {
-    private targets;
-    constructor(targets: HandoffTarget[]);
-    getTools(): ToolDeclaration[];
-    getPromptSections(): PromptSection[];
-    processToolResult(toolName: string, args: unknown, result: unknown): CapabilityAction | null;
-}

package/dist/capabilities/HandoffCapability.js

@@ -1,69 +0,0 @@
-import { z } from 'zod';
-import { isHandoffResult } from '../tools/handoff.js';
-// ─── HandoffCapability ───────────────────────────────────────────────────────
-/**
- * Exposes a single `transfer_to_agent` tool for agents that have explicit
- * `canHandoffTo` targets. Unlike TriageCapability (one tool per route),
- * this uses a single tool with an enum parameter for the target agent.
- */
-export class HandoffCapability {
-    targets;
-    constructor(targets) {
-        this.targets = targets;
-    }
-    getTools() {
-        if (this.targets.length === 0)
-            return [];
-        const agentIds = this.targets.map(t => t.id);
-        const agentDescriptions = this.targets
-            .map(t => `- ${t.id} (${t.name})${t.description ? `: ${t.description}` : ''}`)
-            .join('\n');
-        return [
-            {
-                name: 'transfer_to_agent',
-                description: `Transfer the conversation to a specialized agent.\n` +
-                    `Do NOT mention this transfer to the user.\n\n` +
-                    `Available agents:\n${agentDescriptions}`,
-                parameters: z.object({
-                    targetAgentId: z.enum(agentIds).describe('The ID of the agent to transfer to'),
-                    reason: z.string().describe('Why you are transferring — include relevant context'),
-                    summary: z.string().optional().describe('Optional summary of what has been done so far'),
-                }),
-                execute: async (args) => ({
-                    __handoff: true,
-                    targetAgentId: args.targetAgentId,
-                    targetAgent: args.targetAgentId,
-                    reason: args.reason,
-                    summary: args.summary,
-                }),
-            },
-        ];
-    }
-    getPromptSections() {
-        return [];
-    }
-    processToolResult(toolName, args, result) {
-        if (toolName === 'transfer_to_triage') {
-            if (!isHandoffResult(result))
-                return null;
-            const target = result.targetAgentId ?? result.targetAgent;
-            if (!target)
-                return null;
-            return {
-                type: 'handoff',
-                targetAgent: target,
-                reason: result.reason,
-            };
-        }
-        // Match both 'transfer_to_agent' (capability name) and 'handoff' (legacy flow injection key)
-        if (toolName !== 'transfer_to_agent' && toolName !== 'handoff')
-            return null;
-        if (!isHandoffResult(result))
-            return null;
-        return {
-            type: 'handoff',
-            targetAgent: result.targetAgentId,
-            reason: result.reason,
-        };
-    }
-}

package/dist/capabilities/TriageCapability.d.ts

@@ -1,15 +0,0 @@
-import type { Capability, ToolDeclaration, PromptSection, CapabilityAction } from './index.js';
-import type { AgentRoute } from '../types/index.js';
-/**
- * Exposes triage routing as tools: one `route_to_<agentId>` tool per route.
- * The LLM selects the appropriate route; processToolResult converts the
- * tool result to a `handoff` action for the host.
- */
-export declare class TriageCapability implements Capability {
-    private routes;
-    private defaultAgent;
-    constructor(routes: AgentRoute[], defaultAgent?: string);
-    getTools(): ToolDeclaration[];
-    getPromptSections(): PromptSection[];
-    processToolResult(toolName: string, args: unknown, result: unknown): CapabilityAction | null;
-}

package/dist/capabilities/TriageCapability.js

@@ -1,60 +0,0 @@
-import { z } from 'zod';
-import { isHandoffResult } from '../tools/handoff.js';
-// ─── TriageCapability ────────────────────────────────────────────────────────
-/**
- * Exposes triage routing as tools: one `route_to_<agentId>` tool per route.
- * The LLM selects the appropriate route; processToolResult converts the
- * tool result to a `handoff` action for the host.
- */
-export class TriageCapability {
-    routes;
-    defaultAgent;
-    constructor(routes, defaultAgent) {
-        this.routes = routes;
-        this.defaultAgent = defaultAgent;
-    }
-    getTools() {
-        return this.routes.map(route => ({
-            name: `route_to_${route.agentId}`,
-            description: route.description,
-            parameters: z.object({
-                reason: z.string().describe('Why this route was chosen — include relevant context from the conversation'),
-            }),
-            execute: async (args) => ({
-                __handoff: true,
-                targetAgentId: route.agentId,
-                targetAgent: route.agentId,
-                reason: args.reason,
-            }),
-        }));
-    }
-    getPromptSections() {
-        if (this.routes.length === 0)
-            return [];
-        const routeList = this.routes
-            .map(r => `- route_to_${r.agentId}: ${r.description}`)
-            .join('\n');
-        const defaultNote = this.defaultAgent
-            ? `\nIf no route clearly matches, route to ${this.defaultAgent}.`
-            : '';
-        return [
-            {
-                role: 'routing',
-                content: `Route the user to the most appropriate agent using the routing tools below.\n` +
-                    `Do NOT mention routing or agent transfers to the user.\n\n` +
-                    `Available routes:\n${routeList}${defaultNote}`,
-            },
-        ];
-    }
-    processToolResult(toolName, args, result) {
-        if (!toolName.startsWith('route_to_'))
-            return null;
-        if (!isHandoffResult(result))
-            return null;
-        return {
-            type: 'handoff',
-            targetAgent: result.targetAgentId,
-            reason: result.reason,
-        };
-    }
-}