@kuralle-agents/core 0.6.1 → 0.7.0

package/README.md

@@ -99,17 +99,15 @@ Rule of thumb: if you're pasting more than ~20 lines of procedure into a system
 ```ts
 const triage = defineAgent({
   id: 'triage',
-  instructions: 'Route to the right specialist.',
   model: openai('gpt-4o-mini'),
   routes: [
     { agent: 'billing', when: 'billing question' },
-    { agent: 'support', when: 'support request' },
+    { agent: 'support', when: 'support request or anything else' },
   ],
-  routing: { mode: 'structured', default: 'support' },
 });
 ```
 
-`mode: 'structured'` routes via schema — the routing decision never surfaces to the user.
+With only `routes`/`agents` and no answering surface (no `instructions`/`flows`/`tools`), `triage` derives as a **pure dispatcher**: it silently classifies and routes. The decision is model-reasoned over the `when` descriptions and never surfaces to the user. Model every fallback as a normal route with a semantic `when` (e.g. "or anything else") — there is no `routing.default`. Optionally set `routing: { model }` to pick the control-reasoning model.
 
 ## Sessions
 

package/dist/capabilities/index.d.ts

@@ -141,11 +141,8 @@ export declare class CapabilityHost {
     /** Number of registered capabilities. */
     get capabilityCount(): number;
 }
-export { TriageCapability } from './TriageCapability.js';
 export { ExtractionCapability } from './ExtractionCapability.js';
 export type { ExtractionCapabilityConfig } from './ExtractionCapability.js';
-export { HandoffCapability } from './HandoffCapability.js';
-export type { HandoffTarget } from './HandoffCapability.js';
 export { GuardrailCapability } from './GuardrailCapability.js';
 export { AutoRetrieveCapability } from './AutoRetrieveCapability.js';
 export type { AutoRetrieveCapabilityConfig, RetrieveProvider } from './AutoRetrieveCapability.js';

package/dist/capabilities/index.js

@@ -116,9 +116,7 @@ function assemblePromptSections(basePrompt, sections) {
     return parts.join('\n\n');
 }
 // ─── Re-exports ──────────────────────────────────────────────────────────────
-export { TriageCapability } from './TriageCapability.js';
 export { ExtractionCapability } from './ExtractionCapability.js';
-export { HandoffCapability } from './HandoffCapability.js';
 export { GuardrailCapability } from './GuardrailCapability.js';
 export { AutoRetrieveCapability } from './AutoRetrieveCapability.js';
 export { PassThroughRefinement } from './refinement/PassThrough.js';

package/dist/flow/classifyControl.js

@@ -1,5 +1,6 @@
 import { isHandoffResult } from '../tools/handoff.js';
 import { isFinalResult } from '../tools/final.js';
