llm-agent-runtime 0.1.0

package/dist/services/extract.d.ts

@@ -0,0 +1,33 @@
+import type { ToolCall, ToolExtractorMap } from "../types.js";
+export declare const getToolCallsFromMessages: (messages: unknown[]) => ToolCall[];
+/** Returns args from the first matching tool call in the message list. */
+export declare function extractToolCallArgs<T extends Record<string, unknown>>(messages: unknown[], toolName: string): T | undefined;
+/**
+ * Generic extractor: maps each unique tool name → last args object.
+ */
+export declare function extractRawToolOutputs(messages: unknown[]): Record<string, unknown>;
+/**
+ * Build an extractor from a toolName → parser map (Xel extractToolCall style).
+ *
+ * Pass this as `extractToolOutputs`, or use `toolExtractors` on createAgentRuntime
+ * and the runtime builds it for you.
+ *
+ * @example
+ * createToolOutputExtractor(
+ *   {
+ *     propose_tickets: (args, acc) => {
+ *       if (Array.isArray(acc.tickets) && (acc.tickets as unknown[]).length > 0) return;
+ *       acc.tickets = (args.tickets as unknown[]) ?? [];
+ *     },
+ *     create_campaign: (args, acc) => {
+ *       if (acc.campaign) return;
+ *       acc.campaign = args;
+ *     },
+ *   },
+ *   () => ({ tickets: [] }),
+ * )
+ */
+export declare function createToolOutputExtractor(extractors: ToolExtractorMap, initialOutputs?: () => Record<string, unknown>, options?: {
+    includeUnknown?: boolean;
+}): (messages: unknown[]) => Record<string, unknown>;
+//# sourceMappingURL=extract.d.ts.map

package/dist/services/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/services/extract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAiB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE7E,eAAO,MAAM,wBAAwB,GAAI,UAAU,OAAO,EAAE,KAAG,QAAQ,EAIpE,CAAC;AAEJ,0EAA0E;AAC1E,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,QAAQ,EAAE,OAAO,EAAE,EACnB,QAAQ,EAAE,MAAM,GACf,CAAC,GAAG,SAAS,CAOf;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,EAAE,GAClB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,gBAAgB,EAC5B,cAAc,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9C,OAAO,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GACrC,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwBlD"}

package/dist/services/extract.js

@@ -0,0 +1,64 @@
+export const getToolCallsFromMessages = (messages) => messages.flatMap((message) => message.tool_calls ?? message.additional_kwargs?.tool_calls ?? []);
+/** Returns args from the first matching tool call in the message list. */
+export function extractToolCallArgs(messages, toolName) {
+    for (const call of getToolCallsFromMessages(messages)) {
+        if (call.name === toolName) {
+            return call.args;
+        }
+    }
+    return undefined;
+}
+/**
+ * Generic extractor: maps each unique tool name → last args object.
+ */
+export function extractRawToolOutputs(messages) {
+    const outputs = {};
+    for (const call of getToolCallsFromMessages(messages)) {
+        if (!call.name || !call.args)
+            continue;
+        outputs[call.name] = call.args;
+    }
+    return outputs;
+}
+/**
+ * Build an extractor from a toolName → parser map (Xel extractToolCall style).
+ *
+ * Pass this as `extractToolOutputs`, or use `toolExtractors` on createAgentRuntime
+ * and the runtime builds it for you.
+ *
+ * @example
+ * createToolOutputExtractor(
+ *   {
+ *     propose_tickets: (args, acc) => {
+ *       if (Array.isArray(acc.tickets) && (acc.tickets as unknown[]).length > 0) return;
+ *       acc.tickets = (args.tickets as unknown[]) ?? [];
+ *     },
+ *     create_campaign: (args, acc) => {
+ *       if (acc.campaign) return;
+ *       acc.campaign = args;
+ *     },
+ *   },
+ *   () => ({ tickets: [] }),
+ * )
+ */
+export function createToolOutputExtractor(extractors, initialOutputs, options) {
+    const includeUnknown = options?.includeUnknown ?? false;
+    return (messages) => {
+        const outputs = initialOutputs
+            ? initialOutputs()
+            : {};
+        for (const call of getToolCallsFromMessages(messages)) {
+            if (!call.name)
+                continue;
+            const extractor = extractors[call.name];
+            if (extractor) {
+                extractor(call.args ?? {}, outputs);
+                continue;
+            }
+            if (includeUnknown && call.args) {
+                outputs[call.name] = call.args;
+            }
+        }
+        return outputs;
+    };
+}

