@frankieai/server 0.2.4 → 0.2.6

package/dist/{chunk-7J5Z5MIK.js → chunk-WEHJH4FL.js}

@@ -26,7 +26,10 @@ var TokenService = class {
     const options = {
       ...this.auth.jwtIssuer ? { issuer: this.auth.jwtIssuer } : {},
       ...this.auth.jwtAudience ? { audience: this.auth.jwtAudience } : {},
-      clockTolerance: 30
+      clockTolerance: 30,
+      // A token with no expiry would be valid forever once leaked. Every
+      // token endpoint Frankie generates or documents sets one.
+      requiredClaims: ["exp"]
     };
     let payload;
     try {
@@ -193,9 +196,26 @@ var MemoryRateLimiter = class {
     }
   }
 };
+function clientIp(header, trustedHops = trustedProxyHops()) {
+  const forwarded = header("x-forwarded-for");
+  if (forwarded && trustedHops > 0) {
+    const hops = forwarded.split(",").map((entry2) => entry2.trim()).filter(Boolean);
+    const entry = hops[Math.max(0, hops.length - trustedHops)];
+    if (entry) return entry;
+  }
+  return header("cf-connecting-ip") ?? header("x-real-ip") ?? "unknown";
+}
+function trustedProxyHops() {
+  const value = Number(process.env.FRANKIE_TRUSTED_PROXY_HOPS ?? 1);
+  return Number.isInteger(value) && value >= 0 && value <= 10 ? value : 1;
+}
 
 // src/sessions.ts
 import { randomUUID } from "crypto";
