@ariaflowagents/core 0.8.1 → 0.9.0

package/dist/orchestration/DefaultOrchestrationAuthority.js

@@ -0,0 +1,786 @@
+import crypto from 'node:crypto';
+import { isExtractionNode } from '../types/index.js';
+import { CapabilityHost, FlowCapability, ExtractionCapability, HandoffCapability, toGeminiDeclarations, DefaultLivePromptAssembler } from '../capabilities/index.js';
+import { HookRunner } from '../hooks/HookRunner.js';
+import { ToolEnforcer } from '../guards/ToolEnforcer.js';
+import { defaultEnforcementRules } from '../guards/rules.js';
+import { DefaultToolExecutor } from '../foundation/DefaultToolExecutor.js';
+import { DefaultConversationState } from '../foundation/DefaultConversationState.js';
+import { DefaultConversationEventLog } from '../foundation/DefaultConversationEventLog.js';
+import { DefaultAgentStateController } from '../foundation/DefaultAgentStateController.js';
+import { ExtractionEngine } from '../runtime/ExtractionEngine.js';
+import { RealtimeExtractionRunner } from './RealtimeExtractionRunner.js';
+import { MemoryStore } from '../session/stores/MemoryStore.js';
+// ─── DefaultOrchestrationAuthority ──────────────────────────────────────────
+/**
+ * Default implementation of the OrchestrationAuthority port.
+ *
+ * Composes Foundation services, HookRunner, CapabilityHost, LivePromptAssembler,
+ * ExtractionEngine, and MemoryService into the transport-agnostic orchestration
+ * sequence defined in RFC-REALTIME-RUNTIME-AUTHORITY.md.
+ *
+ * This is the "single brain" that both text Runtime and RealtimeRuntime
+ * delegate to for conversational semantics.
+ */
+export class DefaultOrchestrationAuthority {
+    agents;
+    defaultAgentId;
+    hookRunner;
+    toolExecutor;
+    conversationState;
+    eventLog;
+    agentState;
+    extractionEngine;
+    promptAssembler;
+    memoryService;
+    memoryIngestion;
+    maxPersistRetries;
+    realtimeExtractionRunner;
+    autoRetrieveProvider;
+    constructor(config) {
+        // Build agent registry
+        this.agents = new Map();
+        for (const agent of config.agents) {
+            this.agents.set(agent.id, agent);
+        }
+        this.defaultAgentId = config.defaultAgentId;
+        const injected = config.injectedServices;
+        // Hook infrastructure — use injected HookRunner (shared with Runtime)
+        // or create a new one. This is the critical fix for deviation D1:
+        // VoiceEngine previously had no access to HookRunner.
+        this.hookRunner = injected?.hookRunner ?? new HookRunner(config.hooks);
+        // Foundation services — use injected instances (shared with Runtime)
+        // or construct new ones from config.
+        if (injected?.toolExecutor) {
+            this.toolExecutor = injected.toolExecutor;
+        }
+        else {
+            const sessionStore = config.sessionStore ?? new MemoryStore();
+            const enforcer = new ToolEnforcer(config.enforcementRules ?? defaultEnforcementRules);
+            this.toolExecutor = new DefaultToolExecutor({
+                enforcer,
+                hookRunner: this.hookRunner,
+                memoryService: config.memoryService,
+            });
+        }
+        if (injected?.conversationState) {
+            this.conversationState = injected.conversationState;
+        }
+        else {
+            const sessionStore = config.sessionStore ?? new MemoryStore();
+            this.conversationState = new DefaultConversationState({
+                sessionStore,
+                defaultAgentId: config.defaultAgentId,
+            });
+        }
+        this.eventLog = injected?.eventLog ?? new DefaultConversationEventLog({
+            sessionStore: config.sessionStore ?? new MemoryStore(),
+        });
+        this.agentState = injected?.agentState ?? new DefaultAgentStateController();
+        // Extraction engine — fixes deviation D3 (no extraction in voice path)
+        this.extractionEngine = new ExtractionEngine({
+            defaultModel: config.defaultModel,
+            telemetry: config.telemetry,
+        });
+        this.realtimeExtractionRunner = config.extractionModel
+            ? new RealtimeExtractionRunner({
+                model: config.extractionModel,
+                telemetry: config.telemetry,
+            })
+            : undefined;
+        // Prompt assembler for realtime session config
+        this.promptAssembler = new DefaultLivePromptAssembler();
+        // Memory — fixes deviation D4 (no memory ingestion in voice path)
+        this.memoryService = config.memoryService;
+        this.memoryIngestion = config.memoryIngestion ?? 'manual';
+        // Persistence policy
+        this.maxPersistRetries = config.maxPersistRetries ?? 3;
+        this.autoRetrieveProvider = config.autoRetrieveProvider;
+    }
+    // ─── Public API ─────────────────────────────────────────────────────────────
+    async openSession(params) {
+        const agentId = params.agentId ?? this.defaultAgentId;
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`[OrchestrationAuthority] Agent "${agentId}" not found`);
+        }
+        // Load or create session
+        const sessionId = params.sessionId ?? crypto.randomUUID();
+        const session = await this.conversationState.load(sessionId, params.userId);
+        // Set active agent and bump turn
+        this.agentState.setActiveAgent(session, agentId);
+        this.conversationState.bumpSessionTurn(session);
+        // Build RunContext
+        const context = {
+            session,
+            agentId,
+            stepCount: 0,
+            totalTokens: 0,
+            handoffStack: [],
+            startTime: Date.now(),
+            consecutiveErrors: 0,
+            toolCallHistory: [],
+        };
+        // Build CapabilityHost for this agent
+        const { host, flowCapability } = this.buildCapabilityHost(agent, session);
+        const basePrompt = resolveAgentPrompt(agent);
+        // Fire lifecycle hooks — fixes deviation D1 for realtime
+        await this.hookRunner.onStart(context);
+        await this.hookRunner.onAgentStart(context, agentId);
+        const handle = {
+            session,
+            context,
+            activeAgentId: agentId,
+            _internals: { host, flowCapability, mode: params.mode, basePrompt, agent },
+        };
+        this.syncFlowStateToSession(handle);
+        return handle;
+    }
+    async recordUserInput(handle, text) {
+        this.conversationState.appendUserMessage(handle.session, text);
+        this.getInternals(handle).flowCapability?.appendUserMessage(text);
+        this.syncFlowStateToSession(handle);
+    }
+    async recordAssistantOutput(handle, text) {
+        this.conversationState.appendAssistantMessage(handle.session, text);
+        this.getInternals(handle).flowCapability?.appendAssistantMessage(text);
+        this.syncFlowStateToSession(handle);
+    }
+    async prepareRealtimeConfig(handle) {
+        const internals = this.getInternals(handle);
+        const systemInstruction = await this.promptAssembler.assemble({
+            host: internals.host,
+            basePrompt: internals.basePrompt,
+            session: handle.session,
+            memoryService: this.memoryService,
+        });
+        const tools = toGeminiDeclarations(internals.host.getAllTools());
+        internals.host.markConfigured();
+        return {
+            systemInstruction,
+            tools,
+        };
+    }
+    async executeToolCall(handle, call) {
+        const internals = this.getInternals(handle);
+        const { host, agent } = internals;
+        const { session, context } = handle;
+        const effectiveArgs = await this.resolveToolArgs(handle, call.name, call.args);
+        // 1. Resolve the tool from CapabilityHost (includes capability + regular tools)
+        const allTools = host.getAllTools();
+        const tool = allTools.find((t) => t.name === call.name);
+        if (!tool) {
+            // Unknown tool — return error response, fire hook, continue
+            const errorOutput = { error: `Unknown tool: ${call.name}` };
+            const record = this.buildToolCallRecord(call.id, call.name, effectiveArgs, errorOutput, false);
+            context.toolCallHistory.push(record);
+            await this.hookRunner.onToolError(context, record, new Error(`Unknown tool: ${call.name}`));
+            return {
+                action: { type: 'continue' },
+                toolResponse: { id: call.id, name: call.name, output: errorOutput },
+            };
+        }
+        // 2. Record tool call event
+        this.eventLog.record(context, {
+            type: 'tool-call',
+            toolCallId: call.id,
+            toolName: call.name,
+            args: effectiveArgs,
+        });
+        // 3. Execute the tool
+        let result;
+        try {
+            const isCapabilityTool = this.isCapabilityTool(call.name, tool, agent);
+            if (isCapabilityTool) {
+                // Capability tools (flow transitions, extraction) have self-contained execute()
+                result = await tool.execute(effectiveArgs);
+            }
+            else {
+                // Regular agent tools go through ToolExecutor for enforcement + guards
+                result = await this.toolExecutor.execute({
+                    session,
+                    userId: session.userId,
+                    agentId: context.agentId,
+                    toolName: call.name,
+                    tool: { execute: tool.execute, description: tool.description },
+                    input: effectiveArgs,
+                    toolCallId: call.id,
+                    toolCallHistory: context.toolCallHistory,
+                });
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            // Record error
+            this.eventLog.record(context, {
+                type: 'tool-error',
+                toolCallId: call.id,
+                toolName: call.name,
+                error: errorMsg,
+            });
+            const record = this.buildToolCallRecord(call.id, call.name, effectiveArgs, undefined, false, error);
+            context.toolCallHistory.push(record);
+            await this.hookRunner.onToolError(context, record, error);
+            return {
+                action: { type: 'continue' },
+                toolResponse: { id: call.id, name: call.name, output: { error: errorMsg } },
+            };
+        }
+        // 4. Record successful result
+        this.eventLog.record(context, {
+            type: 'tool-result',
+            toolCallId: call.id,
+            toolName: call.name,
+            result,
+        });
+        const record = this.buildToolCallRecord(call.id, call.name, effectiveArgs, result, true);
+        context.toolCallHistory.push(record);
+        // 5. Fire onToolResult hook — fixes deviation D1
+        await this.hookRunner.onToolResult(context, record);
+        // 6. Route through CapabilityHost to determine semantic action
+        const action = host.processToolResult(call.name, effectiveArgs, result);
+        this.syncFlowStateToSession(handle);
+        // 7. Persist session (fire-and-forget in hot path) — fixes deviation D2 partially
+        this.conversationState.save(session).catch((err) => {
+            console.error('[OrchestrationAuthority] Background save failed:', err);
+        });
+        // 8. Build outcome based on action type
+        return this.buildOutcome(handle, call, result, action);
+    }
+    async completeTurn(handle) {
+        const { context, session } = handle;
+        const internals = this.getInternals(handle);
+        // 1. Post-turn extraction — fixes deviation D3
+        await this.runExtraction(internals.agent, context);
+        // 1b. Optional realtime extraction refinement for active extraction nodes
+        if (internals.mode === 'realtime') {
+            await this.runRealtimeExtractionRefinement(handle);
+        }
+        // 1c. Realtime knowledge + memory preload into working memory (before persist)
+        if (internals.mode === 'realtime') {
+            await this.runRealtimeKnowledgeRefresh(handle);
+        }
+        // 2. Persist session with retry — fixes deviation D2
+        await this.persistWithRetry(session);
+        // 3. Memory ingestion — fixes deviation D4
+        await this.runMemoryIngestion(context, session);
+    }
+    async closeSession(handle, result) {
+        const { context, session } = handle;
+        // Fire lifecycle hooks — fixes deviation D7
+        await this.hookRunner.onAgentEnd(context, context.agentId);
+        await this.hookRunner.onEnd(context, result ?? { success: true });
+        // Clean up transient state
+        this.eventLog.cleanup(session);
+        // Final persistence with retry
+        await this.persistWithRetry(session);
+        await this.hookRunner.onSessionEnd(session, this.buildSessionEndMetadata(session, result ?? { success: true }));
+    }
+    async failSession(handle, error) {
+        const { context, session } = handle;
+        // Fire error hooks — fixes deviation D7
+        await this.hookRunner.onError(context, error);
+        await this.hookRunner.onEnd(context, { success: false, error });
+        // Clean up and emergency persist
+        this.eventLog.cleanup(session);
+        await this.conversationState.save(session).catch((err) => {
+            console.error('[OrchestrationAuthority] Emergency save failed:', err);
+        });
+        await this.hookRunner.onSessionEnd(session, this.buildSessionEndMetadata(session, { success: false, error }));
+    }
+    // ─── Accessors for facades ──────────────────────────────────────────────────
+    /** Expose foundation services for facades that need direct access. */
+    get foundation() {
+        return {
+            toolExecutor: this.toolExecutor,
+            conversationState: this.conversationState,
+            eventLog: this.eventLog,
+            agentState: this.agentState,
+        };
+    }
+    /** Expose hook runner for facades that need to fire transport-specific hooks. */
+    get hooks() {
+        return this.hookRunner;
+    }
+    // ─── Private: CapabilityHost construction ─────────────────────────────────
+    /**
+     * Build a CapabilityHost from agent config.
+     * Mirrors the logic in CapabilityCallWorker.buildHost() and
+     * AgentExecuteStage's host construction, unified into one place.
+     */
+    buildCapabilityHost(agent, session) {
+        const host = new CapabilityHost();
+        let flowCapability;
+        // Flow capability — for flow agents with node graphs
+        if (isFlowAgent(agent) && agent.flow) {
+            const initialNode = agent.initialNode ?? agent.flow.nodes[0]?.id;
+            if (initialNode) {
+                flowCapability = new FlowCapability({
+                    flow: agent.flow,
+                    initialNode,
+                    state: this.readPersistedFlowState(session, agent.id),
+                });
+                if (!flowCapability.isInitialized) {
+                    flowCapability.initialize();
+                }
+                host.use(flowCapability);
+            }
+        }
+        // Handoff capability — for agents with canHandoffTo
+        if (agent.canHandoffTo?.length) {
+            const targets = agent.canHandoffTo
+                .map(id => this.agents.get(id))
+                .filter((a) => Boolean(a))
+                .map(a => ({ id: a.id, name: a.name ?? a.id, description: a.description }));
+            if (targets.length > 0) {
+                host.use(new HandoffCapability(targets));
+            }
+        }
+        // Extraction capability (pure capability-based, not ExtractionEngine-based)
+        if (agent.extraction) {
+            const ex = agent.extraction;
+            const usesExtractionEngine = !!(ex.systemPrompt || ex.memoryKey || ex.includeInSystemPrompt !== undefined);
+            if (!usesExtractionEngine) {
+                host.use(new ExtractionCapability({
+                    schema: ex.schema,
+                    requiredFields: ex.requiredFields,
+                }));
+            }
+        }
+        // Agent's own tools — convert to ToolDeclarations for the host
+        if (agent.tools) {
+            const toolDecls = Object.entries(agent.tools).map(([name, tool]) => ({
+                name,
+                description: tool.description ?? '',
+                parameters: (tool.inputSchema ?? tool.parameters),
+                execute: tool.execute,
+            }));
+            host.addTools(toolDecls);
+        }
+        return { host, flowCapability };
+    }
+    // ─── Private: Outcome construction ────────────────────────────────────────
+    async buildOutcome(handle, call, result, action) {
+        const outputForModel = action.type === 'continue' && action.toolResponseOverride !== undefined
+            ? action.toolResponseOverride
+            : result;
+        const toolResponse = { id: call.id, name: call.name, output: outputForModel };
+        const base = { action, toolResponse };
+        switch (action.type) {
+            case 'reconfigure': {
+                // Flow transitioned — rebuild prompt and tools
+                const internals = this.getInternals(handle);
+                const systemInstruction = await this.promptAssembler.assemble({
+                    host: internals.host,
+                    basePrompt: internals.basePrompt,
+                    session: handle.session,
+                    memoryService: this.memoryService,
+                });
+                const tools = internals.host.getAllTools();
+                const geminiTools = toGeminiDeclarations(tools);
+                internals.host.markConfigured();
+                base.nextSystemPrompt = systemInstruction;
+                base.nextTools = tools;
+                base.nextRealtimeConfig = { systemInstruction, tools: geminiTools };
+                return base;
+            }
+            case 'handoff': {
+                // Fire handoff hook
+                const reason = action.reason ?? `Handoff to ${action.targetAgent}`;
+                await this.hookRunner.onHandoff(handle.context, handle.context.agentId, action.targetAgent, reason);
+                return base;
+            }
+            case 'end': {
+                // Fire agent-end hook
+                await this.hookRunner.onAgentEnd(handle.context, handle.context.agentId);
+                return base;
+            }
+            case 'continue':
+            case 'extraction-complete':
+            default:
+                return base;
+        }
+    }
+    // ─── Private: Extraction ──────────────────────────────────────────────────
+    async runExtraction(agent, context) {
+        // Only run if agent has extraction config and ExtractionEngine is available
+        const extractionConfig = this.extractionEngine.getExtractionConfig(agent, context.session, {
+            getFlowState: (session, agentId) => {
+                const raw = session.agentStates[agentId]?.state;
+                if (!raw || typeof raw !== 'object')
+                    return undefined;
+                return raw;
+            },
+            getFlowNode: (flowAgent, nodeId) => {
+                if (!nodeId)
+                    return undefined;
+                return flowAgent.flow.nodes.find(n => n.id === nodeId);
+            },
+            isFlowAgent,
+        });
+        if (!extractionConfig)
+            return;
+        // Get the last user input for extraction
+        const lastUserInput = this.getLastUserInput(context.session);
+        if (!lastUserInput)
+            return;
+        await this.extractionEngine.runTurnExtraction(agent, context, lastUserInput, {
+            getFlowState: (session, agentId) => {
+                const raw = session.agentStates[agentId]?.state;
+                if (!raw || typeof raw !== 'object')
+                    return undefined;
+                return raw;
+            },
+            setFlowState: (session, agentId, state) => {
+                if (!session.agentStates[agentId]) {
+                    session.agentStates[agentId] = { agentId, state: {}, lastActive: new Date() };
+                }
+                session.agentStates[agentId].state = state;
+            },
+            getFlowNode: (flowAgent, nodeId) => {
+                if (!nodeId)
+                    return undefined;
+                return flowAgent.flow.nodes.find(n => n.id === nodeId);
+            },
+            isFlowAgent,
+            touchSession: (session) => this.conversationState.touchSession(session),
+        });
+    }
+    async runRealtimeKnowledgeRefresh(handle) {
+        const transcript = this.getLastUserInput(handle.session);
+        if (!transcript || transcript.length < 3)
+            return;
+        if (this.autoRetrieveProvider) {
+            try {
+                const result = await this.autoRetrieveProvider.run({
+                    input: transcript,
+                    context: handle.context,
+                });
+                if (result?.text) {
+                    handle.session.workingMemory['knowledge:realtime'] = {
+                        text: result.text.slice(0, 4000),
+                        query: transcript,
+                        retrievedAt: Date.now(),
+                    };
+                }
+            }
+            catch (err) {
+                console.error('[OrchestrationAuthority] Knowledge refresh failed:', err);
+            }
+        }
+        if (this.memoryService && handle.session.userId) {
+            try {
+                const { memories } = await this.memoryService.searchMemory({
+                    userId: handle.session.userId,
+                    query: transcript,
+                    limit: 10,
+                });
+                if (memories.length > 0) {
+                    handle.session.workingMemory['memory:realtime'] = {
+                        memories: memories.slice(0, 5),
+                        retrievedAt: Date.now(),
+                    };
+                }
+            }
+            catch (err) {
+                console.error('[OrchestrationAuthority] Memory preload failed:', err);
+            }
+        }
+    }
+    async runRealtimeExtractionRefinement(handle) {
+        if (!this.realtimeExtractionRunner)
+            return;
+        const internals = this.getInternals(handle);
+        const { flowCapability, agent } = internals;
+        if (!flowCapability || !isFlowAgent(agent))
+            return;
+        const node = flowCapability.currentExtractionNode();
+        if (!node)
+            return;
+        const transcript = this.buildExtractionTranscript(handle.session);
+        if (!transcript)
+            return;
+        const result = await this.realtimeExtractionRunner.runPostTurnExtraction({
+            schema: node.extractionSchema,
+            requiredFields: this.getRequiredExtractionFields(node),
+            userTranscript: transcript,
+            currentCollectedData: flowCapability.collectedData,
+            telemetry: agent.telemetry,
+        });
+        flowCapability.updateCollectedData(result.extractedFields);
+        this.syncFlowStateToSession(handle);
+    }
+    // ─── Private: Memory ingestion ────────────────────────────────────────────
+    async runMemoryIngestion(context, session) {
+        if (!this.memoryService)
+            return;
+        if (!session.userId)
+            return;
+        if (this.memoryIngestion === 'onEnd') {
+            // Automatic ingestion
+            try {
+                await this.memoryService.addSessionToMemory(session);
+            }
+            catch (err) {
+                console.error('[OrchestrationAuthority] Memory ingestion failed:', err);
+            }
+        }
+        else if (this.memoryIngestion === 'hook') {
+            // Hook-controlled ingestion — the onMemoryIngest hook can signal skip
+            // by returning false. HookRunner.run() doesn't return the hook value,
+            // so we call the hook directly for this special case.
+            let shouldIngest = true;
+            const hooks = this.hookRunner.getHooks();
+            if (hooks.onMemoryIngest) {
+                const result = await hooks.onMemoryIngest(context, session);
+                if (result === false)
+                    shouldIngest = false;
+            }
+            if (shouldIngest) {
+                try {
+                    await this.memoryService.addSessionToMemory(session);
+                    if (hooks.onMemoryIngested) {
+                        await hooks.onMemoryIngested(context, session);
+                    }
+                }
+                catch (err) {
+                    console.error('[OrchestrationAuthority] Memory ingestion failed:', err);
+                }
+            }
+        }
+        // 'manual' — no automatic ingestion
+    }
+    // ─── Private: Persistence ─────────────────────────────────────────────────
+    async persistWithRetry(session) {
+        for (let attempt = 1; attempt <= this.maxPersistRetries; attempt++) {
+            try {
+                await this.conversationState.save(session);
+                return;
+            }
+            catch (error) {
+                if (attempt === this.maxPersistRetries) {
+                    // Fire persistence error hook if available
+                    await this.hookRunner.run('onPersistenceError', session, error);
+                    console.error('[OrchestrationAuthority] Persistence failed after retries:', error);
+                    return;
+                }
+                // Exponential backoff
+                await new Promise(r => setTimeout(r, 100 * Math.pow(2, attempt)));
+            }
+        }
+    }
+    // ─── Private: Helpers ─────────────────────────────────────────────────────
+    buildSessionEndMetadata(session, result) {
+        const now = Date.now();
+        const durationMs = now - session.createdAt.getTime();
+        return {
+            success: result?.success ?? true,
+            endReason: result?.error?.message,
+            durationMs,
+            turnCount: session.metadata?.totalSteps,
+            lastAgentId: session.activeAgentId ?? session.currentAgent,
+        };
+    }
+    getInternals(handle) {
+        return handle._internals;
+    }
+    readPersistedFlowState(session, agentId) {
+        const raw = session?.agentStates[agentId]?.state;
+        if (!raw || typeof raw !== 'object')
+            return undefined;
+        const candidate = raw;
+        if (typeof candidate.context !== 'object' || candidate.context === null)
+            return undefined;
+        return {
+            context: candidate.context,
+            initialized: candidate.initialized === true,
+            flowEnded: candidate.flowEnded === true,
+        };
+    }
+    syncFlowStateToSession(handle) {
+        const { flowCapability } = this.getInternals(handle);
+        if (!flowCapability)
+            return;
+        this.agentState.updateAgentState(handle.session, handle.context.agentId, flowCapability.getState());
+        this.conversationState.touchSession(handle.session);
+    }
+    async resolveToolArgs(handle, toolName, args) {
+        const verified = await this.verifyExtractionSubmission(handle, toolName, args);
+        return verified ?? args;
+    }
+    async verifyExtractionSubmission(handle, toolName, args) {
+        const internals = this.getInternals(handle);
+        const flowCapability = internals.flowCapability;
+        if (!flowCapability || !isFlowAgent(internals.agent))
+            return null;
+        const currentNodeId = flowCapability.currentNode;
+        if (!currentNodeId)
+            return null;
+        const node = internals.agent.flow.nodes.find((entry) => entry.id === currentNodeId);
+        if (!node || !isExtractionNode(node))
+            return null;
+        if (toolName !== `submit_${node.id}_data`)
+            return null;
+        const transcript = this.buildExtractionTranscript(handle.session);
+        if (!transcript)
+            return {};
+        if (this.realtimeExtractionRunner) {
+            const result = await this.realtimeExtractionRunner.runPostTurnExtraction({
+                schema: node.extractionSchema,
+                requiredFields: this.getRequiredExtractionFields(node),
+                userTranscript: transcript,
+                currentCollectedData: {},
+                telemetry: internals.agent.telemetry,
+            });
+            if (Object.keys(result.extractedFields).length > 0) {
+                return result.extractedFields;
+            }
+        }
+        return this.filterExtractionArgsAgainstTranscript(args, transcript);
+    }
+    buildExtractionTranscript(session) {
+        const recentUserMessages = session.messages
+            .filter((msg) => msg.role === 'user')
+            .slice(-6)
+            .map((msg) => this.getMessageText(msg.content))
+            .filter((text) => typeof text === 'string' && text.trim().length > 0);
+        return recentUserMessages.join('\n');
+    }
+    getMessageText(content) {
+        if (typeof content === 'string')
+            return content;
+        if (!Array.isArray(content))
+            return null;
+        const text = content
+            .filter((part) => typeof part === 'object' && part !== null && 'type' in part)
+            .filter((part) => part.type === 'text' && typeof part.text === 'string')
+            .map((part) => part.text ?? '')
+            .join(' ')
+            .trim();
+        return text.length > 0 ? text : null;
+    }
+    toRecord(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return {};
+        }
+        return value;
+    }
+    getRequiredExtractionFields(node) {
+        const requiredFields = node.extractionRequiredFields;
+        if (requiredFields && requiredFields.length > 0) {
+            return requiredFields;
+        }
+        const schema = node.extractionSchema;
+        return Object.keys(schema.shape ?? {});
+    }
+    filterExtractionArgsAgainstTranscript(args, transcript) {
+        const submitted = this.toRecord(args);
+        const accepted = {};
+        const normalizedTranscript = normalizeExtractionText(transcript);
+        for (const [key, value] of Object.entries(submitted)) {
+            if (typeof value === 'string') {
+                const normalizedValue = normalizeExtractionText(value);
+                if (!normalizedValue)
+                    continue;
+                if (isSuspiciousExtractionPlaceholder(normalizedValue))
+                    continue;
+                if (normalizedTranscript.includes(normalizedValue)
+                    || normalizedValue.includes(normalizedTranscript)) {
+                    accepted[key] = value;
+                }
+                continue;
+            }
+            if (typeof value === 'number' || typeof value === 'boolean') {
+                const normalizedValue = normalizeExtractionText(String(value));
+                if (normalizedTranscript.includes(normalizedValue)) {
+                    accepted[key] = value;
+                }
+            }
+        }
+        return accepted;
+    }
+    buildToolCallRecord(id, name, args, result, success, error) {
+        return {
+            toolCallId: id,
+            toolName: name,
+            args,
+            result,
+            error,
+            success,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Determine whether a tool is a capability tool (flow transition, extraction)
+     * or a regular agent tool. Capability tools have self-contained execute()
+     * and bypass ToolExecutor enforcement.
+     */
+    isCapabilityTool(name, _tool, agent) {
+        // Extraction submit tools follow this naming pattern
+        if (name.startsWith('submit_') && name.endsWith('_data'))
+            return true;
+        // Flow transition tools are not in agent.tools
+        if (agent.tools && name in agent.tools)
+            return false;
+        // Auto-retrieve tools
+        if (name === 'search_knowledge' || name === 'auto_retrieve')
+            return true;
+        // Handoff tools
+        if (name === 'transfer_to_agent' || name.startsWith('route_to_'))
+            return true;
+        // Default: if not in agent.tools, it's likely a capability tool
+        return !agent.tools || !(name in agent.tools);
+    }
+    getLastUserInput(session) {
+        for (let i = session.messages.length - 1; i >= 0; i--) {
+            const msg = session.messages[i];
+            if (msg.role === 'user') {
+                // Extract text content from user message
+                if (typeof msg.content === 'string')
+                    return msg.content;
+                if (Array.isArray(msg.content)) {
+                    const textPart = msg.content.find((p) => p.type === 'text');
+                    if (textPart && typeof textPart.text === 'string')
+                        return textPart.text;
+                }
+                return null;
+            }
+        }
+        return null;
+    }
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+/** Resolve agent prompt from AgentConfig.prompt (string or AgentPrompt). */
+function resolveAgentPrompt(agent) {
+    const raw = agent.prompt;
+    if (!raw)
+        return '';
+    if (typeof raw === 'string')
+        return raw;
+    // AgentPrompt with sections
+    if ('sections' in raw && Array.isArray(raw.sections)) {
+        return raw.sections.map((s) => s.content).join('\n\n');
+    }
+    return String(raw);
+}
+/** Type guard for flow agents. */
+function isFlowAgent(agent) {
+    return agent.type === 'flow' || ('flow' in agent && !!agent.flow);
+}
+function normalizeExtractionText(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function isSuspiciousExtractionPlaceholder(value) {
+    return /^(unknown|not provided|not sure|n a|none|null)$/.test(value)
+        || value.includes('user mentioned')
+        || value.includes('caller mentioned')
+        || value.includes('already provided')
+        || value.includes('previous detail')
+        || value.includes('in sinhala')
+        || value.includes('in tamil');
+}
+//# sourceMappingURL=DefaultOrchestrationAuthority.js.map