package/dist/services/flow-router.d.ts

@@ -0,0 +1,42 @@
+import type { ChatFlowState, DetectedIntentResult, FinalizeFlowInput, FinalizeFlowResult, FlowResolution, FlowState, IntentDefinition, LlmIntentResult } from "../types.js";
+import type { ChatCache } from "./chat-cache.js";
+export declare const isWizardInput: (message: string) => boolean;
+export declare function createFlowRouter(options: {
+    stickyFlows: Set<string>;
+    menuMap: Record<string, string>;
+    normalizeIntent: (intent: string) => string;
+    getEmbeddedIntents: () => Promise<{
+        name: string;
+        embedding: number[];
+    }[]>;
+    scoreIntentsForMessage: (message: string, embedded: {
+        name: string;
+        embedding: number[];
+    }[]) => Promise<DetectedIntentResult[]>;
+    classifyIntentWithLlm: (input: {
+        message: string;
+        conversationContext: string;
+        activeFlowIntent?: string | null;
+    }) => Promise<LlmIntentResult>;
+    mergeIntentResults: (embeddingTop: DetectedIntentResult, llmResult: LlmIntentResult) => DetectedIntentResult & {
+        action: LlmIntentResult["action"];
+    };
+    chatCache: ChatCache;
+    finalizeFlow?: (input: FinalizeFlowInput) => FinalizeFlowResult | Promise<FinalizeFlowResult>;
+    thresholds?: {
+        switch?: number;
+        ambiguous?: number;
+        switchMargin?: number;
+    };
+}): {
+    resolveFlow: ({ message, explicitIntent, cachedFlowState, conversationContext, }: {
+        message: string;
+        explicitIntent?: string;
+        cachedFlowState: ChatFlowState | null;
+        conversationContext: string;
+    }) => Promise<FlowResolution>;
+    finalizeAgentFlow: (input: FinalizeFlowInput) => Promise<FinalizeFlowResult>;
+};
+export declare function stickySetFromIntents(intents: IntentDefinition[]): Set<string>;
+export type { FlowState, FlowResolution };
+//# sourceMappingURL=flow-router.d.ts.map

package/dist/services/flow-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-router.d.ts","sourceRoot":"","sources":["../../src/services/flow-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,eAAe,EAChB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAOjD,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,OAI/C,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IACxC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5C,kBAAkB,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC,CAAC;IAC3E,sBAAsB,EAAE,CACtB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,KAC9C,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAAC;IACrC,qBAAqB,EAAE,CAAC,KAAK,EAAE;QAC7B,OAAO,EAAE,MAAM,CAAC;QAChB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAClC,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC/B,kBAAkB,EAAE,CAClB,YAAY,EAAE,oBAAoB,EAClC,SAAS,EAAE,eAAe,KACvB,oBAAoB,GAAG;QAAE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;KAAE,CAAC;IAClE,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,CAAC,EAAE,CACb,KAAK,EAAE,iBAAiB,KACrB,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACtD,UAAU,CAAC,EAAE;QACX,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;sFAoBI;QACD,OAAO,EAAE,MAAM,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,eAAe,EAAE,aAAa,GAAG,IAAI,CAAC;QACtC,mBAAmB,EAAE,MAAM,CAAC;KAC7B,KAAG,OAAO,CAAC,cAAc,CAAC;+BA6JlB,iBAAiB,KACvB,OAAO,CAAC,kBAAkB,CAAC;EAkB/B;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAE7E;AAED,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC"}

package/dist/services/flow-router.js