+function isTurnRunning(session, leaseMs, now = Date.now()) {
+  if (!session.busy) return false;
+  return now - (session.busySince ?? session.lastActiveAt) < leaseMs;
+}
 var MemorySessionStore = class {
   constructor(ttlMs = 6 * 60 * 60 * 1e3) {
     this.ttlMs = ttlMs;
@@ -249,6 +269,7 @@ function newSessionId() {
 }
 
 // src/tenants.ts
+import { resolvePersonaConfig } from "@frankieai/core";
 var TenantRegistry = class _TenantRegistry {
   constructor(store) {
     this.store = store;
@@ -300,7 +321,14 @@ var SingleTenantStore = class {
   }
   resolved;
   async byPublishableKey(key) {
-    return safeEqual(key, this.resolved.config.auth.publishableKey) ? this.resolved : null;
+    const base = this.resolved.config;
+    if (safeEqual(key, base.auth.publishableKey)) return this.resolved;
+    for (const persona of base.personas) {
+      if (!safeEqual(key, persona.publishableKey)) continue;
+      const config = resolvePersonaConfig(base, persona.publishableKey);
+      return config ? { ...this.resolved, config } : null;
+    }
+    return null;
   }
 };
 var MemoryTenantStore = class {
@@ -308,12 +336,17 @@ var MemoryTenantStore = class {
   constructor(tenants = []) {
     for (const tenant of tenants) this.add(tenant);
   }
-  /** Register (or replace) a tenant. Its publishable key is its lookup key. */
+  /** Register (or replace) a tenant, under its base key and each persona's key. */
   add(resolved) {
     this.byKey.set(resolved.config.auth.publishableKey, resolved);
+    for (const persona of resolved.config.personas) this.byKey.set(persona.publishableKey, resolved);
   }
   async byPublishableKey(key) {
-    return this.byKey.get(key) ?? null;
+    const resolved = this.byKey.get(key);
+    if (!resolved) return null;
+    const config = resolvePersonaConfig(resolved.config, key);
+    if (!config) return null;
+    return config === resolved.config ? resolved : { ...resolved, config };
   }
 };
 
@@ -456,7 +489,8 @@ async function inspectApiCapabilities(source, options = {}) {
       if (options.policy && !evaluateToolPolicy(toolName, options.policy).allowed) continue;
       const summary = typeof operation["summary"] === "string" ? operation["summary"] : void 0;
       const authGap = httpMethod !== "GET" && effectiveSecurity(doc, operation).length > 0 && !hasPerUserAuth;
-      capabilities.push({ operationId, method: httpMethod, path, ...summary ? { summary } : {}, authGap });
+      const inputs = describeInputs(doc, collectParameters(doc, item, operation), collectRequestBody(doc, operation));
+      capabilities.push({ operationId, method: httpMethod, path, ...summary ? { summary } : {}, ...inputs ? { inputs } : {}, authGap });
     }
   }
   return capabilities;
@@ -537,6 +571,11 @@ ${retrySafetyNote(method, doc, item, operation)}`,
               `"${operationId}" runs in the user's browser and has no server base URL, so it can't run over the hosted MCP endpoint or a headless caller. Set a baseUrl (and a user-token forwarding header) to expose it that way too. Report this to the user.`
             );
           }
+          if (!READ_METHODS.has(method.toUpperCase()) && options.session?.user.anonymous && !options.session.userToken) {
+            throw new Error(
+              `"${operationId}" changes data, and this visitor isn't signed in, so it can't run. Tell the user to sign in first, or offer to hand the request to the team.`
+            );
+          }
           const input = enforceIdentityParams(params, isRecord(args) ? args : {}, options.session);
           enforceResourceScope(scopeRules, input, options.session);
           const url = buildUrl(opBaseUrl, path, params, input, securityQuery);
@@ -652,7 +691,7 @@ function collectParameters(doc, item, operation) {
     const location = resolved["in"];
     if (typeof name !== "string") continue;
     if (location !== "path" && location !== "query") continue;
-    const schema = resolveRef(doc, resolved["schema"]);
+    const schema = inlineSchema(doc, resolved["schema"]);
     params.push({
       name,
       location,
@@ -670,9 +709,108 @@ function collectRequestBody(doc, operation) {
   if (!isRecord(content)) return void 0;
   const json = content["application/json"];
   if (!isRecord(json)) return void 0;
-  const schema = resolveRef(doc, json["schema"]);
+  const schema = inlineSchema(doc, json["schema"]);
   return isRecord(schema) ? schema : void 0;
 }
+var INPUT_DESCRIPTION_CHARS = 100;
+var INPUTS_LINE_CHARS = 900;
+var NESTED_FIELDS = 8;
+function describeInputs(doc, params, body) {
+  const entries = [];
+  for (const param of params) {
+    entries.push(describeInput(doc, param.name, param.required, { ...param.schema, ...param.description ? { description: param.description } : {} }));
+  }
+  entries.push(...describeProperties(doc, body));
+  if (entries.length === 0) return void 0;
+  const line = entries.join("; ");
+  return line.length > INPUTS_LINE_CHARS ? `${line.slice(0, INPUTS_LINE_CHARS - 1)}\u2026` : line;
+}
+function describeSchemaInputs(schema) {
+  const entries = describeProperties({}, isRecord(schema) ? schema : void 0);
+  if (entries.length === 0) return void 0;
+  const line = entries.join("; ");
+  return line.length > INPUTS_LINE_CHARS ? `${line.slice(0, INPUTS_LINE_CHARS - 1)}\u2026` : line;
+}
+function describeProperties(doc, schema) {
+  const properties = schema?.["properties"];
+  if (!isRecord(properties)) return [];
+  const required = new Set(Array.isArray(schema?.["required"]) ? schema["required"].map(String) : []);
+  const entries = [];
+  for (const [name, child] of Object.entries(properties)) {
+    const resolved = resolveRef(doc, child);
+    if (isRecord(resolved) && resolved["readOnly"] === true) continue;
+    entries.push(describeInput(doc, name, required.has(name), isRecord(resolved) ? resolved : {}));
+  }
+  return entries;
+}
+function describeInput(doc, name, required, schema) {
+  const detail = [];
+  const description = typeof schema["description"] === "string" ? schema["description"].replace(/\s+/g, " ").trim() : "";
+  if (description) detail.push(clip(description, INPUT_DESCRIPTION_CHARS));
+  const allowed = Array.isArray(schema["enum"]) ? schema["enum"] : void 0;
+  const type = typeof schema["type"] === "string" ? schema["type"] : void 0;
+  const items = isRecord(schema["items"]) ? resolveRef(doc, schema["items"]) : void 0;
+  const nested = nestedFields(doc, type === "array" && isRecord(items) ? items : schema);
+  if (allowed?.length) detail.push(`one of ${allowed.map(String).join(", ")}`);
+  else if (nested) detail.push(type === "array" ? `list of {${nested}}` : `{${nested}}`);
+  else if (!description) {
+    const itemType = isRecord(items) && typeof items["type"] === "string" ? items["type"] : void 0;
+    if (type) detail.push(type === "array" && itemType ? `list of ${itemType}` : type);
+  }
+  if (typeof schema["format"] === "string" && !allowed) detail.push(`format ${schema["format"]}`);
+  const range = rangeOf(schema, type);
+  if (range) detail.push(range);
+  if (schema["default"] !== void 0 && typeof schema["default"] !== "object") detail.push(`default ${String(schema["default"])}`);
+  const example = schema["example"] ?? (Array.isArray(schema["examples"]) ? schema["examples"][0] : void 0);
+  if (example !== void 0 && typeof example !== "object" && !allowed) detail.push(`e.g. ${clip(String(example), 40)}`);
+  return `${name}${required ? " (required)" : ""}${detail.length ? `: ${detail.join(", ")}` : ""}`;
+}
+function nestedFields(doc, schema) {
+  const properties = schema["properties"];
+  if (!isRecord(properties)) return void 0;
+  const required = new Set(Array.isArray(schema["required"]) ? schema["required"].map(String) : []);
+  const names = Object.entries(properties).filter(([, child]) => !(isRecord(resolveRef(doc, child)) && resolveRef(doc, child)["readOnly"] === true)).map(([field]) => field + (required.has(field) ? " (required)" : ""));
+  if (names.length === 0) return void 0;
+  return names.slice(0, NESTED_FIELDS).join(", ") + (names.length > NESTED_FIELDS ? ", \u2026" : "");
+}
+function rangeOf(schema, type) {
+  const bounds = (min, max, unit) => {
+    const lo = typeof min === "number" ? min : void 0;
+    const hi = typeof max === "number" ? max : void 0;
+    if (lo === void 0 && hi === void 0) return void 0;
+    if (lo !== void 0 && hi !== void 0) return `${lo}\u2013${hi}${unit}`;
+    return lo !== void 0 ? `at least ${lo}${unit}` : `at most ${hi}${unit}`;
+  };
+  if (type === "string") return bounds(schema["minLength"], schema["maxLength"], " characters");
+  if (type === "array") return bounds(schema["minItems"], schema["maxItems"], " items");
+  if (type === "number" || type === "integer") return bounds(schema["minimum"], schema["maximum"], "");
+  return void 0;
+}
+function clip(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+var SCHEMA_DATA_KEYWORDS = /* @__PURE__ */ new Set(["enum", "const", "default", "example", "examples"]);
+function inlineSchema(doc, node, trail = []) {
+  if (Array.isArray(node)) return node.map((entry) => inlineSchema(doc, entry, trail));
+  if (!isRecord(node)) return node;
+  const ref = node["$ref"];
+  if (typeof ref === "string") {
+    if (!ref.startsWith("#/") || trail.includes(ref) || trail.length > 32) return {};
+    const target = resolveRef(doc, node);
+    return isRecord(target) ? inlineSchema(doc, target, [...trail, ref]) : {};
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    out[key] = SCHEMA_DATA_KEYWORDS.has(key) ? value : inlineSchema(doc, value, trail);
+  }
+  if (out["nullable"] === true) {
+    delete out["nullable"];
+    const type = out["type"];
+    if (typeof type === "string" && type !== "null") out["type"] = [type, "null"];
+    else if (Array.isArray(type) && !type.includes("null")) out["type"] = [...type, "null"];
+  }
+  return out;
+}
 function toolSchema(params, body) {
   const properties = {};
   const required = [];
@@ -691,12 +829,17 @@ function toolSchema(params, body) {
     additionalProperties: false
   };
 }
+function encodePathParam(name, value) {
+  const raw = String(value ?? "");
+  if (raw === "." || raw === "..") throw new Error(`"${raw}" isn't a valid value for the path parameter "${name}".`);
+  return encodeURIComponent(raw);
+}
+var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
 function buildUrl(baseUrl, path, params, input, extraQuery = {}) {
   let resolved = path;
   for (const param of params) {
     if (param.location !== "path") continue;
-    const value = input[param.name];
-    resolved = resolved.replace(`{${param.name}}`, encodeURIComponent(String(value ?? "")));
+    resolved = resolved.replace(`{${param.name}}`, encodePathParam(param.name, input[param.name]));
   }
   const url = new URL(`${baseUrl}${resolved.startsWith("/") ? "" : "/"}${resolved}`);
   for (const [name, value] of Object.entries(extraQuery)) url.searchParams.set(name, value);
@@ -716,7 +859,7 @@ function buildRelativePath(path, params, input) {
   let resolved = path;
   for (const param of params) {
     if (param.location !== "path") continue;
-    resolved = resolved.replace(`{${param.name}}`, encodeURIComponent(String(input[param.name] ?? "")));
+    resolved = resolved.replace(`{${param.name}}`, encodePathParam(param.name, input[param.name]));
   }
   const query = new URLSearchParams();
   for (const param of params) {
@@ -1237,6 +1380,161 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 
+// src/agent/knowledge-tools.ts
+import { Type as Type4 } from "@earendil-works/pi-ai";
+
+// src/agent/embeddings.ts
+var DEFAULT_EMBEDDING_MODEL = "nomic-ai/nomic-embed-text-v1.5";
+var DEFAULT_BASE_URL = "https://api.fireworks.ai/inference/v1";
+function resolveEmbeddingConfig(config, apiKey) {
+  const base = (config.model.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  return { endpoint: base + "/embeddings", apiKey, model: DEFAULT_EMBEDDING_MODEL };
+}
+async function embedTexts(texts, config, fetchImpl = fetch, batchSize = 64) {
+  const out = [];
+  for (let i = 0; i < texts.length; i += batchSize) {
+    const batch = texts.slice(i, i + batchSize);
+    const response = await fetchImpl(config.endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${config.apiKey}` },
+      body: JSON.stringify({ model: config.model, input: batch }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const detail = await response.text().catch(() => "");
+      throw new Error(`Embedding request failed (HTTP ${response.status})${detail ? ": " + detail.slice(0, 200) : ""}`);
+    }
+    const body = await response.json();
+    const vectors = body.data ?? [];
+    if (vectors.length !== batch.length) throw new Error(`Embedding provider returned ${vectors.length} vectors for ${batch.length} inputs.`);
+    for (const entry of vectors) {
+      if (!Array.isArray(entry.embedding)) throw new Error("Embedding provider returned a malformed vector.");
+      out.push(entry.embedding);
+    }
+  }
+  return out;
+}
+function cosineSimilarity(a, b) {
+  const length = Math.min(a.length, b.length);
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+// src/agent/knowledge-tools.ts
+var KNOWLEDGE_TOOL_PREFIX = "frankie__docs__";
+function isKnowledgeTool(name) {
+  return name.startsWith(KNOWLEDGE_TOOL_PREFIX);
+}
+function buildKnowledgeTools(config, deps) {
+  if (!config.knowledgeBase.enabled || !deps) return [];
+  const embed = deps.embedImpl ?? embedTexts;
+  return [
+    {
+      name: KNOWLEDGE_TOOL_PREFIX + "search",
+      label: "Search the docs",
+      description: "Search the workspace's documentation for passages relevant to a question, and answer from what it returns. Always call this before answering a question that the docs would cover; prefer the returned passages over your own memory, cite the source URL, and if nothing relevant comes back, say you couldn't find it in the docs rather than guessing.",
+      parameters: Type4.Unsafe({
+        type: "object",
+        required: ["query"],
+        properties: {
+          query: { type: "string", description: "What to look up, in natural language." }
+        }
+      }),
+      async execute(_id, args) {
+        const query = String((typeof args === "object" && args !== null ? args["query"] : "") ?? "").trim();
+        if (!query) return { content: [{ type: "text", text: "Provide a search query." }], details: null };
+        let hits;
+        try {
+          const [vector] = await embed([query], deps.embedding);
+          hits = await deps.store.search(config.tenantId, vector ?? [], 6);
+        } catch (error) {
+          return { content: [{ type: "text", text: `The docs search is unavailable right now: ${error instanceof Error ? error.message : "unknown error"}. Tell the user you couldn't check the docs.` }], details: null };
+        }
+        const relevant = hits.filter((hit) => hit.score > 0.2);
+        if (relevant.length === 0) {
+          return { content: [{ type: "text", text: "No relevant passages found in the documentation. Tell the user you couldn't find this in the docs." }], details: null };
+        }
+        const rendered = relevant.map((hit, index) => `[${index + 1}] ${hit.title} \u2014 ${hit.url}
+${hit.text}`).join("\n\n---\n\n");
+        return {
+          content: [{ type: "text", text: `Relevant documentation passages (cite the source URL when you use one):
+
+${rendered}` }],
+          details: null
+        };
+      }
+    }
+  ];
+}
+
+// src/agent/escalation-tools.ts
+import { Type as Type5 } from "@earendil-works/pi-ai";
+var ESCALATION_TOOL_PREFIX = "frankie__escalate__";
+function isEscalationTool(name) {
+  return name.startsWith(ESCALATION_TOOL_PREFIX);
+}
+function newId() {
+  return "esc_" + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+}
+function buildEscalationTools(config, session, sink) {
+  if (!config.features.escalation.enabled) return [];
+  return [
+    {
+      name: ESCALATION_TOOL_PREFIX + "contact",
+      label: "Escalate to a person",
+      description: "Hand this conversation to the workspace's support team. Use it when you cannot fully resolve what the visitor needs, or when they ask to talk to a person. First ask for the visitor's email if you don't already have it, and write a short summary of what they need and what you already tried. This notifies the team; after calling it, tell the visitor a human will follow up. It grants no other access and returns no data from your systems.",
+      parameters: Type5.Unsafe({
+        type: "object",
+        required: ["summary", "reason"],
+        properties: {
+          summary: { type: "string", description: "A short recap of what the visitor needs and what you already tried." },
+          reason: { type: "string", description: `Why you're escalating (e.g. "visitor asked for a human", "outside my knowledge").` },
+          email: { type: "string", description: "The visitor's email, if they provided one." },
+          name: { type: "string", description: "The visitor's name, if they provided one." }
+        }
+      }),
+      async execute(_id, args) {
+        const record = typeof args === "object" && args !== null ? args : {};
+        const summary = String(record["summary"] ?? "").trim();
+        const reason = String(record["reason"] ?? "").trim();
+        if (!summary || !reason) {
+          return { content: [{ type: "text", text: "Provide both a summary and a reason before escalating." }], details: null };
+        }
+        const email = typeof record["email"] === "string" ? record["email"].trim() : "";
+        const name = typeof record["name"] === "string" ? record["name"].trim() : "";
+        const event = {
+          id: newId(),
+          at: Date.now(),
+          reason: reason.slice(0, 500),
+          summary: summary.slice(0, 2e3),
+          ...email ? { email: email.slice(0, 320) } : {},
+          ...name ? { name: name.slice(0, 120) } : {},
+          tenantId: config.tenantId,
+          conversationId: session.id,
+          userId: session.user.id
+        };
+        try {
+          await sink(event);
+        } catch {
+          return { content: [{ type: "text", text: "The team has been notified with your summary. A human will follow up." }], details: null };
+        }
+        return {
+          content: [{ type: "text", text: `Escalated to the team${email ? " (they'll reach out to " + email + ")" : ""}. Tell the visitor a person will follow up shortly.` }],
+          details: null
+        };
+      }
+    }
+  ];
+}
+
 // src/agent/tools.ts
 async function collectTools(options) {
   const { config, session } = options;
@@ -1271,7 +1569,9 @@ async function collectTools(options) {
     accountApiUrl,
     ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
   });
-  const tools = dedupe([...platform, ...mcp.tools, ...api.tools], options.onWarning);
+  const knowledge = buildKnowledgeTools(config, options.knowledge);
+  const escalation = options.onEscalation ? buildEscalationTools(config, session, options.onEscalation) : [];
+  const tools = dedupe([...platform, ...knowledge, ...escalation, ...mcp.tools, ...api.tools], options.onWarning);
   return {
     tools,
     failed: [...mcp.failed, ...api.failed],
@@ -1303,11 +1603,14 @@ function dedupe(tools, onWarning) {
 // src/host-mcp.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
 var PROTOCOL_VERSION = "2025-06-18";
 var SERVER_INFO = { name: "frankie-hosted-mcp", version: "0.1.0" };
+var MAX_MCP_BATCH = 20;
 function createMcpHostApp(options) {
   const registry = options.tenants instanceof TenantRegistry ? options.tenants : new TenantRegistry(options.tenants);
   const log = options.logger ?? ((event) => console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...event })));
+  const limiter = options.rateLimiter ?? new MemoryRateLimiter();
   const app = new Hono();
   app.get(
     "/:pk",
@@ -1315,6 +1618,7 @@ function createMcpHostApp(options) {
       allow: "POST"
     })
   );
+  app.use("/:pk", bodyLimit({ maxSize: 1024 * 1024, onError: (c) => c.json(rpcError(null, -32600, "Request too large."), 413) }));
   app.post("/:pk", async (c) => {
     const pk = c.req.param("pk");
     let tenant;
@@ -1339,6 +1643,14 @@ function createMcpHostApp(options) {
       return c.json(rpcError(null, -32700, "Parse error: request body must be JSON."), 200);
     }
     const requests = Array.isArray(payload) ? payload : [payload];
+    if (requests.length > MAX_MCP_BATCH) {
+      return c.json(rpcError(null, -32600, `Send at most ${MAX_MCP_BATCH} requests in one batch.`), 200);
+    }
+    const caller = session.user.anonymous ? "ip:" + clientIp((name) => c.req.header(name)) : "user:" + session.user.id;
+    const { messagesPerWindow, windowSeconds } = tenant.config.limits;
+    if (!await limiter.take(`mcp:${tenant.config.tenantId}:${caller}`, messagesPerWindow * 4, windowSeconds)) {
+      return c.json(rpcError(null, -32e3, "Too many requests. Try again shortly."), 429);
+    }
     const needsTools = requests.some((request) => isRecord3(request) && request["id"] !== void 0 && (request["method"] === "tools/list" || request["method"] === "tools/call"));
     const collected = needsTools ? await collectTools({
       config: { ...tenant.config, apis: tenant.config.apis.filter((api) => api.exposeAsMcp) },
@@ -1477,7 +1789,7 @@ function msg(error) {
 }
 
 // src/agent/prompt.ts
-import { activeSkills } from "@frankieai/core";
+import { activeSkills, SKILL_TOOL_NAME } from "@frankieai/core";
 function buildSystemPrompt(config, session, availableTools) {
   const sections = [];
   const configurationAssistant = config.features.configurationAssistant;
@@ -1511,6 +1823,15 @@ function buildSystemPrompt(config, session, availableTools) {
       "- If you need to think or plan before answering, put every word of that thinking inside",
       "  <think>\u2026</think> tags. Everything OUTSIDE those tags is shown to the user verbatim, so nothing",
       "  but the finished answer belongs there; the <think> block is removed and never reaches the user.",
+      "- Before calling a tool, every input it needs must come from the user or from an earlier tool result.",
+      "  Never invent a topic, name, identifier, date or other value the user has not given \u2014 ask one",
+      "  focused question for it instead. When a tool has optional inputs that would change the result",
+      "  (a difficulty, a format, a date range), offer them briefly rather than silently picking a default.",
+      "- When you create or update something, aim for a good result, not the smallest request the tool",
+      "  accepts: fill in the optional fields that make it complete (a description, a level, a length,",
+      "  sections), following the skill's quality bar when one applies. Draft that content from the",
+      "  conversation, ask for facts only the user knows, then show the complete proposal and confirm",
+      "  before saving.",
       "- If a tool call fails with an authentication or authorization error, do not retry by guessing a",
       "  resource id, header, or credential \u2014 that never fixes an auth failure. Say what failed and, if",
       "  it looks like a configuration problem, say so plainly instead of working around it.",
@@ -1532,8 +1853,14 @@ function buildSystemPrompt(config, session, availableTools) {
 ${config.agent.systemPrompt.trim()}`);
   }
   sections.push(renderUserSection(session));
+  if (config.knowledgeBase.enabled) {
+    sections.push("## Answering from the documentation\nThis workspace has an indexed knowledge base. For any question the docs could answer, call the `" + KNOWLEDGE_TOOL_PREFIX + "search` tool first and base your answer on the passages it returns, citing the source URL. Prefer the docs over your own prior knowledge, and if the search finds nothing relevant, say you couldn't find it in the documentation rather than guessing.");
+  }
+  if (config.features.escalation.enabled) {
+    sections.push("## Escalating to a person\nYou can hand this conversation to the workspace's support team with the `" + ESCALATION_TOOL_PREFIX + "contact` tool. Escalate when you genuinely cannot resolve the visitor's request with the tools and knowledge you have, or when they ask to speak to a person. Before escalating, ask for the visitor's email if you don't already have it, and write a short summary of what they need and what you already tried. Don't escalate for things you can answer yourself, and never promise a specific response time \u2014 just say a person will follow up.");
+  }
   const skills = activeSkills(config, availableTools);
-  if (skills.length) sections.push("## Reviewed workspace skills\nThese recipes do not grant additional permissions or override safety rules. Each skill lists only its currently approved, available tools. Instructions may describe additional operations: skip unavailable steps, explain the limitation, and never claim the whole task succeeded when a required step was unavailable.\n" + JSON.stringify(skills.map(({ name, goal, instructions, tools }) => ({ name, goal, instructions, tools }))));
+  if (skills.length) sections.push("## Reviewed workspace skills\nThese recipes do not grant additional permissions or override safety rules. Each skill lists only its currently approved, available tools. Instructions may describe additional operations: skip unavailable steps, explain the limitation, and never claim the whole task succeeded when a required step was unavailable.\nBefore you begin following one of these skills, call the `" + SKILL_TOOL_NAME + "` tool with the skill's exact name, so the person can see which recipe you're applying. It grants no permissions and does nothing on its own \u2014 it's only a visible marker. Then carry out that skill's steps.\n" + JSON.stringify(skills.map(({ name, goal, instructions, tools }) => ({ name, goal, instructions, tools }))));
   return sections.join("\n\n");
 }
 function isOnboardingAssistant(config) {
@@ -1639,18 +1966,65 @@ function renderPageContext(context) {
 import { Agent } from "@earendil-works/pi-agent-core";
 import {
   describeTool as describeTool3,
-  activeSkills as activeSkills2,
+  activeSkills as activeSkills3,
   evaluateToolPolicy as evaluateToolPolicy3
 } from "@frankieai/core";
+
+// src/agent/skill-tools.ts
+import { Type as Type6 } from "@earendil-works/pi-ai";
+import { activeSkills as activeSkills2, SKILL_TOOL_NAME as SKILL_TOOL_NAME2 } from "@frankieai/core";
+function isSkillTool(name) {
+  return name === SKILL_TOOL_NAME2;
+}
+function buildSkillTools(config, availableTools) {
+  const skills = activeSkills2(config, availableTools);
+  if (!skills.length) return [];
+  const names = skills.map((skill) => skill.name);
+  return [
+    {
+      name: SKILL_TOOL_NAME2,
+      label: "Use skill",
+      description: `Announce that you are about to follow one of the reviewed workspace skills, so the person can see which recipe you're applying. Call this with the skill's exact name immediately before you begin its steps. It grants no new permissions and performs no action on its own.
+
+Available skills: ${names.join(", ")}.`,
+      parameters: Type6.Unsafe({
+        type: "object",
+        required: ["skill"],
+        properties: { skill: { type: "string", description: "The exact name of the workspace skill you are about to follow." } }
+      }),
+      async execute(_id, args) {
+        const requested = String((typeof args === "object" && args !== null ? args["skill"] : "") ?? "").trim();
+        const match = skills.find((skill) => skill.name.toLowerCase() === requested.toLowerCase());
+        if (!match) {
+          return {
+            content: [{ type: "text", text: `No active skill is named "${requested}". The skills available this turn are: ${names.join(", ")}.` }],
+            details: null
+          };
+        }
+        return {
+          content: [{ type: "text", text: `Now following the "${match.name}" skill. Apply its steps using only its approved tools.` }],
+          details: null
+        };
+      }
+    }
+  ];
+}
+
+// src/agent/runner.ts
 async function* runTurn(params) {
   const { config, session } = params;
   const toolset = await collectTools({
     config,
     session,
     ...params.clientBridge ? { clientBridge: params.clientBridge } : {},
+    ...params.knowledge ? { knowledge: params.knowledge } : {},
+    ...params.onEscalation ? { onEscalation: params.onEscalation } : {},
     ...params.onWarning ? { onWarning: params.onWarning } : {}
   });
   const availableTools = toolset.tools.map((tool) => tool.name);
+  const skillTools = buildSkillTools(config, availableTools);
+  const agentTools = [...toolset.tools, ...skillTools];
+  const labels = new Map(agentTools.filter((tool) => tool.name.startsWith("frankie__")).map((tool) => [tool.name, tool.label]));
   const queue = new EventQueue();
   let turnCount = 0;
   let lastAssistant;
@@ -1662,7 +2036,7 @@ async function* runTurn(params) {
       systemPrompt: buildSystemPrompt(config, session, availableTools),
       model: params.modelOverride ?? params.model,
       thinkingLevel: config.model.thinkingLevel,
-      tools: toolset.tools,
+      tools: agentTools,
       messages: session.messages
     },
     // Per-request sampling lives here rather than on the agent: the stream
@@ -1686,7 +2060,7 @@ async function* runTurn(params) {
     // tools are exempt: they're gated by the workspaceAdmin flag, not the
     // allow/deny policy, so the policy would otherwise block them here.
     beforeToolCall: async ({ toolCall }) => {
-      if (isPlatformTool(toolCall.name)) return void 0;
+      if (isPlatformTool(toolCall.name) || isSkillTool(toolCall.name) || isKnowledgeTool(toolCall.name) || isEscalationTool(toolCall.name)) return void 0;
       const decision = evaluateToolPolicy3(toolCall.name, config.agent.tools);
       if (decision.allowed) return void 0;
       queue.push({
@@ -1701,7 +2075,7 @@ async function* runTurn(params) {
   });
   const stripper = new ReasoningStripper();
   const unsubscribe = agent.subscribe((event) => {
-    for (const mapped of mapEvent(event, config, stripper)) queue.push(mapped);
+    for (const mapped of mapEvent(event, config, stripper, labels)) queue.push(mapped);
     if (event.type === "message_end" && isAssistant(event.message)) {
       lastAssistant = event.message;
       usage.inputTokens += event.message.usage.input;
@@ -1728,7 +2102,7 @@ async function* runTurn(params) {
     });
   }).finally(() => queue.close());
   try {
-    yield { type: "skills_loaded", skills: activeSkills2(config, availableTools).map(({ id, name, revision }) => ({ id, name, revision })) };
+    yield { type: "skills_loaded", skills: activeSkills3(config, availableTools).map(({ id, name, revision }) => ({ id, name, revision })) };
     yield { type: "tools_active", apis: toolset.apis };
     for await (const event of queue) yield event;
     await run;
@@ -1747,7 +2121,7 @@ async function* runTurn(params) {
     await toolset.close();
   }
 }
-function* mapEvent(event, config, stripper) {
+function* mapEvent(event, config, stripper, labels) {
   switch (event.type) {
     case "message_start":
       if (isAssistant(event.message)) {
@@ -1777,7 +2151,7 @@ function* mapEvent(event, config, stripper) {
         type: "tool_start",
         toolUseId: event.toolCallId,
         name: event.toolName,
-        label: describeTool3(event.toolName, event.args),
+        label: labels.get(event.toolName) ?? describeTool3(event.toolName, event.args),
         input: config.agent.showToolActivity ? event.args : void 0
       };
       return;
@@ -1797,7 +2171,7 @@ function stopReasonFor(signal, turnCount, config, last) {
   if (signal.aborted) return "aborted";
   if (last?.stopReason === "error") return "error";
   if (last?.stopReason === "length") return "max_tokens";
-  if (turnCount >= config.agent.maxTurns) return "max_turns";
+  if (turnCount >= config.agent.maxTurns && last?.stopReason === "toolUse") return "max_turns";
   return "end_turn";
 }
 function isAssistant(message) {
@@ -1954,8 +2328,31 @@ var EventQueue = class {
 // src/app.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { Hono as Hono3 } from "hono";
+import { bodyLimit as bodyLimit2 } from "hono/body-limit";
 import { suggestedPromptsFromSkills } from "@frankieai/core";
 
+// src/knowledge.ts
+function rankChunks(chunks, queryVector, k) {
+  return chunks.map((chunk) => ({ url: chunk.url, title: chunk.title, text: chunk.text, score: cosineSimilarity(chunk.embedding, queryVector) })).sort((a, b) => b.score - a.score).slice(0, Math.max(0, k));
+}
+var MemoryKnowledgeStore = class {
+  byTenant = /* @__PURE__ */ new Map();
+  async replace(tenantId, chunks, meta) {
+    this.byTenant.set(tenantId, { chunks, meta });
+  }
+  async search(tenantId, queryVector, k) {
+    return rankChunks(this.byTenant.get(tenantId)?.chunks ?? [], queryVector, k);
+  }
+  async stats(tenantId) {
+    const entry = this.byTenant.get(tenantId);
+    if (!entry) return { chunks: 0, pages: 0, sources: [] };
+    return { chunks: entry.chunks.length, pages: entry.meta.pages, sources: entry.meta.sources, ingestedAt: entry.meta.ingestedAt };
+  }
+  async clear(tenantId) {
+    this.byTenant.delete(tenantId);
+  }
+};
+
 // src/guide.ts
 import { Hono as Hono2 } from "hono";
 var STEPS = [
@@ -2140,12 +2537,13 @@ function createFrankieApp(options) {
   }
   const registry = options.resolved ? TenantRegistry.single(options.resolved) : options.tenants instanceof TenantRegistry ? options.tenants : new TenantRegistry(options.tenants);
   const sessions = options.sessions ?? new MemorySessionStore();
+  const knowledgeStore = options.knowledge ?? new MemoryKnowledgeStore();
   const limiter = options.rateLimiter ?? new MemoryRateLimiter();
   const clientTools = new ClientToolChannel();
   const log = options.logger ?? ((event) => console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...event })));
   const app = new Hono3();
   app.get("/healthz", (c) => c.json({ ok: true }));
-  app.route("/mcp", createMcpHostApp({ tenants: registry, logger: log }));
+  app.route("/mcp", createMcpHostApp({ tenants: registry, logger: log, rateLimiter: limiter }));
   app.route("/guide", createGuideApp());
   app.use("/v1/*", async (c, next) => {
     const origin = c.req.header("origin");
@@ -2176,6 +2574,14 @@ function createFrankieApp(options) {
     await next();
     return;
   });
+  app.use("/v1/*", async (c, next) => {
+    const { attachments } = c.get("tenant").config.features;
+    const maxSize = (attachments.enabled ? Math.ceil(attachments.maxMb * attachments.maxCount * 1024 * 1024 * 1.4) : 0) + 1024 * 1024;
+    return bodyLimit2({
+      maxSize,
+      onError: (ctx) => jsonError(ctx, 413, "payload_too_large", "That message is too large to send.")
+    })(c, next);
+  });
   app.get("/v1/config", (c) => {
     const { config } = c.get("tenant");
     const publicConfig = {
@@ -2211,13 +2617,16 @@ function createFrankieApp(options) {
           // otherwise an enabled picker with an empty list renders nothing.
           models: publicPickerModels(config)
         }
-      }
+      },
+      // Where this agent shows; the generated FrankieAgents mount reads it so
+      // page changes made in the dashboard apply without a new install PR.
+      pages: config.pagePatterns ?? []
     };
     return c.json(publicConfig);
   });
   app.post("/v1/session", async (c) => {
     const { config, tokens } = c.get("tenant");
-    const ip = clientIp(c);
+    const ip = clientIp2(c);
     if (!await limiter.take(`session:${ip}`, config.limits.sessionsPerIpPerWindow, config.limits.windowSeconds)) {
       return jsonError(c, 429, "rate_limited", "Too many chat sessions from this address. Try again later.");
     }
@@ -2398,12 +2807,30 @@ function createFrankieApp(options) {
         }
       }
     }
-    const session = await sessions.get(claims.sessionId);
+    let session = await sessions.get(claims.sessionId);
     if (!session) {
       return jsonError(c, 404, "session_not_found", "Your chat session expired. Reload the page to start again.");
     }
-    if (session.busy) {
-      return jsonError(c, 409, "internal", "The assistant is still answering your previous message.");
+    if (claims.tenantId !== config.tenantId || session.tenantId !== config.tenantId || session.user.id !== claims.userId) {
+      return jsonError(c, 401, "unauthorized", "This chat session belongs to someone else. Reload the page to start again.");
+    }
+    const leaseMs = config.limits.turnTimeoutMs + BUSY_LEASE_GRACE_MS;
+    if (isTurnRunning(session, leaseMs)) {
+      session = await settledSession(sessions, session, leaseMs);
+      if (!session) {
+        return jsonError(c, 404, "session_not_found", "Your chat session expired. Reload the page to start again.");
+      }
+      if (isTurnRunning(session, leaseMs)) {
+        return jsonError(c, 409, "internal", "The assistant is still answering your previous message.");
+      }
+    } else if (session.busy) {
+      log({
+        level: "warn",
+        event: "busy_lock_expired",
+        tenant: config.tenantId,
+        sessionId: session.id,
+        heldMs: Date.now() - (session.busySince ?? session.lastActiveAt)
+      });
     }
     if (!await limiter.take(
       `chat:${session.id}`,
@@ -2417,6 +2844,7 @@ function createFrankieApp(options) {
     }
     const patch = {
       busy: true,
+      busySince: Date.now(),
       messageCount: session.messageCount + 1,
       ...body.context ? { context: { ...session.context, ...sanitizeContext(body.context) } } : {},
       ...!session.title ? { title: titleFromText(body.message) } : {}
@@ -2429,6 +2857,23 @@ function createFrankieApp(options) {
     const modelOverride = body.model && body.model !== config.model.model && config.features.modelPicker.enabled ? resolveModelChoice(models, config, body.model) ?? void 0 : void 0;
     let finalMessages;
     let turnCostUsd = 0;
+    const escalations = [];
+    const onEscalation = async (event) => {
+      const { tenantId: _t, conversationId: _c, userId: _u, ...record } = event;
+      escalations.push(record);
+      const webhookUrl = config.features.escalation.webhookUrl;
+      if (!webhookUrl) return;
+      try {
+        await connectorFetch(webhookUrl, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ type: "frankie.escalation", workspace: config.tenantId, ...event }),
+          signal: AbortSignal.timeout(1e4)
+        });
+      } catch (error) {
+        log({ level: "warn", event: "escalation_webhook_failed", sessionId: session.id, error: error instanceof Error ? error.message : String(error) });
+      }
+    };
     const clientBridge = clientTools.bridge(session.id, config.limits.turnTimeoutMs);
     const events = runTurn({
       config,
@@ -2438,12 +2883,14 @@ function createFrankieApp(options) {
       model,
       models,
       clientBridge,
+      ...config.knowledgeBase.enabled ? { knowledge: { store: knowledgeStore, embedding: resolveEmbeddingConfig(config, secrets.providerApiKey) } } : {},
       ...modelOverride ? { modelOverride } : {},
       ...attachments.length ? { attachments } : {},
       signal: abort.signal,
       onTranscript: (messages) => {
         finalMessages = messages;
       },
+      onEscalation,
       onWarning: (event, detail) => log({ level: "warn", event, sessionId: session.id, ...detail })
     });
     const encoder = new TextEncoder();
@@ -2480,7 +2927,8 @@ function createFrankieApp(options) {
           await sessions.update(session.id, {
             busy: false,
             ...finalMessages ? { messages: finalMessages } : {},
-            ...turnCostUsd ? { costUsd: current.costUsd + turnCostUsd } : {}
+            ...turnCostUsd ? { costUsd: current.costUsd + turnCostUsd } : {},
+            ...escalations.length ? { escalations: [...current.escalations ?? [], ...escalations] } : {}
           });
           controller.close();
         }
@@ -2563,10 +3011,8 @@ function setCors(c, origin) {
 function jsonError(c, status, code, message) {
   return c.json({ error: { code, message } }, status);
 }
-function clientIp(c) {
-  const forwarded = c.req.header("x-forwarded-for");
-  if (forwarded) return forwarded.split(",")[0]?.trim() ?? "unknown";
-  return c.req.header("cf-connecting-ip") ?? c.req.header("x-real-ip") ?? "unknown";
+function clientIp2(c) {
+  return clientIp((name) => c.req.header(name));
 }
 function sanitizeContext(context) {
   if (!context) return {};
@@ -2585,6 +3031,18 @@ function sanitizeContext(context) {
 function validConversationId(value) {
   return typeof value === "string" && /^[A-Za-z0-9_-]{8,128}$/.test(value);
 }
+var BUSY_LEASE_GRACE_MS = 3e4;
+var BUSY_SETTLE_WAIT_MS = 1500;
+var BUSY_SETTLE_POLL_MS = 250;
+async function settledSession(sessions, session, leaseMs) {
+  const deadline = Date.now() + BUSY_SETTLE_WAIT_MS;
+  let latest = session;
+  while (latest && isTurnRunning(latest, leaseMs) && Date.now() < deadline) {
+    await new Promise((resolve2) => setTimeout(resolve2, BUSY_SETTLE_POLL_MS));
+    latest = await sessions.get(session.id);
+  }
+  return latest;
+}
 function titleFromText(value) {
   const title = value.trim().replace(/\s+/g, " ");
   return title.slice(0, 42) + (title.length > 42 ? "\u2026" : "");
@@ -2633,8 +3091,9 @@ function titleFromClientMessages(messages) {
 import { mkdir, readFile as readFile2, readdir, rename, rm, writeFile } from "fs/promises";
 import { randomUUID as randomUUID5 } from "crypto";
 import { join, resolve } from "path";
-import { parseFrankieConfig } from "@frankieai/core";
+import { parseFrankieConfig, resolvePersonaConfig as resolvePersonaConfig2 } from "@frankieai/core";
 var MEMBERS_FILE = "__members.json";
+var SUBSCRIPTIONS_FILE = "__subscriptions.json";
 function publicVercelLink(link) {
   const { accessToken: _token, ...rest } = link;
   return rest;
@@ -2687,10 +3146,15 @@ function toPublicTenant(record) {
       }))
     ],
     locked: record.locked ?? false,
+    apiAutoRefresh: record.apiAutoRefresh ?? false,
+    ...record.suggestedTheme ? { suggestedTheme: record.suggestedTheme } : {},
     ...record.repositoryInstall ? { repositoryInstall: record.repositoryInstall } : {},
+    ...record.personaInstalls ? { personaInstalls: record.personaInstalls } : {},
     ...record.vercel ? { vercel: publicVercelLink(record.vercel) } : {},
     theme: config.theme,
     features: config.features,
+    knowledgeBase: config.knowledgeBase,
+    personas: config.personas,
     agent: {
       greeting: config.agent.greeting,
       suggestedPrompts: config.agent.suggestedPrompts,
@@ -2743,6 +3207,8 @@ var FileTenantStore = class _FileTenantStore {
   byId = /* @__PURE__ */ new Map();
   members = /* @__PURE__ */ new Map();
   // by `${org}\n${login}`
+  subscriptions = /* @__PURE__ */ new Map();
+  // by org (owner id)
   loaded = false;
   static memberKey(org, login) {
     return `${org}
@@ -2759,7 +3225,7 @@ ${login.toLowerCase()}`;
     const files = await readdir(this.dir).catch(() => []);
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
-      if (file === MEMBERS_FILE) continue;
+      if (file === MEMBERS_FILE || file === SUBSCRIPTIONS_FILE) continue;
       try {
         const record = JSON.parse(await readFile2(join(this.dir, file), "utf8"));
         record.config = parseFrankieConfig(record.config);
@@ -2774,6 +3240,11 @@ ${login.toLowerCase()}`;
       }
     } catch {
     }
+    try {
+      const raw = await readFile2(join(this.dir, SUBSCRIPTIONS_FILE), "utf8");
+      for (const sub of JSON.parse(raw)) this.subscriptions.set(sub.org, sub);
+    } catch {
+    }
     this.loaded = true;
   }
   async persistMembers() {
@@ -2798,18 +3269,38 @@ ${login.toLowerCase()}`;
     const lower = login.toLowerCase();
     return [...this.members.values()].filter((m) => m.login === lower);
   }
+  async persistSubscriptions() {
+    await mkdir(this.dir, { recursive: true });
+    await writeFile(join(this.dir, SUBSCRIPTIONS_FILE), JSON.stringify([...this.subscriptions.values()], null, 2), "utf8");
+  }
+  async getSubscription(org) {
+    await this.load();
+    return this.subscriptions.get(org) ?? null;
+  }
+  async putSubscription(subscription) {
+    await this.load();
+    this.subscriptions.set(subscription.org, subscription);
+    await this.persistSubscriptions();
+  }
   remember(record) {
+    const prior = this.byId.get(record.id);
+    if (prior) {
+      for (const [key, value] of this.index) if (value === prior) this.index.delete(key);
+    }
     this.byId.set(record.id, record);
     this.index.set(record.config.auth.publishableKey, record);
+    for (const persona of record.config.personas) this.index.set(persona.publishableKey, record);
   }
   async byPublishableKey(key) {
     await this.load();
     const record = this.index.get(key);
     if (!record) return null;
-    const providerApiKey = this.env[record.config.model.apiKeyEnv] ?? this.env[this.providerKeyEnv];
+    const config = resolvePersonaConfig2(record.config, key);
+    if (!config) return null;
+    const providerApiKey = this.env[config.model.apiKeyEnv] ?? this.env[this.providerKeyEnv];
     if (!providerApiKey) return null;
     return {
-      config: record.config,
+      config,
       secrets: {
         ...record.jwtSecret ? { jwtSecret: record.jwtSecret } : {},
         sessionSecret: record.sessionSecret,
@@ -2833,29 +3324,40 @@ ${login.toLowerCase()}`;
       throw new Error(`Publishable key already belongs to tenant "${existing.id}".`);
     }
     this.remember(record);
-    await mkdir(this.dir, { recursive: true });
-    await writeFile(join(this.dir, `${record.id}.json`), JSON.stringify(record, null, 2), "utf8");
+    await this.write(record);
   }
   async compareAndSwap(previous, next) {
     await this.load();
     if (this.byId.get(previous.id) !== previous) return false;
     this.remember(next);
-    await mkdir(this.dir, { recursive: true });
-    await writeFile(join(this.dir, `${next.id}.json`), JSON.stringify(next, null, 2), "utf8");
+    await this.write(next);
     return true;
   }
+  /**
+   * A record holds the workspace's signing and session secrets and source
+   * credentials: owner-only permissions, and written whole (temp file, then
+   * rename) so a crash never leaves half a record behind.
+   */
+  async write(record) {
+    await mkdir(this.dir, { recursive: true, mode: 448 });
+    const path = join(this.dir, `${record.id}.json`);
+    const temporary = `${path}.${process.pid}.${randomUUID5()}.tmp`;
+    await writeFile(temporary, JSON.stringify(record, null, 2), { encoding: "utf8", mode: 384 });
+    await rename(temporary, path);
+  }
   async delete(id) {
     await this.load();
     const record = this.byId.get(id);
     if (!record) return;
     this.byId.delete(id);
     this.index.delete(record.config.auth.publishableKey);
+    for (const persona of record.config.personas) this.index.delete(persona.publishableKey);
     await rm(join(this.dir, `${id}.json`), { force: true });
   }
 };
 
 // src/control/postgres-store.ts
-import { parseFrankieConfig as parseFrankieConfig2 } from "@frankieai/core";
+import { parseFrankieConfig as parseFrankieConfig2, resolvePersonaConfig as resolvePersonaConfig3 } from "@frankieai/core";
 var PostgresTenantStore = class {
   snapshots = /* @__PURE__ */ new WeakMap();
   db;
@@ -2902,6 +3404,28 @@ var PostgresTenantStore = class {
        )`
     );
     await this.db.query(`CREATE INDEX IF NOT EXISTS frankie_org_members_login ON frankie_org_members (login)`);
+    await this.db.query(
+      `CREATE TABLE IF NOT EXISTS frankie_subscriptions (
+         org text PRIMARY KEY,
+         plan text NOT NULL,
+         status text NOT NULL,
+         stripe_customer_id text,
+         stripe_subscription_id text,
+         current_period_end text,
+         updated_at text NOT NULL
+       )`
+    );
+  }
+  subscriptionRow(row) {
+    return {
+      org: String(row.org),
+      plan: row.plan === "pro" ? "pro" : "free",
+      status: ["active", "trialing", "past_due", "canceled", "incomplete"].includes(String(row.status)) ? String(row.status) : "active",
+      ...row.stripe_customer_id ? { stripeCustomerId: String(row.stripe_customer_id) } : {},
+      ...row.stripe_subscription_id ? { stripeSubscriptionId: String(row.stripe_subscription_id) } : {},
+      ...row.current_period_end ? { currentPeriodEnd: String(row.current_period_end) } : {},
+      updatedAt: String(row.updated_at)
+    };
   }
   memberRow(row) {
     return {
@@ -2963,6 +3487,23 @@ var PostgresTenantStore = class {
     await this.ensureReady();
     await this.db.query(`DELETE FROM frankie_org_members WHERE org = $1 AND login = $2`, [org, login.toLowerCase()]);
   }
+  async getSubscription(org) {
+    await this.ensureReady();
+    const { rows } = await this.db.query(`SELECT * FROM frankie_subscriptions WHERE org = $1`, [org]);
+    return rows[0] ? this.subscriptionRow(rows[0]) : null;
+  }
+  async putSubscription(subscription) {
+    await this.ensureReady();
+    await this.db.query(
+      `INSERT INTO frankie_subscriptions (org, plan, status, stripe_customer_id, stripe_subscription_id, current_period_end, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       ON CONFLICT (org) DO UPDATE SET
+         plan = EXCLUDED.plan, status = EXCLUDED.status,
+         stripe_customer_id = EXCLUDED.stripe_customer_id, stripe_subscription_id = EXCLUDED.stripe_subscription_id,
+         current_period_end = EXCLUDED.current_period_end, updated_at = EXCLUDED.updated_at`,
+      [subscription.org, subscription.plan, subscription.status, subscription.stripeCustomerId ?? null, subscription.stripeSubscriptionId ?? null, subscription.currentPeriodEnd ?? null, subscription.updatedAt]
+    );
+  }
   async membershipsForLogin(login) {
     await this.ensureReady();
     const { rows } = await this.db.query(`SELECT * FROM frankie_org_members WHERE login = $1`, [login.toLowerCase()]);
@@ -2976,19 +3517,27 @@ var PostgresTenantStore = class {
   }
   async byPublishableKey(key) {
     await this.ensureReady();
-    const { rows } = await this.db.query(`SELECT record FROM frankie_tenants WHERE publishable_key = $1`, [key]);
-    if (rows.length === 0 || !rows[0]) return null;
-    const record = this.parse(rows[0]);
-    const providerApiKey = this.env[record.config.model.apiKeyEnv] ?? this.env[this.providerKeyEnv];
-    if (!providerApiKey) return null;
-    return {
-      config: record.config,
-      secrets: {
-        ...record.jwtSecret ? { jwtSecret: record.jwtSecret } : {},
-        sessionSecret: record.sessionSecret,
-        providerApiKey
-      }
-    };
+    let records = await this.db.query(`SELECT record FROM frankie_tenants WHERE publishable_key = $1`, [key]);
+    if (records.rows.length === 0) {
+      if (!/^pk_[A-Za-z0-9_-]{1,120}$/.test(key)) return null;
+      records = await this.db.query(`SELECT record FROM frankie_tenants WHERE record LIKE $1`, [`%"publishableKey":${JSON.stringify(key)}%`]);
+    }
+    for (const row of records.rows) {
+      const record = this.parse(row);
+      const config = resolvePersonaConfig3(record.config, key);
+      if (!config) continue;
+      const providerApiKey = this.env[config.model.apiKeyEnv] ?? this.env[this.providerKeyEnv];
+      if (!providerApiKey) return null;
+      return {
+        config,
+        secrets: {
+          ...record.jwtSecret ? { jwtSecret: record.jwtSecret } : {},
+          sessionSecret: record.sessionSecret,
+          providerApiKey
+        }
+      };
+    }
+    return null;
   }
   async list(ownerId) {
     await this.ensureReady();
@@ -3127,6 +3676,53 @@ var PostgresSessionStore = class {
   }
 };
 
+// src/postgres-knowledge.ts
+var PostgresKnowledgeStore = class {
+  db;
+  ready;
+  constructor(options) {
+    this.db = options.db;
+  }
+  ensureReady() {
+    return this.ready ??= this.init();
+  }
+  async init() {
+    await this.db.query(
+      `CREATE TABLE IF NOT EXISTS frankie_kb (
+         tenant_id text PRIMARY KEY,
+         data text NOT NULL
+       )`
+    );
+  }
+  async load(tenantId) {
+    await this.ensureReady();
+    const { rows } = await this.db.query(`SELECT data FROM frankie_kb WHERE tenant_id = $1`, [tenantId]);
+    if (rows.length === 0 || !rows[0]) return void 0;
+    return JSON.parse(String(rows[0].data));
+  }
+  async replace(tenantId, chunks, meta) {
+    await this.ensureReady();
+    const data = JSON.stringify({ chunks, meta });
+    await this.db.query(
+      `INSERT INTO frankie_kb (tenant_id, data) VALUES ($1, $2)
+       ON CONFLICT (tenant_id) DO UPDATE SET data = EXCLUDED.data`,
+      [tenantId, data]
+    );
+  }
+  async search(tenantId, queryVector, k) {
+    return rankChunks((await this.load(tenantId))?.chunks ?? [], queryVector, k);
+  }
+  async stats(tenantId) {
+    const stored = await this.load(tenantId);
+    if (!stored) return { chunks: 0, pages: 0, sources: [] };
+    return { chunks: stored.chunks.length, pages: stored.meta.pages, sources: stored.meta.sources, ingestedAt: stored.meta.ingestedAt };
+  }
+  async clear(tenantId) {
+    await this.ensureReady();
+    await this.db.query(`DELETE FROM frankie_kb WHERE tenant_id = $1`, [tenantId]);
+  }
+};
+
 // src/control/resolve-store.ts
 async function resolveStores(env = process.env) {
   const url = env["DATABASE_URL"];
@@ -3139,10 +3735,11 @@ async function resolveStores(env = process.env) {
     });
     const tenants = new PostgresTenantStore({ db: pool, env });
     const sessions = new PostgresSessionStore({ db: pool });
-    return { tenants, sessions, describe: "postgres" };
+    const knowledge = new PostgresKnowledgeStore({ db: pool });
+    return { tenants, sessions, knowledge, describe: "postgres" };
   }
   const dir = env["FRANKIE_TENANTS_DIR"] ?? "./.frankie/tenants";
-  return { tenants: new FileTenantStore({ dir, env }), sessions: new MemorySessionStore(), describe: `files:${dir}` };
+  return { tenants: new FileTenantStore({ dir, env }), sessions: new MemorySessionStore(), knowledge: new MemoryKnowledgeStore(), describe: `files:${dir}` };
 }
 async function resolveTenantStore(env = process.env) {
   const url = env["DATABASE_URL"];
@@ -3174,6 +3771,8 @@ export {
   MemoryRateLimiter,
   MemorySessionStore,
   newSessionId,
+  resolveEmbeddingConfig,
+  embedTexts,
   TenantRegistry,
   SingleTenantStore,
   MemoryTenantStore,
@@ -3190,6 +3789,7 @@ export {
   securitySchemes,
   applySecurity,
   collectParameters,
+  describeSchemaInputs,
   buildUrl,
   slug,
   isRecord,
@@ -3207,4 +3807,4 @@ export {
   resolveStores,
   resolveTenantStore
 };
-//# sourceMappingURL=chunk-7J5Z5MIK.js.map
+//# sourceMappingURL=chunk-WEHJH4FL.js.map