@diegoaltoworks/chatter 0.31.0 → 0.33.0

package/dist/flows/index.mjs

@@ -0,0 +1,448 @@
+// src/flows/intent.ts
+async function detectIntent(client, model, message, flows, conversationContext) {
+  const contextStr = conversationContext && conversationContext.length > 0 ? `
+
+Recent conversation:
+${conversationContext.join("\n")}` : "";
+  const flowDescriptions = Array.from(flows.entries()).map(([id, flow], index) => {
+    const keywords = flow.definition.triggerKeywords.join(", ");
+    return `${index + 1}. ${id} -- ${flow.definition.description}
+   - Keywords: ${keywords}`;
+  }).join("\n\n");
+  const systemPrompt = `You are an intent detector.
+
+Detect ONE category. Use these EXACT ids (they must match flow ids):
+
+${flowDescriptions}
+
+${flows.size + 1}. chatbot -- All other questions (general fallback)
+${contextStr}
+
+Return JSON with:
+- "intent": one of the ids above (exact string)
+- "confidence": 0.0-1.0 (how certain you are)
+- "reasoning": brief explanation
+
+Rules:
+- If uncertain, always return "chatbot" with low confidence`;
+  try {
+    const response = await client.chat.completions.create({
+      model,
+      temperature: 0.1,
+      response_format: { type: "json_object" },
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: message }
+      ]
+    });
+    const content = response.choices[0]?.message?.content || "{}";
+    const raw = JSON.parse(content);
+    const validFlowIds = new Set(flows.keys());
+    const intent = validFlowIds.has(raw.intent) ? raw.intent : "chatbot";
+    const confidence = typeof raw.confidence === "number" ? raw.confidence : 0;
+    return { intent, confidence, reasoning: raw.reasoning };
+  } catch (error) {
+    console.warn(
+      `[flows] intent detection failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return { intent: "chatbot", confidence: 0, reasoning: "exception, defaulting to chatbot" };
+  }
+}
+
+// src/flows/loader.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+var SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set(["lib", "tests", "registry"]);
+async function loadFlowsFromDirectory(flowsDir) {
+  const flows = /* @__PURE__ */ new Map();
+  if (!existsSync(flowsDir)) {
+    console.warn(`[flows] directory does not exist: ${flowsDir}`);
+    return flows;
+  }
+  const flowDirs = readdirSync(flowsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).filter((dirent) => !SKIPPED_DIR_NAMES.has(dirent.name)).map((dirent) => dirent.name);
+  for (const flowName of flowDirs) {
+    try {
+      flows.set(flowName, await loadFlow(flowsDir, flowName));
+    } catch (error) {
+      console.warn(
+        `[flows] failed to load "${flowName}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return flows;
+}
+async function loadFlow(flowsDir, flowName) {
+  const flowPath = resolve(flowsDir, flowName);
+  const definitionPath = join(flowPath, "flow.json");
+  const instructionsPath = join(flowPath, "instructions.md");
+  const handlerPath = join(flowPath, "handler.ts");
+  if (!existsSync(definitionPath)) {
+    throw new Error(`flow.json not found for ${flowName}`);
+  }
+  if (!existsSync(instructionsPath)) {
+    throw new Error(`instructions.md not found for ${flowName}`);
+  }
+  if (!existsSync(handlerPath)) {
+    throw new Error(`handler.ts not found for ${flowName}`);
+  }
+  const definition = JSON.parse(readFileSync(definitionPath, "utf-8"));
+  if (definition.id !== flowName) {
+    throw new Error(`Flow id mismatch: ${definition.id} !== ${flowName}`);
+  }
+  if (!definition.triggerKeywords || definition.triggerKeywords.length === 0) {
+    throw new Error(`Flow ${flowName} has no trigger keywords`);
+  }
+  if (!definition.schema || Object.keys(definition.schema.properties ?? {}).length === 0) {
+    throw new Error(`Flow ${flowName} has no schema`);
+  }
+  const handlerModule = await import(handlerPath);
+  const handler = handlerModule.execute;
+  if (typeof handler !== "function") {
+    throw new Error(`Flow ${flowName} handler.ts must export an 'execute' function`);
+  }
+  const prefillPath = join(flowPath, "prefill.ts");
+  let prefill;
+  if (existsSync(prefillPath)) {
+    const prefillModule = await import(prefillPath);
+    if (typeof prefillModule.prefillFromContext === "function") {
+      prefill = prefillModule.prefillFromContext;
+    } else {
+      console.warn(
+        `[flows] "${flowName}" prefill.ts does not export a prefillFromContext function`
+      );
+    }
+  }
+  return { definition, handler, instructionsPath, prefill };
+}
+
+// src/flows/params.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+function isMissing(value) {
+  return value === void 0 || value === null;
+}
+async function extractParameters(client, model, flow, message, existingParams, now = Date.now) {
+  const instructions = readFileSync2(flow.instructionsPath, "utf-8");
+  const schema = flow.definition.schema;
+  const properties = schema.properties || {};
+  const required = schema.required || [];
+  const schemaDescription = Object.entries(properties).map(
+    ([key, field]) => `- ${key} (${field.type}${required.includes(key) ? ", required" : ""}): ${field.description || ""}`
+  ).join("\n");
+  const existingParamsStr = Object.keys(existingParams).length > 0 ? `
+
+Already collected:
+${JSON.stringify(existingParams, null, 2)}` : "";
+  const missingFields = required.filter((key) => isMissing(existingParams[key]));
+  const currentlyAsking = missingFields.length > 0 ? missingFields[0] : null;
+  const nowDate = new Date(now());
+  const todayStr = nowDate.toISOString().split("T")[0];
+  const currentYear = nowDate.getFullYear();
+  const currentMonth = nowDate.getMonth() + 1;
+  const nextYear = currentYear + 1;
+  const tomorrow = new Date(nowDate);
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  const tomorrowStr = tomorrow.toISOString().split("T")[0];
+  const dateContext = `
+
+## CRITICAL DATE CONTEXT
+TODAY IS: ${todayStr} (year ${currentYear}, month ${currentMonth})
+
+**DATE EXTRACTION RULES:**
+- "tomorrow" = ${tomorrowStr}
+- Months 1-${currentMonth} = year ${nextYear}
+- Months ${currentMonth + 1}-12 = year ${currentYear}
+- NEVER output a date before ${todayStr}`;
+  const currentFieldHint = currentlyAsking ? `
+
+## IMPORTANT CONTEXT
+We just asked the user for: "${currentlyAsking}"
+If the user's response is a simple value, interpret it as the value for the "${currentlyAsking}" parameter.` : "";
+  const systemPrompt = `${instructions}
+${dateContext}
+
+## Schema
+${schemaDescription}
+${existingParamsStr}
+${currentFieldHint}
+
+## Task
+Extract any parameters from the user's message that match the schema above.
+Return JSON with:
+- "extractedParams": object with any NEW parameters found
+
+Do not compute "allParamsFilled" - the caller recomputes it from the merged params.`;
+  const response = await client.chat.completions.create({
+    model,
+    temperature: 0.2,
+    response_format: { type: "json_object" },
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: message }
+    ]
+  });
+  const content = response.choices[0]?.message?.content || "{}";
+  const result = JSON.parse(content);
+  const extractedParams = Object.fromEntries(
+    Object.entries(result.extractedParams || {}).filter(([, value]) => !isMissing(value))
+  );
+  const mergedParams = { ...existingParams, ...extractedParams };
+  const allParamsFilled = required.every((key) => !isMissing(mergedParams[key]));
+  let nextPrompt;
+  if (!allParamsFilled) {
+    const missingKey = required.find((key) => isMissing(mergedParams[key]));
+    if (missingKey) {
+      nextPrompt = `What is the ${missingKey.replace(/([A-Z])/g, " $1").toLowerCase()}?`;
+    }
+  }
+  return { extractedParams, allParamsFilled, nextPrompt };
+}
+
+// src/flows/registry.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+function createFlowRegistry(flows, criticalKeywords = {}) {
+  const keywordEntries = Object.entries(criticalKeywords);
+  return {
+    getFlow(id) {
+      return flows.get(id);
+    },
+    getAllFlows() {
+      return Array.from(flows.values());
+    },
+    getInstructions(id) {
+      const flow = flows.get(id);
+      if (!flow) {
+        throw new Error(`Flow ${id} not found`);
+      }
+      return readFileSync3(flow.instructionsPath, "utf-8");
+    },
+    matchByKeyword(message) {
+      const lowerMessage = message.toLowerCase();
+      for (const [keyword, flowId] of keywordEntries) {
+        if (lowerMessage.includes(keyword.toLowerCase())) {
+          const flow = flows.get(flowId);
+          if (flow) return flow;
+        }
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/flows/utils.ts
+var DEFAULT_CANCEL_KEYWORDS = ["cancel", "nevermind", "never mind", "stop", "forget it", "quit"];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function containsWholePhrase(message, phrase) {
+  return new RegExp(`(^|\\W)${escapeRegExp(phrase)}($|\\W)`, "i").test(message);
+}
+function shouldExitFlow(message, cancelKeywords = DEFAULT_CANCEL_KEYWORDS) {
+  return cancelKeywords.some((keyword) => containsWholePhrase(message, keyword));
+}
+
+// src/flows/engine.ts
+var DEFAULT_MIN_CONFIDENCE = 0.7;
+var DEFAULT_CANCEL_MESSAGE = "Okay, cancelled.";
+var DEFAULT_ERROR_MESSAGE = "Sorry, something went wrong. Please try again.";
+function createFlowEngine(options) {
+  const {
+    client,
+    model,
+    flowsDir,
+    sessionStore,
+    criticalKeywords,
+    minConfidence = DEFAULT_MIN_CONFIDENCE,
+    cancelKeywords,
+    cancelMessage = DEFAULT_CANCEL_MESSAGE,
+    errorMessage = DEFAULT_ERROR_MESSAGE,
+    sessionTtlMs,
+    now = Date.now
+  } = options;
+  let registry = createFlowRegistry(/* @__PURE__ */ new Map());
+  async function matchFlow(message, conversationContext) {
+    const byKeyword = registry.matchByKeyword(message);
+    if (byKeyword) return byKeyword;
+    const allFlows = registry.getAllFlows();
+    if (allFlows.length === 0) return void 0;
+    const flowMap = new Map(allFlows.map((flow) => [flow.definition.id, flow]));
+    const detection = await detectIntent(client, model, message, flowMap, conversationContext);
+    if (detection.confidence >= minConfidence) {
+      return registry.getFlow(detection.intent);
+    }
+    return void 0;
+  }
+  async function runToCompletionOrPrompt(flow, sessionKey, message, existingParams, attempts, startedAt, channel) {
+    const extraction = await extractParameters(client, model, flow, message, existingParams, now);
+    const mergedParams = { ...existingParams, ...extraction.extractedParams };
+    if (extraction.allParamsFilled) {
+      const result = await flow.handler(mergedParams, { sessionKey, channel });
+      await sessionStore.clear(sessionKey);
+      return {
+        isFlowActive: false,
+        message: result.message,
+        flowCompleted: true,
+        flowSuccess: result.success,
+        result: result.result
+      };
+    }
+    await sessionStore.set(sessionKey, {
+      flowId: flow.definition.id,
+      params: mergedParams,
+      attempts: attempts + 1,
+      startedAt
+    });
+    return {
+      isFlowActive: true,
+      message: extraction.nextPrompt || "Could you provide more details?",
+      flowCompleted: false
+    };
+  }
+  return {
+    async loadFlows() {
+      const flows = await loadFlowsFromDirectory(flowsDir);
+      registry = createFlowRegistry(flows, criticalKeywords);
+    },
+    getFlow(id) {
+      return registry.getFlow(id);
+    },
+    getAllFlows() {
+      return registry.getAllFlows();
+    },
+    async process(sessionKey, message, processOptions) {
+      const channel = processOptions?.channel;
+      let activeSession = await sessionStore.get(sessionKey);
+      if (activeSession && sessionTtlMs !== void 0 && now() - activeSession.startedAt > sessionTtlMs) {
+        await sessionStore.clear(sessionKey);
+        activeSession = null;
+      }
+      if (activeSession && shouldExitFlow(message, cancelKeywords)) {
+        await sessionStore.clear(sessionKey);
+        return {
+          isFlowActive: false,
+          message: cancelMessage,
+          flowCompleted: false,
+          cancelled: true
+        };
+      }
+      if (activeSession) {
+        const flow = registry.getFlow(activeSession.flowId);
+        if (!flow) {
+          await sessionStore.clear(sessionKey);
+          return { isFlowActive: false, message: errorMessage, flowCompleted: false, error: true };
+        }
+        try {
+          return await runToCompletionOrPrompt(
+            flow,
+            sessionKey,
+            message,
+            activeSession.params,
+            activeSession.attempts,
+            activeSession.startedAt,
+            channel
+          );
+        } catch {
+          return { isFlowActive: true, message: errorMessage, flowCompleted: false, error: true };
+        }
+      }
+      const matched = await matchFlow(message, processOptions?.conversationContext);
+      if (!matched) {
+        return { isFlowActive: false, message: "", flowCompleted: false };
+      }
+      try {
+        const globalParams = matched.prefill ? matched.prefill(sessionKey, processOptions?.prefillContext ?? {}) : {};
+        return await runToCompletionOrPrompt(
+          matched,
+          sessionKey,
+          message,
+          globalParams,
+          0,
+          now(),
+          channel
+        );
+      } catch {
+        return { isFlowActive: false, message: errorMessage, flowCompleted: false, error: true };
+      }
+    }
+  };
+}
+
+// src/flows/session.ts
+var schemaReady = /* @__PURE__ */ new WeakMap();
+function ensureSessionSchema(client, tableName) {
+  let perTable = schemaReady.get(client);
+  if (!perTable) {
+    perTable = /* @__PURE__ */ new Map();
+    schemaReady.set(client, perTable);
+  }
+  const tables = perTable;
+  let ready = tables.get(tableName);
+  if (!ready) {
+    ready = client.execute(
+      `CREATE TABLE IF NOT EXISTS ${tableName} (
+          session_key TEXT PRIMARY KEY,
+          flow_id TEXT NOT NULL,
+          params TEXT NOT NULL,
+          attempts INTEGER NOT NULL,
+          started_at INTEGER NOT NULL
+        )`
+    ).catch((error) => {
+      tables.delete(tableName);
+      throw error;
+    });
+    tables.set(tableName, ready);
+  }
+  return ready;
+}
+var VALID_TABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function createTursoFlowSessionStore(client, tableName = "flow_sessions") {
+  if (!VALID_TABLE_NAME.test(tableName)) {
+    throw new Error(`Invalid flow session store table name: ${tableName}`);
+  }
+  return {
+    async get(sessionKey) {
+      await ensureSessionSchema(client, tableName);
+      const result = await client.execute({
+        sql: `SELECT flow_id, params, attempts, started_at FROM ${tableName} WHERE session_key = ?`,
+        args: [sessionKey]
+      });
+      const row = result.rows[0];
+      if (!row) return null;
+      return {
+        flowId: String(row.flow_id),
+        params: JSON.parse(String(row.params)),
+        attempts: Number(row.attempts),
+        startedAt: Number(row.started_at)
+      };
+    },
+    async set(sessionKey, state) {
+      await ensureSessionSchema(client, tableName);
+      await client.execute({
+        sql: `INSERT INTO ${tableName} (session_key, flow_id, params, attempts, started_at) VALUES (?, ?, ?, ?, ?)
+              ON CONFLICT(session_key) DO UPDATE SET flow_id = excluded.flow_id, params = excluded.params, attempts = excluded.attempts, started_at = excluded.started_at`,
+        args: [
+          sessionKey,
+          state.flowId,
+          JSON.stringify(state.params),
+          state.attempts,
+          state.startedAt
+        ]
+      });
+    },
+    async clear(sessionKey) {
+      await ensureSessionSchema(client, tableName);
+      await client.execute({
+        sql: `DELETE FROM ${tableName} WHERE session_key = ?`,
+        args: [sessionKey]
+      });
+    }
+  };
+}
+export {
+  createFlowEngine,
+  createFlowRegistry,
+  createTursoFlowSessionStore,
+  detectIntent,
+  extractParameters,
+  loadFlowsFromDirectory,
+  shouldExitFlow
+};

package/dist/flows/intent.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LLM-powered intent detection — classifies a message into a flow id, or the
+ * `chatbot` fallback, using the caller's OpenAI client (never a raw fetch, so
+ * the same client tests already fake for chat completions covers this too).
+ */
+import type OpenAI from "openai";
+import type { IntentDetection, LoadedFlow } from "./types";
+/** Detects which loaded flow (if any) a message expresses intent for. */
+export declare function detectIntent(client: OpenAI, model: string, message: string, flows: Map<string, LoadedFlow>, conversationContext?: string[]): Promise<IntentDetection>;
+//# sourceMappingURL=intent.d.ts.map

package/dist/flows/intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../src/flows/intent.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE3D,yEAAyE;AACzE,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAC9B,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAC7B,OAAO,CAAC,eAAe,CAAC,CAyD1B"}

package/dist/flows/intent.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Intent detection tests — a faked OpenAI client (see src/routes/openai.test.ts
+ * for the same pattern), never a real API call.
+ */
+export {};
+//# sourceMappingURL=intent.test.d.ts.map

package/dist/flows/intent.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.test.d.ts","sourceRoot":"","sources":["../../src/flows/intent.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/flows/loader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Directory-based flow loader.
+ *
+ * Discovers flow directories on disk and loads each one's contract. Kept
+ * byte-for-byte compatible with the reference implementation's on-disk
+ * shape, so existing flow directories load unchanged.
+ */
+import type { LoadedFlow } from "./types";
+/** Loads every flow directory under `flowsDir`. A flow that fails to load is skipped, not fatal to the rest. */
+export declare function loadFlowsFromDirectory(flowsDir: string): Promise<Map<string, LoadedFlow>>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/flows/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/flows/loader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAA4C,UAAU,EAAE,MAAM,SAAS,CAAC;AAIpF,gHAAgH;AAChH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAwB/F"}

package/dist/flows/loader.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Loader tests — verifies flow directories load per the reference
+ * implementation's on-disk contract (flow.json/handler.ts/instructions.md,
+ * optional prefill.ts), and that a malformed directory is skipped rather
+ * than failing the whole load.
+ */
+export {};
+//# sourceMappingURL=loader.test.d.ts.map

package/dist/flows/loader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.test.d.ts","sourceRoot":"","sources":["../../src/flows/loader.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/flows/params.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Schema-driven parameter extraction — pulls structured params out of a
+ * message using the flow's `instructions.md` and JSON schema, across as many
+ * turns as it takes to fill every required field.
+ */
+import type OpenAI from "openai";
+import type { FlowExtractionResult, LoadedFlow } from "./types";
+/**
+ * Extracts (and merges) params from `message` against `flow`'s schema.
+ *
+ * `now` is injectable so date-relative prompt context ("tomorrow") is
+ * deterministic in tests; defaults to the real clock.
+ */
+export declare function extractParameters(client: OpenAI, model: string, flow: LoadedFlow, message: string, existingParams: Record<string, unknown>, now?: () => number): Promise<FlowExtractionResult>;
+//# sourceMappingURL=params.d.ts.map

package/dist/flows/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/flows/params.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAOhE;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,GAAG,GAAE,MAAM,MAAiB,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CA6F/B"}

package/dist/flows/params.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=params.test.d.ts.map

package/dist/flows/params.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.test.d.ts","sourceRoot":"","sources":["../../src/flows/params.test.ts"],"names":[],"mappings":""}

package/dist/flows/registry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Flow registry — lookup and the pure (non-LLM) half of matching.
+ *
+ * Framework-free: holds loaded flows and answers keyword lookups
+ * synchronously. LLM-based intent matching lives in `./intent` and is
+ * orchestrated by `./engine`, which is what decides whether the keyword step
+ * or the LLM step wins.
+ */
+import type { LoadedFlow } from "./types";
+export interface FlowRegistry {
+    getFlow(id: string): LoadedFlow | undefined;
+    getAllFlows(): LoadedFlow[];
+    getInstructions(id: string): string;
+    /**
+     * Immediate, deterministic trigger: the first configured keyword found in
+     * `message` (case-insensitive substring match) wins over LLM intent
+     * detection. Empty/unset `criticalKeywords` disables this step entirely.
+     */
+    matchByKeyword(message: string): LoadedFlow | undefined;
+}
+export declare function createFlowRegistry(flows: Map<string, LoadedFlow>, criticalKeywords?: Record<string, string>): FlowRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/flows/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/flows/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;IAC5C,WAAW,IAAI,UAAU,EAAE,CAAC;IAC5B,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;CACzD;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAC9B,gBAAgB,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAC5C,YAAY,CA4Bd"}

package/dist/flows/registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registry.test.d.ts.map

package/dist/flows/registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.test.d.ts","sourceRoot":"","sources":["../../src/flows/registry.test.ts"],"names":[],"mappings":""}

package/dist/flows/session.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turso/libsql-backed {@link FlowSessionStore}.
+ *
+ * Session state lives in the database rather than process memory because
+ * deployments run multiple instances — the instance that handles turn 2 of a
+ * multi-turn flow is not guaranteed to be the one that handled turn 1.
+ *
+ * `@libsql/client` is imported for its type alone, so this module adds no
+ * runtime dependency to anyone importing `./flows` for the pure engine.
+ */
+import type { Client } from "@libsql/client";
+import type { FlowSessionStore } from "./types";
+/** Creates a session store keyed by an arbitrary session id (phone number, WhatsApp JID, web session id) on `tableName`. */
+export declare function createTursoFlowSessionStore(client: Client, tableName?: string): FlowSessionStore;
+//# sourceMappingURL=session.d.ts.map

package/dist/flows/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/flows/session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAyClE,4HAA4H;AAC5H,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,SAAS,SAAkB,GAC1B,gBAAgB,CA6ClB"}

package/dist/flows/session.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Turso flow session store tests — run against a real in-memory libsql
+ * client, since what's worth proving here is the SQL: upsert-on-conflict
+ * behaves as an upsert, and table creation is idempotent.
+ */
+export {};
+//# sourceMappingURL=session.test.d.ts.map

package/dist/flows/session.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.test.d.ts","sourceRoot":"","sources":["../../src/flows/session.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}