@@ -0,0 +1,167 @@
+const WIZARD_SHORT_REPLIES = /^(yes|no|ok|okay|sure|yep|nope|cancel|stop|skip|continue|done|never mind)$/i;
+const isNumericOnlyMessage = (message) => /^\d+(\.\d+)?$/.test(message.trim());
+export const isWizardInput = (message) => {
+    const trimmed = message.trim();
+    if (isNumericOnlyMessage(trimmed))
+        return true;
+    return WIZARD_SHORT_REPLIES.test(trimmed);
+};
+export function createFlowRouter(options) {
+    const SWITCH_THRESHOLD = options.thresholds?.switch ?? 0.65;
+    const AMBIGUOUS_THRESHOLD = options.thresholds?.ambiguous ?? 0.45;
+    const SWITCH_MARGIN = options.thresholds?.switchMargin ?? 0.12;
+    const resolveGreetingMenuSelection = (message, activeIntent) => {
+        const trimmed = message.trim();
+        if (!(trimmed in options.menuMap))
+            return null;
+        if (activeIntent && options.stickyFlows.has(activeIntent))
+            return null;
+        return options.menuMap[trimmed] ?? null;
+    };
+    const resolveFlow = async ({ message, explicitIntent, cachedFlowState, conversationContext, }) => {
+        if (explicitIntent) {
+            const intent = options.normalizeIntent(explicitIntent);
+            const sticky = options.stickyFlows.has(intent);
+            return {
+                messageIntent: { intent, score: 1 },
+                flow: { active: sticky, intent: sticky ? intent : null },
+                promptIntent: intent,
+            };
+        }
+        const cachedIntent = cachedFlowState?.intent
+            ? options.normalizeIntent(cachedFlowState.intent)
+            : null;
+        const menuIntent = resolveGreetingMenuSelection(message, cachedIntent);
+        if (menuIntent) {
+            const sticky = options.stickyFlows.has(menuIntent);
+            return {
+                messageIntent: { intent: menuIntent, score: 1 },
+                flow: { active: sticky, intent: sticky ? menuIntent : null },
+                promptIntent: menuIntent,
+            };
+        }
+        const embeddedIntents = await options.getEmbeddedIntents();
+        const [embeddingScores, llmResult] = await Promise.all([
+            options.scoreIntentsForMessage(message, embeddedIntents),
+            options.classifyIntentWithLlm({
+                message,
+                conversationContext,
+                activeFlowIntent: cachedFlowState?.intent ?? null,
+            }),
+        ]);
+        const merged = options.mergeIntentResults(embeddingScores[0], llmResult);
+        const messageIntent = {
+            intent: merged.intent,
+            score: merged.score,
+        };
+        const inStickyFlow = cachedIntent !== null && options.stickyFlows.has(cachedIntent);
+        if (!inStickyFlow) {
+            const shouldStartFlow = options.stickyFlows.has(messageIntent.intent) &&
+                (messageIntent.score >= SWITCH_THRESHOLD ||
+                    llmResult.action === "switch" ||
+                    llmResult.intent === messageIntent.intent);
+            return {
+                messageIntent,
+                flow: shouldStartFlow
+                    ? { active: true, intent: messageIntent.intent }
+                    : { active: false, intent: null },
+                promptIntent: messageIntent.intent,
+                llmResult,
+            };
+        }
+        const cachedFlowIntent = cachedIntent;
+        if (llmResult.action === "switch" || llmResult.action === "cancel") {
+            const newSticky = options.stickyFlows.has(messageIntent.intent);
+            return {
+                messageIntent,
+                flow: newSticky
+                    ? { active: true, intent: messageIntent.intent }
+                    : { active: false, intent: null },
+                promptIntent: messageIntent.intent,
+                llmResult,
+            };
+        }
+        if (isWizardInput(message)) {
+            return {
+                messageIntent,
+                flow: { active: true, intent: cachedFlowIntent },
+                promptIntent: cachedFlowIntent,
+                llmResult,
+            };
+        }
+        if (messageIntent.intent === cachedFlowIntent) {
+            return {
+                messageIntent,
+                flow: { active: true, intent: cachedFlowIntent },
+                promptIntent: cachedFlowIntent,
+                llmResult,
+            };
+        }
+        const cachedScore = embeddingScores.find((s) => s.intent === cachedFlowIntent)?.score ?? 0;
+        const wantsSwitch = messageIntent.intent !== cachedFlowIntent &&
+            messageIntent.score >= SWITCH_THRESHOLD &&
+            messageIntent.score - cachedScore >= SWITCH_MARGIN;
+        if (wantsSwitch) {
+            const newSticky = options.stickyFlows.has(messageIntent.intent);
+            return {
+                messageIntent,
+                flow: newSticky
+                    ? { active: true, intent: messageIntent.intent }
+                    : { active: false, intent: null },
+                promptIntent: messageIntent.intent,
+                llmResult,
+            };
+        }
+        const isAmbiguous = messageIntent.score < AMBIGUOUS_THRESHOLD;
+        if (isAmbiguous) {
+            return {
+                messageIntent,
+                flow: { active: true, intent: cachedFlowIntent },
+                promptIntent: cachedFlowIntent,
+                llmResult,
+            };
+        }
+        return {
+            messageIntent,
+            flow: { active: true, intent: cachedFlowIntent },
+            promptIntent: cachedFlowIntent,
+            llmResult,
+        };
+    };
+    const defaultFinalize = async ({ threadId, flow, }) => {
+        if (!flow.active || !flow.intent) {
+            await options.chatCache.clearChatCacheFlowState(threadId);
+            return {
+                flow: { active: false, intent: null },
+                flowCompleted: false,
+            };
+        }
+        await options.chatCache.setChatCacheFlowState(threadId, {
+            intent: flow.intent,
+            timestamp: Date.now(),
+        });
+        return {
+            flow,
+            flowCompleted: false,
+        };
+    };
+    const finalizeAgentFlow = async (input) => {
+        const custom = options.finalizeFlow
+            ? await options.finalizeFlow(input)
+            : await defaultFinalize(input);
+        if (custom.flowCompleted || !custom.flow.active || !custom.flow.intent) {
+            await options.chatCache.clearChatCacheFlowState(input.threadId);
+        }
+        else {
+            await options.chatCache.setChatCacheFlowState(input.threadId, {
+                intent: custom.flow.intent,
+                timestamp: Date.now(),
+            });
+        }
+        return custom;
+    };
+    return { resolveFlow, finalizeAgentFlow };
+}
+export function stickySetFromIntents(intents) {
+    return new Set(intents.filter((i) => i.sticky).map((i) => i.name));
+}

