llm-agent-runtime 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# llm-agent-runtime
+
+Reusable LangGraph agent runtime (intent routing, sticky flows, checkpointer, tool extractors).
+
+Usage docs deferred until the package is tested end-to-end.

package/dist/agent.d.ts

@@ -0,0 +1,20 @@
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import type { IntentRegistry } from "./types.js";
+export type AgentFactory = {
+    checkpointer: BaseCheckpointSaver;
+    createAgent: (phoneKey: string, intent?: string) => ReturnType<typeof createReactAgent>;
+    getAgentState: (threadId: string) => Promise<{
+        values: {
+            messages?: unknown[];
+        };
+    }>;
+};
+export declare function createAgentFactory(options: {
+    llm: BaseChatModel;
+    intentRegistry: IntentRegistry;
+    redisUrl?: string;
+    checkpointer?: BaseCheckpointSaver;
+}): Promise<AgentFactory>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,mBAAmB,CAAC;IAClC,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;IACxF,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE;YAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC;CACpF,CAAC;AAEF,wBAAsB,kBAAkB,CAAC,OAAO,EAAE;IAChD,GAAG,EAAE,aAAa,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,mBAAmB,CAAC;CACpC,GAAG,OAAO,CAAC,YAAY,CAAC,CAsCxB"}

package/dist/agent.js

@@ -0,0 +1,37 @@
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { MemorySaver } from "@langchain/langgraph-checkpoint";
+import { RedisSaver } from "@langchain/langgraph-checkpoint-redis";
+export async function createAgentFactory(options) {
+    const checkpointer = options.checkpointer ??
+        (options.redisUrl
+            ? await RedisSaver.fromUrl(options.redisUrl)
+            : new MemorySaver());
+    const fallbackTools = () => {
+        const first = Object.values(options.intentRegistry)[0];
+        return first?.tools("") ?? [];
+    };
+    const stateReader = createReactAgent({
+        llm: options.llm,
+        tools: fallbackTools(),
+        checkpointSaver: checkpointer,
+    });
+    return {
+        checkpointer,
+        createAgent: (phoneKey, intent) => {
+            const tools = intent
+                ? (options.intentRegistry[intent]?.tools(phoneKey) ?? [])
+                : fallbackTools();
+            return createReactAgent({
+                llm: options.llm,
+                tools,
+                checkpointSaver: checkpointer,
+            });
+        },
+        getAgentState: async (threadId) => {
+            const state = await stateReader.getState({
+                configurable: { thread_id: threadId },
+            });
+            return state;
+        },
+    };
+}

package/dist/create-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { AgentRuntimeConfig, InvokeInput, InvokeResult } from "./types.js";
+export type AgentRuntime = {
+    invoke: (input: InvokeInput) => Promise<InvokeResult>;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    clearFlow: (threadId: string) => Promise<void>;
+    getCachedAnswer: (message: string) => Promise<string | undefined>;
+    setCachedAnswer: (message: string, answer: string) => Promise<void>;
+    /** Invalidate embedding cache after changing intent examples at runtime. */
+    invalidateIntentEmbeddings: () => void;
+};
+/**
+ * Factory for a reusable agent runtime.
+ * Engine pipeline: resolveFlow → runAgent → getTurnMessages → extract → finalize
+ */
+export declare function createAgentRuntime(config: AgentRuntimeConfig): Promise<AgentRuntime>;
+//# sourceMappingURL=create-runtime.d.ts.map

package/dist/create-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-runtime.d.ts","sourceRoot":"","sources":["../src/create-runtime.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACX,YAAY,EAEb,MAAM,YAAY,CAAC;AAepB,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IACtD,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAClE,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,4EAA4E;IAC5E,0BAA0B,EAAE,MAAM,IAAI,CAAC;CACxC,CAAC;AAEF;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,YAAY,CAAC,CA6MvB"}

package/dist/create-runtime.js