+import { isEnterFlowResult } from '../tools/enterFlow.js';
 import { isEscalateResult, isRecoverResult } from '../tools/controlResults.js';
 export function classifyControl(result) {
     if (isHandoffResult(result)) {
@@ -9,6 +10,9 @@ export function classifyControl(result) {
             reason: result.reason,
         };
     }
+    if (isEnterFlowResult(result)) {
+        return { type: 'enterFlow', flowName: result.flowName, reason: result.reason };
+    }
     if (isFinalResult(result)) {
         return { type: 'end', reason: result.text };
     }

package/dist/flow/collectDigression.js

@@ -44,7 +44,6 @@ export async function runCollectDigression(options) {
         agent,
         run,
         model: agent.routing?.model ?? ctx.controlModel,
-        alwaysRoute: agent.routing?.always === true,
         excludeFlowNames: [activeFlowName],
     });
     if (selection.kind === 'route') {

package/dist/flow/controlEvaluator.js

@@ -9,6 +9,9 @@ function controlToTransition(control) {
             return { kind: 'escalate', reason: control.reason };
         case 'recover':
             return { kind: 'end', reason: control.reason ?? 'error_degraded' };
+        case 'enterFlow':
+            // enter_flow is host-turn-only; never injected into in-flow reply nodes.
+            throw new Error(`enter_flow control reached the in-flow evaluator (flow "${control.flowName}") — it is host-only`);
     }
 }
 export async function evaluateReplyControl(signal) {

package/dist/flow/flowControlTools.js

@@ -2,6 +2,7 @@
 export const FLOW_TRANSITION_CONTROL_TOOL_NAMES = new Set([
     'handoff',
     'transfer_to_agent',
+    'enter_flow',
     'final',
     'escalate',
     'recover',

package/dist/index.d.ts

@@ -60,8 +60,8 @@ export type { HandoffInputFilter, HandoffInputData, HandoffInputResult, } from '
 export { DefaultToolExecutor, DefaultConversationState, DefaultConversationEventLog, DefaultAgentStateController, createFoundation, } from './foundation/index.js';
 export type { ToolExecutor, ConversationState, ConversationEventLog, ConversationEvent, AgentStateController, Foundation, FoundationConfig, } from './foundation/index.js';
 export type * from './types/index.js';
-export { CapabilityHost, TriageCapability, ExtractionCapability, HandoffCapability, GuardrailCapability, AutoRetrieveCapability, PassThroughRefinement, PassThroughValidation, toGeminiDeclarations, toAISDKTools, } from './capabilities/index.js';
-export type { Capability, CapabilityAction, ExtractionToolResponseEnvelope, FlowReconfigureTransition, ToolDeclaration, PromptSection as CapabilityPromptSection, GeminiFunctionDeclaration, ExtractionCapabilityConfig, HandoffTarget, RetrieveProvider, AutoRetrieveCapabilityConfig, RefinementCapability, RefineInput, RefineDecision, ValidationCapability, ValidateInput, ValidateDecision, SourceRef, } from './capabilities/index.js';
+export { CapabilityHost, ExtractionCapability, GuardrailCapability, AutoRetrieveCapability, PassThroughRefinement, PassThroughValidation, toGeminiDeclarations, toAISDKTools, } from './capabilities/index.js';
+export type { Capability, CapabilityAction, ExtractionToolResponseEnvelope, FlowReconfigureTransition, ToolDeclaration, PromptSection as CapabilityPromptSection, GeminiFunctionDeclaration, ExtractionCapabilityConfig, RetrieveProvider, AutoRetrieveCapabilityConfig, RefinementCapability, RefineInput, RefineDecision, ValidationCapability, ValidateInput, ValidateDecision, SourceRef, } from './capabilities/index.js';
 export type { EscalationOutcome, EscalationReason } from './escalation/types.js';
 export { filterAuditEntries } from './audit/index.js';
 export type { AuditConfig, AuditEntryBase, AuditEntryType, AuditListOptions, AuditReplayOptions, ConversationAuditEntry, ConversationAuditLog, } from './audit/types.js';

package/dist/index.js

@@ -36,7 +36,7 @@ export { DEFAULT_CONTEXT_BUDGET, VOICE_CONTEXT_BUDGET, computeMessageHistoryBudg
 export { TokenAccumulator } from './runtime/TokenAccumulator.js';
 export { handoffFilters, removeToolHistory, keepRecentMessages, removeKeys, composeFilters, } from './runtime/handoffFilters.js';
 export { DefaultToolExecutor, DefaultConversationState, DefaultConversationEventLog, DefaultAgentStateController, createFoundation, } from './foundation/index.js';
-export { CapabilityHost, TriageCapability, ExtractionCapability, HandoffCapability, GuardrailCapability, AutoRetrieveCapability, PassThroughRefinement, PassThroughValidation, toGeminiDeclarations, toAISDKTools, } from './capabilities/index.js';
+export { CapabilityHost, ExtractionCapability, GuardrailCapability, AutoRetrieveCapability, PassThroughRefinement, PassThroughValidation, toGeminiDeclarations, toAISDKTools, } from './capabilities/index.js';
 export { filterAuditEntries } from './audit/index.js';
 export { defineAgent, defineFlow, reply, collect, action, decide, confirmGate, } from './authoring/index.js';
 export { defineTool } from './types/effectTool.js';

package/dist/runtime/Runtime.d.ts

@@ -10,7 +10,7 @@ import type { TurnHandle } from '../types/stream.js';
 import type { SignalDelivery } from './durable/types.js';
 import type { ResolvedSelection } from '../types/selection.js';
 import type { ConversationOutcome, ConversationOutcomeMarkedBy } from '../outcomes/types.js';
-import type { selectHostTarget } from './select.js';
+import type { classifyHostTarget, selectHostTarget } from './select.js';
 import type { KnowledgeProviderConfig } from '../types/voice.js';
 import type { MemoryService as V1MemoryService } from '../memory/MemoryService.js';
 import type { PersistentMemoryStore } from '../memory/blocks/types.js';
@@ -23,6 +23,8 @@ export interface HarnessConfig {
     terminalHandoffTargets?: string[];
     hooks?: Hooks;
     voiceMode?: boolean;
+    hostClassify?: typeof classifyHostTarget;
+    /** @deprecated Use hostClassify — test injection adapter for HostSelection stubs. */
     hostSelect?: typeof selectHostTarget;
     tools?: Record<string, AnyTool>;
     knowledge?: KnowledgeProviderConfig;

package/dist/runtime/Runtime.js

@@ -10,6 +10,7 @@ import { wireAgentSkills } from '../skills/wireAgentSkills.js';
 import { hostLoop } from './hostLoop.js';
 import { isDegradableRuntimeError } from '../flow/degradableErrors.js';
 import { SAFE_DEGRADED_MESSAGE } from '../flow/degrade.js';
+import { adaptHostSelect } from './hostClassifyAdapter.js';
 import { openRun } from './openRun.js';
 import { closeRun } from './closeRun.js';
 import { SessionRunStore } from './durable/SessionRunStore.js';
@@ -166,7 +167,8 @@ export class Runtime {
                         run: runCtx.runState,
                         driver,
                         ctx: runCtx,
-                        select: this.config.hostSelect,
+                        classify: this.config.hostClassify ??
+                            (this.config.hostSelect ? adaptHostSelect(this.config.hostSelect) : undefined),
                     });
                     if (loopResult.kind === 'handoff') {
                         if (this.terminalHandoffTargets.has(loopResult.to)) {

package/dist/runtime/agentReply.d.ts

@@ -1,3 +1,4 @@
 import type { AgentConfig } from '../types/agentConfig.js';
 import type { ReplyNode } from '../types/flow.js';
-export declare function buildAgentReplyNode(agent: AgentConfig): ReplyNode;
+import type { RunState } from './durable/types.js';
+export declare function buildAgentReplyNode(agent: AgentConfig, run?: RunState): ReplyNode;

package/dist/runtime/agentReply.js

@@ -1,13 +1,24 @@
 import { buildToolSet } from '../tools/effect/defineTool.js';
-export function buildAgentReplyNode(agent) {
+import { deriveAgentShape } from './deriveAgent.js';
+import { buildHostControlTools } from './hostControlTools.js';
+export function buildAgentReplyNode(agent, run) {
+    const shape = deriveAgentShape(agent);
+    const tools = { ...agent.tools };
+    if (shape.isAnsweringAgent && run) {
+        Object.assign(tools, buildHostControlTools(agent, run));
+    }
     const label = agent.name ?? agent.id;
     const instructions = agent.instructions ??
-        `You are ${label}. Help the user concisely. Do not mention internal routing or flows.`;
+        (shape.isAnsweringAgent
+            ? `You are ${label}. Help the user concisely. Do not mention internal routing or flows. ` +
+                'If the user wants a specialist or a procedure, CALL the control tool (enter_flow or transfer_to_agent) — ' +
+                'do not first say a filler or acknowledgement like "Sure" or "One moment".'
+            : '');
     return {
         kind: 'reply',
         id: `${agent.id}__host`,
         instructions,
-        tools: agent.tools ? buildToolSet(agent.tools) : undefined,
+        tools: Object.keys(tools).length > 0 ? buildToolSet(tools) : undefined,
         model: agent.model,
     };
 }

package/dist/runtime/channels/TextDriver.d.ts

@@ -9,6 +9,7 @@ export interface TextDriverConfig {
     maxSteps?: number;
 }
 export declare class TextDriver implements ChannelDriver {
+    readonly outputCapability: "kuralle-controlled-text";
     private readonly toolDefs;
     private readonly maxSteps;
     constructor(config?: TextDriverConfig);

package/dist/runtime/channels/TextDriver.js

@@ -6,12 +6,13 @@ import { consumePendingUserInput } from './inputBuffer.js';
 import { runSilentExtraction } from './extractionTurn.js';
 import { applyPreTurnPolicies, applyPostTurnPolicies } from '../policies/agentTurn.js';
 import { resolveMaxSteps } from '../policies/limits.js';
-import { speakGated } from './streaming/speakGated.js';
+import { speakWithHostControl } from './streaming/hostControlSpeak.js';
 import { resolveStreamMode } from './streaming/mode.js';
 import { appendGatherBlocks, resolveNodeGatherScope, runGatherPhase } from '../grounding/index.js';
 import { isFlowTransitionControlTool } from '../../flow/flowControlTools.js';
 import { resolveStructuredDecide } from '../../flow/choiceMatch.js';
 export class TextDriver {
+    outputCapability = 'kuralle-controlled-text';
     toolDefs;
     maxSteps;
     constructor(config = {}) {
@@ -108,24 +109,36 @@ export class TextDriver {
                 }
             },
         };
-        const spoken = await speakGated({
-            ctx,
-            mode,
-            turnId,
-            source,
-            runGate: async (text, _final) => {
-                const r = await applyPostTurnPolicies(ctx, text, toolCallsMade, gather.citations ?? []);
-                return {
-                    blocked: !r.proceed,
-                    text: r.proceed ? r.text : (r.blockedMessage ?? r.text),
-                    reason: r.control?.reason,
-                    control: r.control,
-                    confidence: r.confidence,
-                };
-            },
-        });
+        const runGate = async (text, _final) => {
+            const r = await applyPostTurnPolicies(ctx, text, toolCallsMade, gather.citations ?? []);
+            return {
+                blocked: !r.proceed,
+                text: r.proceed ? r.text : (r.blockedMessage ?? r.text),
+                reason: r.control?.reason,
+                control: r.control,
+                confidence: r.confidence,
+            };
+        };
+        const speakFn = node.hostControl
+            ? speakWithHostControl({
+                ctx,
+                mode,
+                turnId,
+                source,
+                runGate,
+                dispatchMode: node.hostControl.dispatchMode,
+                getToolControl: () => out.control,
+            })
+            : (await import('./streaming/speakGated.js')).speakGated({
+                ctx,
+                mode,
+                turnId,
+                source,
+                runGate,
+            });
+        const spoken = await speakFn;
         out.text = spoken.text;
-        out.control = spoken.control;
+        out.control = spoken.control ?? out.control;
         out.confidence = spoken.confidence;
         ctx.emit({ type: 'turn-end' });
         return out;

package/dist/runtime/channels/VoiceDriver.d.ts

@@ -12,6 +12,7 @@ export interface VoiceDriverConfig {
     maxSteps?: number;
 }
 export declare class VoiceDriver implements ChannelDriver {
+    readonly outputCapability: "native-realtime";
     private readonly client;
     private readonly toolDefs;
     private readonly maxSteps;

package/dist/runtime/channels/VoiceDriver.js

@@ -34,6 +34,7 @@ function emitNativeRealtimePostHocGate(ctx, client, gate) {
     client.requestResponse?.(gate.safeText);
 }
 export class VoiceDriver {
+    outputCapability = 'native-realtime';
     client;
     toolDefs;
     maxSteps;
@@ -128,7 +129,10 @@ export class VoiceDriver {
         transcript.close('complete');
         const spoken = await speakPromise;
         out.text = spoken.text;
-        out.control = spoken.control;
+        // Preserve host-control raised during provider tool execution (enter_flow /
+        // transfer_to_agent); the post-hoc gate must not clobber it (else native
+        // realtime silently drops valid routing). Same fix as TextDriver.
+        out.control = spoken.control ?? out.control;
         out.confidence = spoken.confidence;
         if (postHocGate) {
             // Advisory post-hoc gate: provider audio may already have played; correction does not un-speak it.

package/dist/runtime/channels/streaming/hostControlSpeak.d.ts

@@ -0,0 +1,30 @@
+import type { TurnControl } from '../../../types/channel.js';
+import type { RunContext } from '../../../types/run-context.js';
+import { type TokenSource, type GateOutcome } from './speakGated.js';
+import type { StreamMode } from './mode.js';
+/**
+ * Streaming dispatch gate. Its only job is to control EMISSION per dispatch mode
+ * and surface the model's own control tool — it does NOT consult the host guard.
+ * The guard has a single owner (`hostLoop`): when this returns empty text and no
+ * control, `hostLoop` runs the guard exactly once. Keeping the guard out of here
+ * avoids double-evaluation and keeps guard telemetry attributable.
+ *
+ * - relaxed: stream live; if the model's own control tool fires, cancel any
+ *   streamed text and return that control.
+ * - strict: emit NOTHING until the model's intent is known — buffer until the
+ *   first substantive token (answering → flush + stream the rest live) or source
+ *   end (no answer → return empty; `hostLoop` then guards with no leak).
+ */
+export declare function speakWithHostControl(args: {
+    ctx: RunContext;
+    mode: StreamMode;
+    turnId: string;
+    source: TokenSource;
+    runGate: (fullOrSentence: string, final: boolean) => Promise<GateOutcome>;
+    dispatchMode: 'strict' | 'relaxed';
+    getToolControl: () => TurnControl | undefined;
+}): Promise<{
+    text: string;
+    control?: TurnControl;
+    confidence?: number;
+}>;

package/dist/runtime/channels/streaming/hostControlSpeak.js

@@ -0,0 +1,80 @@
+import { speakGated } from './speakGated.js';
+/**
+ * Streaming dispatch gate. Its only job is to control EMISSION per dispatch mode
+ * and surface the model's own control tool — it does NOT consult the host guard.
+ * The guard has a single owner (`hostLoop`): when this returns empty text and no
+ * control, `hostLoop` runs the guard exactly once. Keeping the guard out of here
+ * avoids double-evaluation and keeps guard telemetry attributable.
+ *
+ * - relaxed: stream live; if the model's own control tool fires, cancel any
+ *   streamed text and return that control.
+ * - strict: emit NOTHING until the model's intent is known — buffer until the
+ *   first substantive token (answering → flush + stream the rest live) or source
+ *   end (no answer → return empty; `hostLoop` then guards with no leak).
+ */
+export async function speakWithHostControl(args) {
+    const { ctx, mode, turnId, source, runGate, dispatchMode, getToolControl } = args;
+    if (dispatchMode === 'strict') {
+        const it = source[Symbol.asyncIterator]();
+        const buffered = [];
+        let answered = false;
+        while (!getToolControl()) {
+            const r = await it.next();
+            if (r.done) {
+                break;
+            }
+            buffered.push(r.value);
+            if (r.value.delta.trim().length > 0) {
+                answered = true;
+                break;
+            }
+        }
+        const toolControl = getToolControl();
+        if (toolControl) {
+            return { text: '', control: toolControl };
+        }
+        // No substantive text → emit nothing; hostLoop owns the empty-turn guard.
+        if (!answered) {
+            return { text: '', control: undefined };
+        }
+        // Answering: flush the buffered prefix, then stream the remainder live.
+        const flushSource = {
+            async *[Symbol.asyncIterator]() {
+                for (const chunk of buffered) {
+                    yield chunk;
+                }
+                let cur = await it.next();
+                while (!cur.done) {
+                    if (getToolControl()) {
+                        return;
+                    }
+                    yield cur.value;
+                    cur = await it.next();
+                }
+            },
+        };
+        return speakGated({ ctx, mode, turnId, source: flushSource, runGate });
+    }
+    // Relaxed: stream live; stop if the model's own control tool fires.
+    let toolControl;
+    const wrappedSource = {
+        async *[Symbol.asyncIterator]() {
+            for await (const chunk of source) {
+                toolControl = getToolControl();
+                if (toolControl) {
+                    return;
+                }
+                yield chunk;
+            }
+        },
+    };
+    const spoken = await speakGated({ ctx, mode, turnId, source: wrappedSource, runGate });
+    toolControl = getToolControl();
+    if (toolControl) {
+        if (spoken.text) {
+            ctx.emit({ type: 'text-cancel', id: turnId, reason: 'host-control' });
+        }
+        return { text: '', control: toolControl };
+    }
+    return spoken;
+}

package/dist/runtime/deriveAgent.d.ts

@@ -6,5 +6,14 @@ export interface DerivedAgentCapabilities {
     hasHandoffs: boolean;
     precedence: 'routes' | 'flows' | 'free';
 }
+export interface AgentShape {
+    hasDispatchTargets: boolean;
+    hasLocalProcedure: boolean;
+    hasLocalAnsweringSurface: boolean;
+    isAnsweringAgent: boolean;
+    isPureDispatcher: boolean;
+}
+export declare function hasLocalAnsweringSurface(agent: AgentConfig): boolean;
+export declare function hasDispatchTargets(agent: AgentConfig): boolean;
+export declare function deriveAgentShape(agent: AgentConfig): AgentShape;
 export declare function deriveAgentCapabilities(agent: AgentConfig): DerivedAgentCapabilities;
-export declare function shouldRunHostSelector(agent: AgentConfig, activeFlow?: string, alwaysRoute?: boolean): boolean;

package/dist/runtime/deriveAgent.js

@@ -1,8 +1,68 @@
+function hasPopulatedInstructions(instructions) {
+    if (instructions === undefined) {
+        return false;
+    }
+    if (typeof instructions === 'string') {
+        return instructions.trim().length > 0;
+    }
+    return true;
+}
+export function hasLocalAnsweringSurface(agent) {
+    if (hasPopulatedInstructions(agent.instructions)) {
+        return true;
+    }
+    if (agent.tools && Object.keys(agent.tools).length > 0) {
+        return true;
+    }
+    if (agent.globalTools && Object.keys(agent.globalTools).length > 0) {
+        return true;
+    }
+    if (agent.knowledge) {
+        return true;
+    }
+    if (agent.memory) {
+        return true;
+    }
+    if (agent.skills) {
+        return true;
+    }
+    if (agent.workspace) {
+        return true;
+    }
+    return false;
+}
+export function hasDispatchTargets(agent) {
+    const routes = agent.routes ?? [];
+    if (routes.some((route) => route.agent || route.flow)) {
+        return true;
+    }
+    if ((agent.agents?.length ?? 0) > 0) {
+        return true;
+    }
+    if ((agent.handoffs?.length ?? 0) > 0) {
+        return true;
+    }
+    return false;
+}
+export function deriveAgentShape(agent) {
+    const hasLocalProcedure = (agent.flows?.length ?? 0) > 0;
+    const answeringSurface = hasLocalAnsweringSurface(agent);
+    const dispatchTargets = hasDispatchTargets(agent);
+    const isAnsweringAgent = hasLocalProcedure || answeringSurface;
+    const isPureDispatcher = dispatchTargets && !isAnsweringAgent;
+    return {
+        hasDispatchTargets: dispatchTargets,
+        hasLocalProcedure,
+        hasLocalAnsweringSurface: answeringSurface,
+        isAnsweringAgent,
+        isPureDispatcher,
+    };
+}
 export function deriveAgentCapabilities(agent) {
+    const shape = deriveAgentShape(agent);
     const hasRoutes = (agent.routes?.length ?? 0) > 0;
-    const hasFlows = (agent.flows?.length ?? 0) > 0;
+    const hasFlows = shape.hasLocalProcedure;
     const hasHandoffs = (agent.agents?.length ?? 0) > 0 || (agent.handoffs?.length ?? 0) > 0;
-    const hasFreeConversation = true;
     const precedence = hasRoutes
         ? 'routes'
         : hasFlows
@@ -11,18 +71,8 @@ export function deriveAgentCapabilities(agent) {
     return {
         hasRoutes,
         hasFlows,
-        hasFreeConversation,
+        hasFreeConversation: shape.isAnsweringAgent,
         hasHandoffs,
         precedence,
     };
 }
-export function shouldRunHostSelector(agent, activeFlow, alwaysRoute) {
-    if (activeFlow) {
-        return false;
-    }
-    if (alwaysRoute) {
-        return true;
-    }
-    const { hasRoutes, hasFlows } = deriveAgentCapabilities(agent);
-    return hasRoutes || hasFlows;
-}

package/dist/runtime/dispatchMode.d.ts

@@ -0,0 +1,5 @@
+import type { AgentConfig } from '../types/agentConfig.js';
+import type { DriverOutputCapability } from '../types/channel.js';
+export type DispatchMode = 'strict' | 'relaxed';
+export declare function resolveDispatchMode(agent: AgentConfig, capability: DriverOutputCapability): DispatchMode;
+export declare function isAdvisoryDispatch(capability: DriverOutputCapability): boolean;

package/dist/runtime/dispatchMode.js

@@ -0,0 +1,18 @@
+export function resolveDispatchMode(agent, capability) {
+    if (agent.routing?.dispatch === 'strict') {
+        return 'strict';
+    }
+    switch (capability) {
+        case 'kuralle-controlled-text':
+            return 'relaxed';
+        case 'kuralle-controlled-tts':
+            return 'strict';
+        case 'native-realtime':
+            return 'strict';
+        default:
+            return 'relaxed';
+    }
+}
+export function isAdvisoryDispatch(capability) {
+    return capability === 'native-realtime';
+}

package/dist/runtime/hostClassifyAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { classifyHostTarget } from './select.js';
+export declare function adaptHostSelect(select: typeof import('./select.js').selectHostTarget): typeof classifyHostTarget;

package/dist/runtime/hostClassifyAdapter.js

@@ -0,0 +1,21 @@
+export function adaptHostSelect(select) {
+    return async (options) => {
+        const selection = await select({
+            agent: options.agent,
+            run: options.run,
+            model: options.model,
+            excludeFlowNames: options.excludeFlowNames,
+        });
+        if (selection.kind === 'keep') {
+            return { action: 'keep', confidence: 1 };
+        }
+        if (selection.kind === 'enterFlow') {
+            return { action: 'enterFlow', flowName: selection.flow.name };
+        }
+        return {
+            action: 'transfer',
+            targetAgentId: selection.agentId,
+            reason: selection.reason,
+        };
+    };
+}

package/dist/runtime/hostControlGuard.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModel } from 'ai';
+import type { AgentConfig } from '../types/agentConfig.js';
+import type { TurnControl } from '../types/channel.js';
+import type { RunState } from './durable/types.js';
+import { type HostGuardVerdict, type ClassifyHostOptions } from './select.js';
+export type { HostGuardVerdict };
+export declare function startHostControlGuard(options: {
+    agent: AgentConfig;
+    run: RunState;
+    model: LanguageModel;
+    classify?: (opts: ClassifyHostOptions) => Promise<HostGuardVerdict>;
+}): Promise<HostGuardVerdict>;
+export declare function isValidControl(control: TurnControl, agent: AgentConfig, run: RunState): boolean;
+export declare function isValidGuardVerdict(verdict: HostGuardVerdict, agent: AgentConfig, run: RunState): boolean;
+export declare function guardVerdictToControl(verdict: HostGuardVerdict): TurnControl | undefined;
+/**
+ * Main model control wins when valid. The guard is a forgot-to-route net, NOT a
+ * second-guesser: it only overrides when the answering model produced neither a
+ * control tool NOR a substantive answer (`mainAnswered`). If the model answered,
+ * the answer stands — a guard verdict must not hijack a correct keep answer
+ * (which caused observed mis-routes of Q&A turns into flows).
+ */
+export declare function resolveHostControl(mainControl: TurnControl | undefined, guardVerdict: HostGuardVerdict | undefined, agent: AgentConfig, run: RunState, mainAnswered: boolean): TurnControl | undefined;