package/dist/services/intent-embeddings.d.ts

@@ -0,0 +1,17 @@
+import type { Embeddings } from "@langchain/core/embeddings";
+import type { DetectedIntentResult, IntentDefinition } from "../types.js";
+export type EmbeddedIntent = {
+    name: string;
+    embedding: number[];
+};
+export declare function createIntentEmbeddings(options: {
+    embeddings: Embeddings;
+    intents: IntentDefinition[];
+    normalizeIntent: (intent: string) => string;
+}): {
+    getEmbeddedIntents: () => Promise<EmbeddedIntent[]>;
+    scoreIntentsForMessage: (message: string, embeddedIntents: EmbeddedIntent[]) => Promise<DetectedIntentResult[]>;
+    /** Rebuild embeddings after intent catalog changes. */
+    invalidate: () => void;
+};
+//# sourceMappingURL=intent-embeddings.d.ts.map

package/dist/services/intent-embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-embeddings.d.ts","sourceRoot":"","sources":["../../src/services/intent-embeddings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAgB1E,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C;8BAsBsC,OAAO,CAAC,cAAc,EAAE,CAAC;sCAQnD,MAAM,mBACE,cAAc,EAAE,KAChC,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAchC,uDAAuD;;EAK1D"}

package/dist/services/intent-embeddings.js

@@ -0,0 +1,46 @@
+function cosineSimilarity(a, b) {
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        magA += a[i] * a[i];
+        magB += b[i] * b[i];
+    }
+    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+export function createIntentEmbeddings(options) {
+    let cached = null;
+    const build = async () => {
+        const results = [];
+        for (const intent of options.intents) {
+            const embeddings = await Promise.all(intent.examples.map((ex) => options.embeddings.embedQuery(ex)));
+            const avgEmbedding = embeddings[0].map((_, i) => embeddings.reduce((sum, emb) => sum + emb[i], 0) / embeddings.length);
+            results.push({ name: intent.name, embedding: avgEmbedding });
+        }
+        return results;
+    };
+    const getEmbeddedIntents = async () => {
+        if (!cached) {
+            cached = await build();
+        }
+        return cached;
+    };
+    const scoreIntentsForMessage = async (message, embeddedIntents) => {
+        const queryEmbedding = await options.embeddings.embedQuery(message);
+        return embeddedIntents
+            .map((intent) => ({
+            intent: options.normalizeIntent(intent.name),
+            score: cosineSimilarity(queryEmbedding, intent.embedding),
+        }))
+            .sort((a, b) => b.score - a.score);
+    };
+    return {
+        getEmbeddedIntents,
+        scoreIntentsForMessage,
+        /** Rebuild embeddings after intent catalog changes. */
+        invalidate: () => {
+            cached = null;
+        },
+    };
+}

package/dist/services/intent-router.d.ts

@@ -0,0 +1,21 @@
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { DetectedIntentResult, IntentDefinition, LlmIntentResult } from "../types.js";
+export declare function createIntentRouter(options: {
+    model: BaseChatModel;
+    intents: IntentDefinition[];
+    normalizeIntent: (intent: string) => string;
+    defaultIntent: string;
+    routerSystemPrompt?: string | ((intents: IntentDefinition[]) => string);
+    llmConfidence?: number;
+    embeddingConfidence?: number;
+}): {
+    classifyIntentWithLlm: ({ message, conversationContext, activeFlowIntent, }: {
+        message: string;
+        conversationContext: string;
+        activeFlowIntent?: string | null;
+    }) => Promise<LlmIntentResult>;
+    mergeIntentResults: (embeddingTop: DetectedIntentResult, llmResult: LlmIntentResult) => DetectedIntentResult & {
+        action: LlmIntentResult["action"];
+    };
+};
+//# sourceMappingURL=intent-router.d.ts.map