@@ -0,0 +1,197 @@
+import { createAgentFactory } from "./agent.js";
+import { createModels } from "./llm.js";
+import { createRedis } from "./redis.js";
+import { createAgentRunner } from "./services/agent-runner.js";
+import { createChatCache } from "./services/chat-cache.js";
+import { createConversationService } from "./services/conversation.js";
+import { createToolOutputExtractor, extractRawToolOutputs } from "./services/extract.js";
+import { createFlowRouter, stickySetFromIntents, } from "./services/flow-router.js";
+import { createIntentEmbeddings } from "./services/intent-embeddings.js";
+import { createIntentRouter } from "./services/intent-router.js";
+import { getLastMessageContent } from "./utils/message.js";
+/** Messages for this user turn only (used to extract tool outputs). */
+const getTurnMessages = (allMessages, userMessage) => {
+    const normalized = userMessage.trim();
+    const list = allMessages;
+    for (let i = list.length - 1; i >= 0; i--) {
+        const content = String(list[i]?.content ?? "").trim();
+        if (content === normalized) {
+            return list.slice(i);
+        }
+    }
+    return list.slice(-6);
+};
+/**
+ * Factory for a reusable agent runtime.
+ * Engine pipeline: resolveFlow → runAgent → getTurnMessages → extract → finalize
+ */
+export async function createAgentRuntime(config) {
+    const defaultIntent = config.defaultIntent ?? config.intents[0]?.name ?? "greetings";
+    const intentNames = new Set(config.intents.map((i) => i.name));
+    const aliases = config.intentAliases ?? {};
+    const normalizeIntent = (intent) => {
+        const key = intent
+            .trim()
+            .toLowerCase()
+            .replace(/[\s-]+/g, "_");
+        if (intentNames.has(key))
+            return key;
+        return aliases[key] ?? defaultIntent;
+    };
+    const stickyFlows = stickySetFromIntents(config.intents);
+    const menuMap = config.menuMap ?? {};
+    const created = createModels(config.llm);
+    const chat = config.models?.chat ?? created.chat;
+    const intentRouterModel = config.models?.intentRouter ?? created.intentRouter;
+    const embeddings = config.models?.embeddings ?? created.embeddings;
+    // Redis client when redisUrl is set (flow state + optional answer cache)
+    const redis = config.redisUrl
+        ? createRedis(config.redisUrl)
+        : undefined;
+    const chatCache = createChatCache({
+        redis: redis?.client,
+        config: {
+            enabled: config.cache?.enabled ?? false,
+            ttlSeconds: config.cache?.ttlSeconds,
+            flowTtlSeconds: config.cache?.flowTtlSeconds,
+            scope: config.cache?.scope,
+        },
+    });
+    const agentFactory = await createAgentFactory({
+        llm: chat,
+        intentRegistry: config.intentRegistry,
+        redisUrl: config.redisUrl,
+        checkpointer: config.checkpointer,
+    });
+    const conversation = createConversationService(agentFactory);
+    const { runAgent } = createAgentRunner({
+        agentFactory,
+        recursionLimit: config.recursionLimit,
+    });
+    const intentEmbeddings = createIntentEmbeddings({
+        embeddings,
+        intents: config.intents,
+        normalizeIntent,
+    });
+    const intentRouter = createIntentRouter({
+        model: intentRouterModel,
+        intents: config.intents,
+        normalizeIntent,
+        defaultIntent,
+        routerSystemPrompt: config.routerSystemPrompt,
+        llmConfidence: config.thresholds?.llmConfidence,
+        embeddingConfidence: config.thresholds?.embeddingConfidence,
+    });
+    const { resolveFlow, finalizeAgentFlow } = createFlowRouter({
+        stickyFlows,
+        menuMap,
+        normalizeIntent,
+        getEmbeddedIntents: intentEmbeddings.getEmbeddedIntents,
+        scoreIntentsForMessage: intentEmbeddings.scoreIntentsForMessage,
+        classifyIntentWithLlm: intentRouter.classifyIntentWithLlm,
+        mergeIntentResults: intentRouter.mergeIntentResults,
+        chatCache,
+        finalizeFlow: config.finalizeFlow,
+        thresholds: config.thresholds,
+    });
+    const extractToolOutputs = config.extractToolOutputs ??
+        (config.toolExtractors
+            ? createToolOutputExtractor(config.toolExtractors, config.initialToolOutputs, { includeUnknown: config.includeUnknownToolOutputs ?? false })
+            : extractRawToolOutputs);
+    const buildSystemPrompt = config.buildSystemPrompt ??
+        ((ctx) => {
+            const binding = config.intentRegistry[ctx.intent];
+            if (!binding) {
+                const fallback = Object.values(config.intentRegistry)[0];
+                return fallback?.prompt(ctx) ?? "";
+            }
+            return binding.prompt(ctx);
+        });
+    const resolvePhoneKey = config.resolvePhoneKey ??
+        (({ threadId, phoneKey }) => phoneKey ?? threadId);
+    const invoke = async (input) => {
+        if (chatCache.enabled) {
+            const cached = await chatCache.getCachedAnswer(input.message);
+            if (cached) {
+                return {
+                    messages: [],
+                    answer: cached,
+                    intent: { intent: defaultIntent, score: 1 },
+                    flow: { active: false, intent: null },
+                    toolOutputs: {},
+                    flowCompleted: false,
+                    extras: { cacheHit: true },
+                };
+            }
+        }
+        const cachedFlowState = await chatCache.getChatCacheFlowState(input.threadId);
+        const [messages, conversationContext] = await Promise.all([
+            conversation.getManagedConversationMessages(input.threadId),
+            conversation.getConversationContextForIntent(input.threadId),
+        ]);
+        const { messageIntent, flow, promptIntent, llmResult } = await resolveFlow({
+            message: input.message,
+            explicitIntent: input.explicitIntent,
+            cachedFlowState,
+            conversationContext,
+        });
+        const phoneKey = resolvePhoneKey({
+            threadId: input.threadId,
+            phoneKey: input.phoneKey,
+            context: input.context,
+        });
+        const systemPrompt = buildSystemPrompt({
+            hasConversationHistory: messages.length > 0,
+            intent: promptIntent,
+            intentScore: flow.active ? 1 : messageIntent.score,
+            message: input.message,
+            context: input.context,
+        });
+        const result = await runAgent({
+            message: input.message,
+            threadId: input.threadId,
+            messages,
+            systemPrompt,
+            phoneKey,
+            intent: promptIntent,
+        });
+        const resultMessages = result.messages;
+        const turnMessages = getTurnMessages(resultMessages, input.message);
+        const toolOutputs = extractToolOutputs(turnMessages);
+        const finalized = await finalizeAgentFlow({
+            threadId: input.threadId,
+            promptIntent,
+            flow,
+            toolOutputs,
+        });
+        const answer = getLastMessageContent(resultMessages);
+        if (chatCache.enabled && answer) {
+            await chatCache.setCachedAnswer(input.message, answer);
+        }
+        return {
+            messages: resultMessages,
+            answer,
+            intent: messageIntent,
+            flow: finalized.flow,
+            toolOutputs,
+            flowCompleted: finalized.flowCompleted,
+            extras: finalized.extras,
+            ...(llmResult
+                ? { router: { action: llmResult.action, reason: llmResult.reason } }
+                : {}),
+        };
+    };
+    return {
+        invoke,
+        connect: async () => {
+            await redis?.connect();
+        },
+        disconnect: async () => {
+            await redis?.disconnect();
+        },
+        clearFlow: chatCache.clearChatCacheFlowState,
+        getCachedAnswer: chatCache.getCachedAnswer,
+        setCachedAnswer: chatCache.setCachedAnswer,
+        invalidateIntentEmbeddings: intentEmbeddings.invalidate,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createAgentRuntime, type AgentRuntime } from "./create-runtime.js";
+export { createModels } from "./llm.js";
+export { createRedis } from "./redis.js";
+export { extractRawToolOutputs, extractToolCallArgs, getToolCallsFromMessages, createToolOutputExtractor, } from "./services/extract.js";
+export { isWizardInput } from "./services/flow-router.js";
+export { getLastMessageContent } from "./utils/message.js";
+export { normalize } from "./utils/normalize.js";
+export type { AgentRuntimeConfig, CacheConfig, ChatFlowState, DetectedIntentResult, FinalizeFlowInput, FinalizeFlowResult, FlowResolution, FlowState, IntentBinding, IntentDefinition, IntentRegistry, InvokeInput, InvokeResult, LlmConfig, LlmIntentResult, LlmProvider, PromptContext, ToolCall, ToolExtractor, ToolExtractorMap, TracingConfig, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,YAAY,EACV,kBAAkB,EAClB,WAAW,EACX,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,YAAY,EACZ,SAAS,EACT,eAAe,EACf,WAAW,EACX,aAAa,EACb,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { createAgentRuntime } from "./create-runtime.js";
+export { createModels } from "./llm.js";
+export { createRedis } from "./redis.js";
+export { extractRawToolOutputs, extractToolCallArgs, getToolCallsFromMessages, createToolOutputExtractor, } from "./services/extract.js";
+export { isWizardInput } from "./services/flow-router.js";
+export { getLastMessageContent } from "./utils/message.js";
+export { normalize } from "./utils/normalize.js";

package/dist/llm.d.ts

@@ -0,0 +1,17 @@
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { Embeddings } from "@langchain/core/embeddings";
+import type { LlmConfig, LlmProvider } from "./types.js";
+export type CreatedModels = {
+    chat: BaseChatModel;
+    intentRouter: BaseChatModel;
+    embeddings: Embeddings;
+    config: {
+        provider: LlmProvider;
+        embeddingsProvider: LlmProvider;
+        model: string;
+        intentRouterModel: string;
+        embeddingsModel: string;
+    };
+};
+export declare function createModels(llm: LlmConfig): CreatedModels;
+//# sourceMappingURL=llm.d.ts.map

package/dist/llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../src/llm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAG7D,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAczD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,aAAa,CAAC;IACpB,YAAY,EAAE,aAAa,CAAC;IAC5B,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE;QACN,QAAQ,EAAE,WAAW,CAAC;QACtB,kBAAkB,EAAE,WAAW,CAAC;QAChC,KAAK,EAAE,MAAM,CAAC;QACd,iBAAiB,EAAE,MAAM,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;CACH,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,aAAa,CAgE1D"}

package/dist/llm.js

@@ -0,0 +1,65 @@
+import { ChatOpenAI, OpenAIEmbeddings } from "@langchain/openai";
+import { ChatOllama, OllamaEmbeddings } from "@langchain/ollama";
+const normalizeProvider = (value) => {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "openai" ||
+        normalized === "gpt" ||
+        normalized === "chatgpt") {
+        return "openai";
+    }
+    return "ollama";
+};
+export function createModels(llm) {
+    const provider = normalizeProvider(llm.provider);
+    const embeddingsProvider = normalizeProvider(llm.embeddingsProvider ?? llm.provider);
+    const temperature = llm.temperature ?? 0;
+    const createChat = (modelName) => {
+        if (provider === "openai") {
+            if (!llm.apiKey) {
+                throw new Error("llm.apiKey is required when provider is openai.");
+            }
+            return new ChatOpenAI({
+                model: modelName,
+                temperature,
+                apiKey: llm.apiKey,
+            });
+        }
+        return new ChatOllama({
+            model: modelName,
+            temperature,
+            baseUrl: llm.baseUrl,
+        });
+    };
+    const createEmbeddings = () => {
+        if (embeddingsProvider === "openai") {
+            if (!llm.apiKey) {
+                throw new Error("llm.apiKey is required when embeddingsProvider is openai.");
+            }
+            return new OpenAIEmbeddings({
+                model: llm.embeddingsModel ?? "text-embedding-3-small",
+                apiKey: llm.apiKey,
+            });
+        }
+        return new OllamaEmbeddings({
+            model: llm.embeddingsModel ?? "mxbai-embed-large:latest",
+            baseUrl: llm.baseUrl,
+        });
+    };
+    const intentRouterModelName = llm.intentRouterModel ?? llm.model;
+    const embeddingsModelName = llm.embeddingsModel ??
+        (embeddingsProvider === "openai"
+            ? "text-embedding-3-small"
+            : "mxbai-embed-large:latest");
+    return {
+        chat: createChat(llm.model),
+        intentRouter: createChat(intentRouterModelName),
+        embeddings: createEmbeddings(),
+        config: {
+            provider,
+            embeddingsProvider,
+            model: llm.model,
+            intentRouterModel: intentRouterModelName,
+            embeddingsModel: embeddingsModelName,
+        },
+    };
+}

package/dist/redis.d.ts

@@ -0,0 +1,9 @@
+import { type RedisClientType } from "redis";
+export type RuntimeRedis = {
+    client: RedisClientType;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+};
+/** Creates a Redis client for flow state + optional answer cache. */
+export declare function createRedis(redisUrl: string): RuntimeRedis;
+//# sourceMappingURL=redis.d.ts.map

package/dist/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../src/redis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,OAAO,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC,CAAC;AAEF,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,CAgB1D"}

package/dist/redis.js

@@ -0,0 +1,18 @@
+import { createClient } from "redis";
+/** Creates a Redis client for flow state + optional answer cache. */
+export function createRedis(redisUrl) {
+    const client = createClient({ url: redisUrl });
+    return {
+        client,
+        connect: async () => {
+            if (!client.isOpen) {
+                await client.connect();
+            }
+        },
+        disconnect: async () => {
+            if (client.isOpen) {
+                await client.disconnect();
+            }
+        },
+    };
+}

package/dist/services/agent-runner.d.ts

@@ -0,0 +1,17 @@
+import type { AgentFactory } from "../agent.js";
+export type AgentRunInput = {
+    message: string;
+    threadId: string;
+    messages: unknown[];
+    systemPrompt: string;
+    phoneKey: string;
+    intent?: string;
+};
+export declare function createAgentRunner(options: {
+    agentFactory: AgentFactory;
+    recursionLimit?: number;
+}): {
+    runAgent: ({ message, threadId, messages, systemPrompt, phoneKey, intent, }: AgentRunInput) => Promise<any>;
+};
+export type AgentRunResult = Awaited<ReturnType<ReturnType<typeof createAgentRunner>["runAgent"]>>;
+//# sourceMappingURL=agent-runner.d.ts.map

package/dist/services/agent-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner.d.ts","sourceRoot":"","sources":["../../src/services/agent-runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;iFAUI,aAAa;EAmBjB;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,CAClC,UAAU,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,UAAU,CAAC,CAAC,CAC7D,CAAC"}

package/dist/services/agent-runner.js

@@ -0,0 +1,18 @@
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+export function createAgentRunner(options) {
+    const recursionLimit = options.recursionLimit ?? 6;
+    const runAgent = async ({ message, threadId, messages, systemPrompt, phoneKey, intent, }) => {
+        const agent = options.agentFactory.createAgent(phoneKey, intent);
+        return agent.invoke({
+            messages: [
+                new SystemMessage(systemPrompt),
+                ...messages,
+                new HumanMessage(message),
+            ],
+        }, {
+            configurable: { thread_id: threadId },
+            recursionLimit,
+        });
+    };
+    return { runAgent };
+}

package/dist/services/chat-cache.d.ts

@@ -0,0 +1,16 @@
+import type { RedisClientType } from "redis";
+import type { CacheConfig, ChatFlowState } from "../types.js";
+export declare function createChatCache(options: {
+    redis?: RedisClientType;
+    config?: CacheConfig;
+}): {
+    enabled: boolean;
+    getCachedAnswer: (message: string) => Promise<string | undefined>;
+    setCachedAnswer: (message: string, answer: string) => Promise<void>;
+    deleteCachedAnswer: (message: string) => Promise<void>;
+    setChatCacheFlowState: (threadId: string, flowState: ChatFlowState) => Promise<void>;
+    getChatCacheFlowState: (threadId: string) => Promise<ChatFlowState | null>;
+    clearChatCacheFlowState: (threadId: string) => Promise<void>;
+};
+export type ChatCache = ReturnType<typeof createChatCache>;
+//# sourceMappingURL=chat-cache.d.ts.map

package/dist/services/chat-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-cache.d.ts","sourceRoot":"","sources":["../../src/services/chat-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAG7C,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAK9D,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;;+BAUyC,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;+BAmBpC,MAAM,UAAU,MAAM;kCAOnB,MAAM;sCAMrC,MAAM,aACL,aAAa;sCASd,MAAM,KACf,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;wCAOiB,MAAM;EAcxD;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/services/chat-cache.js

@@ -0,0 +1,70 @@
+import { normalize } from "../utils/normalize.js";
+import { getLastMessageContent } from "../utils/message.js";
+const DEFAULT_ANSWER_TTL = 60 * 60 * 24;
+const DEFAULT_FLOW_TTL = 60 * 30;
+export function createChatCache(options) {
+    const enabled = Boolean(options.config?.enabled && options.redis);
+    const answerTtl = options.config?.ttlSeconds ?? DEFAULT_ANSWER_TTL;
+    const flowTtl = options.config?.flowTtlSeconds ?? DEFAULT_FLOW_TTL;
+    const scope = options.config?.scope ?? "qa";
+    const redis = options.redis;
+    const getCacheKey = (message) => `${scope}:${normalize(message)}`;
+    const getFlowStateKey = (threadId) => `flow:${threadId}`;
+    const getCachedAnswer = async (message) => {
+        if (!enabled || !redis)
+            return undefined;
+        const cacheKey = getCacheKey(message);
+        const cached = await redis.get(cacheKey);
+        if (!cached)
+            return undefined;
+        const cachedResult = JSON.parse(cached);
+        const cachedAnswer = typeof cachedResult?.answer === "string"
+            ? cachedResult.answer
+            : getLastMessageContent(cachedResult?.messages);
+        if (cachedAnswer)
+            return cachedAnswer;
+        await redis.del(cacheKey);
+        return undefined;
+    };
+    const setCachedAnswer = async (message, answer) => {
+        if (!enabled || !redis)
+            return;
+        await redis.set(getCacheKey(message), JSON.stringify({ answer }), {
+            EX: answerTtl,
+        });
+    };
+    const deleteCachedAnswer = async (message) => {
+        if (!redis)
+            return;
+        await redis.del(getCacheKey(message));
+    };
+    const setChatCacheFlowState = async (threadId, flowState) => {
+        if (!redis)
+            return;
+        await redis.set(getFlowStateKey(threadId), JSON.stringify(flowState), {
+            EX: flowTtl,
+        });
+    };
+    const getChatCacheFlowState = async (threadId) => {
+        if (!redis)
+            return null;
+        const cached = await redis.get(getFlowStateKey(threadId));
+        if (!cached)
+            return null;
+        return JSON.parse(cached);
+    };
+    const clearChatCacheFlowState = async (threadId) => {
+        if (!redis)
+            return;
+        await redis.del(getFlowStateKey(threadId));
+    };
+    return {
+        enabled,
+        getCachedAnswer,
+        setCachedAnswer,
+        deleteCachedAnswer,
+        setChatCacheFlowState,
+        getChatCacheFlowState,
+        clearChatCacheFlowState,
+    };
+}

package/dist/services/conversation.d.ts

@@ -0,0 +1,7 @@
+import type { AgentFactory } from "../agent.js";
+export declare function createConversationService(agentFactory: AgentFactory): {
+    getManagedConversationMessages: (threadId: string) => Promise<unknown[]>;
+    formatConversationForIntentRouter: (messages: unknown[]) => string;
+    getConversationContextForIntent: (threadId: string) => Promise<string>;
+};
+//# sourceMappingURL=conversation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conversation.d.ts","sourceRoot":"","sources":["../../src/services/conversation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY;+CACV,MAAM;kDAsCT,OAAO,EAAE,KAAG,MAAM;gDAe3D,MAAM,KACf,OAAO,CAAC,MAAM,CAAC;EAUnB"}

package/dist/services/conversation.js

@@ -0,0 +1,56 @@
+export function createConversationService(agentFactory) {
+    const getManagedConversationMessages = async (threadId) => {
+        const state = await agentFactory.getAgentState(threadId);
+        const messages = state.values.messages ?? [];
+        return messages
+            .filter((message) => {
+            const content = String(message?.content ?? "").toLowerCase();
+            return (!content.includes("tool failed") &&
+                !content.includes("error") &&
+                !content.includes("undefined"));
+        })
+            .slice(-8);
+    };
+    const getMessageRole = (message) => {
+        const type = message._getType?.() ?? message.type ?? "";
+        if (type === "human")
+            return "User";
+        if (type === "ai")
+            return "Assistant";
+        return "System";
+    };
+    const getMessageText = (message) => {
+        const content = message.content;
+        if (typeof content === "string")
+            return content.trim();
+        if (Array.isArray(content)) {
+            return content
+                .map((part) => (typeof part === "string" ? part : (part?.text ?? "")))
+                .join(" ")
+                .trim();
+        }
+        return String(content ?? "").trim();
+    };
+    const formatConversationForIntentRouter = (messages) => {
+        if (messages.length === 0)
+            return "(no prior messages)";
+        return messages
+            .slice(-6)
+            .map((message) => {
+            const role = getMessageRole(message);
+            const text = getMessageText(message).slice(0, 300);
+            return text ? `${role}: ${text}` : null;
+        })
+            .filter(Boolean)
+            .join("\n");
+    };
+    const getConversationContextForIntent = async (threadId) => {
+        const messages = await getManagedConversationMessages(threadId);
+        return formatConversationForIntentRouter(messages);
+    };
+    return {
+        getManagedConversationMessages,
+        formatConversationForIntentRouter,
+        getConversationContextForIntent,
+    };
+}