package/dist/services/intent-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-router.d.ts","sourceRoot":"","sources":["../../src/services/intent-router.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EAChB,MAAM,aAAa,CAAC;AAuBrB,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,gBAAgB,EAAE,KAAK,MAAM,CAAC,CAAC;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;iFA2BI;QACD,OAAO,EAAE,MAAM,CAAC;QAChB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAClC,KAAG,OAAO,CAAC,eAAe,CAAC;uCAsCZ,oBAAoB,aACvB,eAAe,KACzB,oBAAoB,GAAG;QAAE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;KAAE;EA4BhE"}

package/dist/services/intent-router.js

@@ -0,0 +1,98 @@
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { z } from "zod";
+function buildDefaultRouterPrompt(intents) {
+    const lines = intents.map((intent) => {
+        const desc = intent.description ?? intent.examples.slice(0, 3).join(", ");
+        return `- ${intent.name} — ${desc}`;
+    });
+    return `You classify user intent for an assistant.
+
+Available intents:
+${lines.join("\n")}
+
+Return JSON only with: intent, confidence (0-1), action, optional short reason.
+
+action rules:
+- continue — user is answering the current flow, confirming a step, or their message fits the active flow
+- switch — user wants a different service
+- cancel — user explicitly stops or abandons the current flow
+
+Wizard replies (digits only, yes/no/ok/skip) during an active sticky flow → action: continue, intent: that sticky flow.`;
+}
+export function createIntentRouter(options) {
+    const intentNames = options.intents.map((i) => i.name);
+    if (intentNames.length === 0) {
+        throw new Error("intents must contain at least one intent definition.");
+    }
+    // zod enum needs a non-empty tuple
+    const IntentRouterSchema = z.object({
+        intent: z.enum(intentNames),
+        confidence: z.number().min(0).max(1),
+        action: z.enum(["continue", "switch", "cancel"]),
+        reason: z.string().max(200).optional(),
+    });
+    const systemPrompt = typeof options.routerSystemPrompt === "function"
+        ? options.routerSystemPrompt(options.intents)
+        : (options.routerSystemPrompt ??
+            buildDefaultRouterPrompt(options.intents));
+    const llmConfidence = options.llmConfidence ?? 0.6;
+    const embeddingConfidence = options.embeddingConfidence ?? 0.65;
+    const classifyIntentWithLlm = async ({ message, conversationContext, activeFlowIntent, }) => {
+        const userPrompt = [
+            `Active flow: ${activeFlowIntent ?? "none"}`,
+            "",
+            "Recent conversation:",
+            conversationContext || "(no prior messages)",
+            "",
+            `Latest user message: "${message}"`,
+            "",
+            "Classify intent and action. Reply with JSON only.",
+        ].join("\n");
+        try {
+            const structured = options.model.withStructuredOutput(IntentRouterSchema, {
+                name: "intent_router",
+            });
+            const result = await structured.invoke([
+                new SystemMessage(systemPrompt),
+                new HumanMessage(userPrompt),
+            ]);
+            return {
+                intent: options.normalizeIntent(result.intent),
+                score: result.confidence,
+                action: result.action,
+                reason: result.reason,
+            };
+        }
+        catch {
+            return {
+                intent: options.defaultIntent,
+                score: 0.5,
+                action: activeFlowIntent ? "continue" : "switch",
+            };
+        }
+    };
+    const mergeIntentResults = (embeddingTop, llmResult) => {
+        if (llmResult.score >= llmConfidence) {
+            return {
+                intent: llmResult.intent,
+                score: llmResult.score,
+                action: llmResult.action,
+            };
+        }
+        if (embeddingTop.score >= embeddingConfidence) {
+            return {
+                intent: embeddingTop.intent,
+                score: embeddingTop.score,
+                action: llmResult.action === "cancel" || llmResult.action === "switch"
+                    ? llmResult.action
+                    : "continue",
+            };
+        }
+        return {
+            intent: llmResult.intent,
+            score: llmResult.score,
+            action: llmResult.action,
+        };
+    };
+    return { classifyIntentWithLlm, mergeIntentResults };
+}