sideagent 0.4.0 → 0.5.0

package/README.md

@@ -55,6 +55,18 @@ With an agent hosted on sideagent Cloud, pass its publishable key instead of `en
 
 Pass `endpoint` as well to send the requests somewhere else, such as a proxy in front of sideagent Cloud. A malformed key, or neither prop, throws during render. `parsePublishableKey` and `publishableEndpoint` are exported from `sideagent/keys`.
 
+Signed-in users: pass `getHeaders`, which the chat calls before every request, so a login token that expires is fetched fresh each time. Pass `storageKey` (the user's ID) so the last conversation the chat remembers in `localStorage` belongs to that user; on a shared browser another user starts from their own.
+
+```tsx
+<AgentChat
+  publishableKey="pk_live_…"
+  getHeaders={async () => ({ Authorization: `Bearer ${await getToken()}` })}
+  storageKey={user.id}
+/>
+```
+
+`getHeaders` works with `endpoint` too. Its headers are merged under `headers`, which wins on a clash, so it cannot replace the publishable key. If it throws, the request is not sent and the chat shows an error.
+
 ### Docked sidebar
 
 Wrap your app in `AgentProvider` to dock the chat on the right, side by side with the app instead of over it. It takes the same props as `AgentChat`. The user drags the panel's left edge (or uses the arrow keys on it) to resize; the width is remembered. Outside `AgentProvider`, sidebar mode overlays the page.

package/dist/index.d.ts

@@ -49,6 +49,17 @@ interface AgentChatProps {
     /** Use "include" when the endpoint is on another origin and relies on cookies. */
     credentials?: RequestCredentials;
     headers?: Record<string, string>;
+    /**
+     * Called before every request; its headers are added to `headers` (which wins on a clash). Use it for a
+     * login token that expires, e.g. `Authorization: Bearer <token>` from your login SDK. If it throws, the
+     * request is not sent and the chat shows an error.
+     */
+    getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+    /**
+     * Scopes what the chat remembers in localStorage (the last conversation) to one user, e.g. their user ID.
+     * Changing it starts over with that user's last conversation.
+     */
+    storageKey?: string;
     defaultOpen?: boolean;
     /** Custom result views per operationId. Anything not listed gets the built-in table / fields view. */
     resultRenderers?: Record<string, (e: {
@@ -79,10 +90,13 @@ interface AgentControls {
 /** Open or close the assistant from anywhere under `AgentProvider`. */
 declare function useAgent(): AgentControls;
 
+type GetHeaders = () => Record<string, string> | Promise<Record<string, string>>;
 interface TransportOptions {
     endpoint: string;
     credentials?: RequestCredentials;
     headers?: Record<string, string>;
+    /** Called before every request, e.g. for a fresh login token. `headers` wins on a clash. */
+    getHeaders?: GetHeaders;
     signal?: AbortSignal;
 }
 /** POSTs a chat request and yields the server's SSE events. */

package/dist/index.js

@@ -343,11 +343,22 @@ function toInitialMessages(messages) {
 }
 
 // src/client/transport.ts
+async function requestHeaders(opts) {
+  const dynamic = opts.getHeaders ? await opts.getHeaders() : {};
+  return { "content-type": "application/json", ...dynamic, ...opts.headers };
+}
 async function* streamChat(body, opts) {
+  let headers;
+  try {
+    headers = await requestHeaders(opts);
+  } catch {
+    yield { type: "error", code: "headers_failed", message: "Could not get credentials. Sign in again." };
+    return;
+  }
   const res = await fetch(opts.endpoint, {
     method: "POST",
     credentials: opts.credentials ?? "same-origin",
-    headers: { "content-type": "application/json", ...opts.headers },
+    headers,
     body: JSON.stringify(body),
     signal: opts.signal
   });
@@ -377,10 +388,16 @@ async function* streamChat(body, opts) {
   }
 }
 async function callJson(body, opts) {
+  let headers;
+  try {
+    headers = await requestHeaders(opts);
+  } catch {
+    return { status: 0, data: null };
+  }
   const res = await fetch(opts.endpoint, {
     method: "POST",
     credentials: opts.credentials ?? "same-origin",
-    headers: { "content-type": "application/json", ...opts.headers },
+    headers,
     body: JSON.stringify(body)
   });
   let data = null;
@@ -394,7 +411,7 @@ async function callJson(body, opts) {
 // src/client/Chat.tsx
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function Chat(props) {
-  const { endpoint, hooks, credentials, headers } = props;
+  const { endpoint, hooks, credentials, headers, getHeaders } = props;
   const latest = useRef(props);
   latest.current = props;
   const threadId = useRef(props.session.threadId);
@@ -417,6 +434,7 @@ function Chat(props) {
               endpoint: p.endpoint,
               credentials: p.credentials,
               headers: p.headers,
+              getHeaders: p.getHeaders,
               signal: abortSignal
             })) {
               parts = applyEvent(parts, ev);
@@ -459,7 +477,7 @@ function Chat(props) {
     setLoadedPending(null);
     for await (const ev of streamChat(
       { threadId: threadId.current, approval: { token: req.token, decision } },
-      { endpoint, credentials, headers }
+      { endpoint, credentials, headers, getHeaders }
     )) {
       if (ev.type === "tool.complete") fireComplete(hooks, ev);
       if (ev.type === "error") safely(() => hooks?.onError?.({ code: ev.code, message: ev.message }));
@@ -499,7 +517,12 @@ import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function HistoryList(props) {
   const [threads, setThreads] = useState2(null);
   const [error, setError] = useState2(false);
-  const opts = { endpoint: props.endpoint, credentials: props.credentials, headers: props.headers };
+  const opts = {
+    endpoint: props.endpoint,
+    credentials: props.credentials,
+    headers: props.headers,
+    getHeaders: props.getHeaders
+  };
   useEffect(() => {
     callJson({ action: "threads.list" }, opts).then((r) => r.data?.threads ? setThreads(r.data.threads) : setError(true)).catch(() => setError(true));
   }, []);
@@ -538,7 +561,7 @@ function HistoryList(props) {
 // src/client/storage.ts
 var MODE_KEY = "sideagent:mode";
 var WIDTH_KEY = "sideagent:width";
-var threadKey = (endpoint) => `sideagent:thread:${endpoint}`;
+var threadKey = (endpoint, storageKey) => `sideagent:thread:${endpoint}${storageKey ? `:${storageKey}` : ""}`;
 var MODES = ["floating", "sidebar"];
 function storeGet(k) {
   try {
@@ -739,8 +762,13 @@ function AgentChat(props) {
   const [width, setWidth] = useState3(() => clampWidth(Number(storeGet(WIDTH_KEY)) || DEFAULT_WIDTH));
   const [resizing, setResizing] = useState3(false);
   const booted = useRef2(false);
-  const key = threadKey(target.endpoint);
-  const opts = { endpoint: target.endpoint, credentials: props.credentials, headers: target.headers };
+  const key = threadKey(target.endpoint, props.storageKey);
+  const opts = {
+    endpoint: target.endpoint,
+    credentials: props.credentials,
+    headers: target.headers,
+    getHeaders: props.getHeaders
+  };
   const setMode = useCallback((m) => {
     setModeState(m);
     storeSet(MODE_KEY, m);
@@ -765,7 +793,7 @@ function AgentChat(props) {
       }
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [target, props.credentials]
+    [target, props.credentials, props.getHeaders]
   );
   const resizeTo = useCallback((w) => {
     const next = clampWidth(w);
@@ -796,6 +824,14 @@ function AgentChat(props) {
     setView("chat");
   };
   const visible = open;
+  const shownKey = useRef2(key);
+  useEffect2(() => {
+    if (shownKey.current === key) return;
+    shownKey.current = key;
+    booted.current = false;
+    setView("chat");
+    setSession((s) => ({ key: s.key + 1 }));
+  }, [key]);
   useEffect2(() => {
     if (!visible || booted.current) return;
     booted.current = true;

package/dist/server/index.d.ts

@@ -2,7 +2,11 @@ import { ThreadMeta } from '../protocol.js';
 export { AgentEvent, ChatRequest } from '../protocol.js';
 import { z } from 'zod';
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { BaseCheckpointSaver } from '@langchain/langgraph';
+import { BaseStore, BaseCheckpointSaver } from '@langchain/langgraph';
+import { Document } from '@langchain/core/documents';
+import { EmbeddingsInterface } from '@langchain/core/embeddings';
+import { VectorStore, VectorStoreInterface } from '@langchain/core/vectorstores';
+export { VectorStoreInterface as VectorStore } from '@langchain/core/vectorstores';
 
 declare const configSchema: z.ZodObject<{
     spec: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
@@ -71,31 +75,35 @@ interface ChunkMeta {
     /** Only set for sources that came from a URL listed in config. */
     url?: string;
 }
-interface StoredChunk {
-    text: string;
-    vector: number[];
-    meta: ChunkMeta;
-}
 interface Hit {
     text: string;
     score: number;
     meta: ChunkMeta;
 }
-/** Plug in your own (pgvector, Vectorize, …). The default is an in-memory cosine store. */
-interface VectorStore {
-    replace(sourceId: string, chunks: StoredChunk[]): Promise<void>;
-    search(vector: number[], k: number): Promise<Hit[]>;
-}
-declare class MemoryVectorStore implements VectorStore {
-    private bySource;
-    replace(sourceId: string, chunks: StoredChunk[]): Promise<void>;
-    search(vector: number[], k: number): Promise<Hit[]>;
+
+/** Default store: cosine similarity over everything in process memory. */
+declare class MemoryVectorStore extends VectorStore {
+    FilterType: object;
+    lc_namespace: string[];
+    private rows;
+    constructor(embeddings: EmbeddingsInterface);
+    _vectorstoreType(): string;
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    delete(params?: {
+        ids?: string[];
+    }): Promise<void>;
+    similaritySearchVectorWithScore(query: number[], k: number): Promise<[Document, number][]>;
 }
 
-/** Splits markdown/plain text into chunks of roughly `size` chars, keeping the nearest heading as context. */
-declare function chunkText(content: string, size: number): string[];
+/** Splits markdown/plain text into chunks of at most about `size` chars, each prefixed with its nearest heading. */
+declare function chunkText(content: string, size: number): Promise<string[]>;
 
-/** Dependency-free HTML to text/markdown-ish conversion. Plain text out; never HTML. */
+/** HTML to text/markdown-ish conversion on a real parser. Plain text out; never HTML. */
 declare function htmlToText(html: string): {
     title?: string;
     text: string;
@@ -130,7 +138,7 @@ interface SourceStatus {
 interface KnowledgeDeps {
     embedDocuments(texts: string[]): Promise<number[][]>;
     embedQuery(text: string): Promise<number[]>;
-    store?: VectorStore;
+    store?: VectorStoreInterface;
     allowPrivateNetworks?: boolean;
     fetch?: typeof fetch;
     now?: () => number;
@@ -138,8 +146,10 @@ interface KnowledgeDeps {
 declare class KnowledgeBase {
     private opts;
     private deps;
-    readonly store: VectorStore;
+    readonly store: VectorStoreInterface;
     private statuses;
+    /** Chunk ids currently stored per source, so a refresh can drop the ones that disappeared. */
+    private chunkIds;
     private refreshing;
     private lastRefresh;
     private totalChunks;
@@ -208,6 +218,20 @@ declare class MemoryThreadStore implements ThreadStore {
     touch(userId: string, threadId: string, title: string): Promise<void>;
     delete(userId: string, threadId: string): Promise<void>;
 }
+/**
+ * Thread index on any LangGraph `BaseStore` (Postgres, Redis, …), so one store can serve the checkpointer
+ * ecosystem and the thread list. Keeps at most 200 threads per user, like `MemoryThreadStore`.
+ */
+declare class LangGraphThreadStore implements ThreadStore {
+    private store;
+    constructor(store: BaseStore);
+    private ns;
+    private all;
+    list(userId: string): Promise<ThreadMeta[]>;
+    has(userId: string, threadId: string): Promise<boolean>;
+    touch(userId: string, threadId: string, title: string): Promise<void>;
+    delete(userId: string, threadId: string): Promise<void>;
+}
 
 interface AuthResult {
     /** Stable identity of the signed-in user. Threads are bound to it. */
@@ -238,7 +262,7 @@ interface CreateAgentOptions extends AgentConfigInput {
     /** Index of each user's conversations (history list). Defaults to in-memory. */
     threadStore?: ThreadStore;
     /** Where knowledge embeddings live. Defaults to in-memory (re-embedded on every start). */
-    vectorStore?: VectorStore;
+    vectorStore?: VectorStoreInterface;
 }
 declare function createAgent(options: CreateAgentOptions): Promise<{
     handler: (request: Request) => Promise<Response>;
@@ -262,4 +286,4 @@ declare function honoHandler(agent: Agent): (c: {
 /** Express (use express.json() before it): `app.post("/agent", expressHandler(agent))` and `app.options("/agent", expressHandler(agent))` */
 declare function expressHandler(agent: Agent): (req: any, res: any) => Promise<any>;
 
-export { type Agent, type AgentConfig, type AgentConfigInput, type AuditEvent, type AuthResult, type CreateAgentOptions, type DoctorReport, type EmbeddingsLike, KnowledgeBase, type KnowledgeSourceInput, MemoryThreadStore, MemoryVectorStore, type ThreadStore, type VectorStore, assertAllowedUrl, chunkText, configSchema, createAgent, expressHandler, honoHandler, htmlToText, nextRoute, parseConfig };
+export { type Agent, type AgentConfig, type AgentConfigInput, type AuditEvent, type AuthResult, type CreateAgentOptions, type DoctorReport, type EmbeddingsLike, KnowledgeBase, type KnowledgeSourceInput, LangGraphThreadStore, MemoryThreadStore, MemoryVectorStore, type ThreadStore, assertAllowedUrl, chunkText, configSchema, createAgent, expressHandler, honoHandler, htmlToText, nextRoute, parseConfig };

package/dist/server/index.js

@@ -232,34 +232,39 @@ import {
 } from "@langchain/langgraph";
 
 // src/server/knowledge/chunk.ts
-function chunkText(content, size) {
+import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
+var HEADING = /^#{1,6}\s.*$/;
+async function chunkText(content, size) {
   const out = [];
   let heading = "";
-  let cur = "";
-  const flush = () => {
-    if (cur.trim()) out.push(cur.trim());
-    cur = "";
-  };
-  const withHeading = (t) => heading && !t.startsWith("#") ? `${heading}
+  let body = [];
+  const flush = async () => {
+    const text = body.join("\n").trim();
+    body = [];
+    if (!text) return;
+    const room = Math.max(size - heading.length - 2, Math.floor(size / 2));
+    const splitter = RecursiveCharacterTextSplitter.fromLanguage("markdown", {
+      chunkSize: room,
+      chunkOverlap: Math.floor(room / 10)
+    });
+    for (const piece of await splitter.splitText(text)) {
+      const t = piece.trim();
+      if (t) out.push(heading ? `${heading}
 
-${t}` : t;
-  for (const raw of content.replace(/\r\n/g, "\n").split(/\n{2,}/)) {
-    const block = raw.trim();
-    if (!block) continue;
-    if (/^#{1,6}\s/.test(block)) {
-      flush();
-      heading = block.split("\n")[0];
+${t}` : t);
     }
-    const pieces = block.length > size ? block.match(new RegExp(`[\\s\\S]{1,${size}}(?:\\s|$)`, "g")) ?? [block] : [block];
-    for (const piece of pieces) {
-      if (cur && cur.length + piece.length + 2 > size) flush();
-      if (!cur) cur = withHeading(piece.trim());
-      else cur += `
-
-${piece.trim()}`;
+  };
+  let fence = false;
+  for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+    if (/^\s*(```|~~~)/.test(line)) fence = !fence;
+    if (!fence && HEADING.test(line)) {
+      await flush();
+      heading = line.trim();
+    } else {
+      body.push(line);
     }
   }
-  flush();
+  await flush();
   return out;
 }
 
@@ -357,25 +362,44 @@ async function executeOperation(op, args, ctx, signal) {
 }
 
 // src/server/knowledge/html.ts
-var ENTITIES = {
-  "&": "&",
-  "&lt;": "<",
-  "&gt;": ">",
-  "&quot;": '"',
-  "&#39;": "'",
-  "&nbsp;": " "
-};
+import { Parser } from "htmlparser2";
+var SKIP = /* @__PURE__ */ new Set(["script", "style", "noscript", "svg", "nav", "footer", "header", "form", "iframe", "template"]);
+var BLOCK_END = /* @__PURE__ */ new Set(["p", "div", "section", "article", "tr", "ul", "ol", "table", "pre", "blockquote"]);
 function htmlToText(html) {
-  const title = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html)?.[1]?.trim();
-  const text = html.replace(/<!--[\s\S]*?-->/g, "").replace(/<(script|style|noscript|svg|nav|footer|header|form|iframe)\b[\s\S]*?<\/\1>/gi, "").replace(
-    /<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi,
-    (_m, n, t) => `
-
-${"#".repeat(Number(n))} ${t}
+  let out = "";
+  let title = "";
+  let skip = 0;
+  let inTitle = false;
+  const parser = new Parser(
+    {
+      onopentag(name) {
+        if (SKIP.has(name)) skip++;
+        else if (name === "title") inTitle = true;
+        else if (skip) return;
+        else if (/^h[1-6]$/.test(name)) out += `
 
-`
-  ).replace(/<li[^>]*>/gi, "\n- ").replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|section|article|tr|ul|ol|table|pre|blockquote)>/gi, "\n\n").replace(/<[^>]+>/g, "").replace(/&(amp|lt|gt|quot|#39|nbsp);/g, (m) => ENTITIES[m] ?? m).replace(/[ \t]+/g, " ").replace(/ ?\n ?/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
-  return { title: title ? htmlToText(title).text.replace(/\s+/g, " ") : void 0, text };
+${"#".repeat(Number(name[1]))} `;
+        else if (name === "li") out += "\n- ";
+        else if (name === "br") out += "\n";
+      },
+      onclosetag(name) {
+        if (SKIP.has(name)) skip = Math.max(0, skip - 1);
+        else if (name === "title") inTitle = false;
+        else if (skip) return;
+        else if (/^h[1-6]$/.test(name) || BLOCK_END.has(name)) out += "\n\n";
+      },
+      ontext(text2) {
+        if (inTitle) title += text2;
+        else if (!skip) out += text2;
+      }
+    },
+    { decodeEntities: true }
+  );
+  parser.write(html);
+  parser.end();
+  const text = out.replace(/[ \t ]+/g, " ").replace(/ ?\n ?/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  const clean = title.replace(/\s+/g, " ").trim();
+  return { title: clean || void 0, text };
 }
 
 // src/server/knowledge/fetch-page.ts
@@ -415,32 +439,43 @@ async function fetchPage(url2, opts) {
   throw new Error("too many redirects");
 }
 
+// src/server/knowledge/index.ts
+import { Document } from "@langchain/core/documents";
+
 // src/server/knowledge/vector-store.ts
-var MemoryVectorStore = class {
-  bySource = /* @__PURE__ */ new Map();
-  async replace(sourceId, chunks) {
-    this.bySource.set(sourceId, chunks);
-  }
-  async search(vector, k) {
-    const hits = [];
-    for (const chunks of this.bySource.values()) {
-      for (const c of chunks) hits.push({ text: c.text, meta: c.meta, score: cosine(vector, c.vector) });
-    }
-    return hits.sort((a, b) => b.score - a.score).slice(0, k);
+import { VectorStore } from "@langchain/core/vectorstores";
+import { cosineSimilarity } from "@langchain/core/utils/math";
+var MemoryVectorStore = class extends VectorStore {
+  lc_namespace = ["sideagent", "vectorstores", "memory"];
+  rows = /* @__PURE__ */ new Map();
+  constructor(embeddings) {
+    super(embeddings, {});
+  }
+  _vectorstoreType() {
+    return "sideagent_memory";
+  }
+  async addVectors(vectors, documents, options) {
+    const ids = documents.map((_, i) => options?.ids?.[i] ?? crypto.randomUUID());
+    documents.forEach((doc, i) => this.rows.set(ids[i], { vector: vectors[i], doc }));
+    return ids;
+  }
+  async addDocuments(documents, options) {
+    const vectors = await this.embeddings.embedDocuments(documents.map((d) => d.pageContent));
+    return this.addVectors(vectors, documents, options);
+  }
+  async delete(params) {
+    for (const id of params?.ids ?? []) this.rows.delete(id);
+  }
+  async similaritySearchVectorWithScore(query, k) {
+    const rows = [...this.rows.values()].filter((r) => r.vector.length === query.length);
+    if (!rows.length) return [];
+    const scores = cosineSimilarity(
+      [query],
+      rows.map((r) => r.vector)
+    )[0];
+    return rows.map((r, i) => [r.doc, scores[i]]).sort((a, b) => b[1] - a[1]).slice(0, k);
   }
 };
-function cosine(a, b) {
-  let dot = 0;
-  let na = 0;
-  let nb = 0;
-  const n = Math.min(a.length, b.length);
-  for (let i = 0; i < n; i++) {
-    dot += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
-  }
-  return na && nb ? dot / Math.sqrt(na * nb) : 0;
-}
 
 // src/server/knowledge/format.ts
 function wrapKnowledge(hits, maxBytes) {
@@ -478,12 +513,14 @@ var KnowledgeBase = class {
   constructor(opts, deps) {
     this.opts = opts;
     this.deps = deps;
-    this.store = deps.store ?? new MemoryVectorStore();
+    this.store = deps.store ?? new MemoryVectorStore({ embedDocuments: (t) => deps.embedDocuments(t), embedQuery: (t) => deps.embedQuery(t) });
   }
   opts;
   deps;
   store;
   statuses = /* @__PURE__ */ new Map();
+  /** Chunk ids currently stored per source, so a refresh can drop the ones that disappeared. */
+  chunkIds = /* @__PURE__ */ new Map();
   refreshing = null;
   lastRefresh = 0;
   totalChunks = 0;
@@ -525,16 +562,24 @@ var KnowledgeBase = class {
       if (new TextEncoder().encode(content).byteLength > this.opts.maxSourceBytes) {
         throw new Error(`source larger than maxSourceBytes (${this.opts.maxSourceBytes})`);
       }
-      const texts = chunkText(content, this.opts.chunkSize);
+      const texts = await chunkText(content, this.opts.chunkSize);
       const others = this.totalChunks - (this.statuses.get(id)?.chunks ?? 0);
       if (others + texts.length > this.opts.maxChunks)
         throw new Error(`would exceed maxChunks (${this.opts.maxChunks})`);
       const vectors = texts.length ? await this.deps.embedDocuments(texts) : [];
       const meta = { sourceId: id, title, ...url2 ? { url: url2 } : {} };
-      await this.store.replace(
-        id,
-        texts.map((text, i) => ({ text, vector: vectors[i], meta }))
-      );
+      const ids = texts.map((_, i) => `${id}#${i}`);
+      if (texts.length) {
+        await this.store.addVectors(
+          vectors,
+          texts.map((text) => new Document({ pageContent: text, metadata: meta })),
+          { ids }
+        );
+      }
+      const keep = new Set(ids);
+      const stale = (this.chunkIds.get(id) ?? []).filter((old) => !keep.has(old));
+      if (stale.length) await this.store.delete({ ids: stale });
+      this.chunkIds.set(id, ids);
       this.totalChunks = others + texts.length;
       this.statuses.set(id, { id, title, ...url2 ? { url: url2 } : {}, chunks: texts.length, loadedAt: this.now() });
     } catch (e) {
@@ -557,7 +602,8 @@ var KnowledgeBase = class {
     if (this.opts.urls.length && this.now() - this.lastRefresh > this.opts.ttlMs) void this.refresh().catch(() => {
     });
     const vector = await this.deps.embedQuery(query);
-    return this.store.search(vector, this.opts.topK);
+    const found = await this.store.similaritySearchVectorWithScore(vector, this.opts.topK);
+    return found.map(([doc, score]) => ({ text: doc.pageContent, score, meta: doc.metadata }));
   }
 };
 
@@ -647,6 +693,7 @@ async function verifyApproval(secret, token, claims) {
 }
 
 // src/server/openapi.ts
+import { Validator } from "@langchain/core/utils/json_schema";
 import { dereference } from "@scalar/openapi-parser";
 var METHODS = ["get", "post", "put", "patch", "delete"];
 async function loadSpec(spec) {
@@ -743,6 +790,7 @@ async function loadOperations(spec, allow, maxTools) {
   }
   return ops;
 }
+var validators = /* @__PURE__ */ new WeakMap();
 function validateArgs(op, args) {
   if (!args || typeof args !== "object" || Array.isArray(args)) throw new Error("arguments must be an object");
   const a = args;
@@ -751,6 +799,13 @@ function validateArgs(op, args) {
   for (const r of op.inputSchema.required ?? []) {
     if (a[r] === void 0) throw new Error(`missing required argument "${r}"`);
   }
+  let validator = validators.get(op);
+  if (!validator) validators.set(op, validator = new Validator(op.inputSchema, "2019-09", false));
+  const result = validator.validate(a);
+  if (!result.valid) {
+    const detail = result.errors.slice(0, 3).map((e) => `${e.instanceLocation.replace(/^#\/?/, "") || "arguments"}: ${e.error}`).join("; ");
+    throw new Error(detail);
+  }
   return a;
 }
 
@@ -982,6 +1037,34 @@ var MemoryThreadStore = class {
     this.of(userId).delete(threadId);
   }
 };
+var LangGraphThreadStore = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  // Namespace labels cannot contain "." and user ids are often emails.
+  ns = (userId) => ["sideagent", "threads", encodeURIComponent(userId).replace(/\./g, "%2E")];
+  async all(userId) {
+    const items = await this.store.search(this.ns(userId), { limit: MAX_THREADS_PER_USER + 1 });
+    return items.map((i) => i.value).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async list(userId) {
+    return (await this.all(userId)).slice(0, MAX_THREADS_PER_USER);
+  }
+  async has(userId, threadId) {
+    return await this.store.get(this.ns(userId), threadId) != null;
+  }
+  async touch(userId, threadId, title) {
+    const existing = (await this.store.get(this.ns(userId), threadId))?.value;
+    const meta = { id: threadId, title: existing?.title ?? title, updatedAt: Date.now() };
+    await this.store.put(this.ns(userId), threadId, meta);
+    const threads = await this.all(userId);
+    if (threads.length > MAX_THREADS_PER_USER) await this.delete(userId, threads[threads.length - 1].id);
+  }
+  async delete(userId, threadId) {
+    await this.store.delete(this.ns(userId), threadId);
+  }
+};
 var titleFrom = (message) => message.replace(/\s+/g, " ").trim().slice(0, 60) || "New chat";
 var threadPrefix = (userId) => `${encodeURIComponent(userId)}:`;
 async function ownsThread(store, userId, threadId) {
@@ -1048,7 +1131,7 @@ function toHistory(messages) {
     return last;
   };
   for (const m of messages) {
-    const type = m._getType();
+    const type = m.getType();
     if (type === "human") {
       out.push({ role: "user", parts: [{ type: "text", text: messageText(m.content) }] });
     } else if (type === "ai") {
@@ -1092,7 +1175,7 @@ async function handleThreadAction(body, { userId, threads, graph }, cors) {
 
 // src/server/http/turn.ts
 import { HumanMessage } from "@langchain/core/messages";
-import { Command } from "@langchain/langgraph";
+import { Command, GraphRecursionError } from "@langchain/langgraph";
 async function runTurn(request, body, auth, deps, cors) {
   const { config, graph, threads, secret, active } = deps;
   const { userId } = auth;
@@ -1122,7 +1205,11 @@ async function runTurn(request, body, auth, deps, cors) {
   await threads.touch(userId, threadId, titleFrom("message" in body ? body.message : ""));
   active.set(userId, (active.get(userId) ?? 0) + 1);
   const timeout = new AbortController();
-  const timer = setTimeout(() => timeout.abort(new Error("turn timed out")), config.limits.turnTimeoutMs);
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    timeout.abort(new Error("turn timed out"));
+  }, config.limits.turnTimeoutMs);
   request.signal.addEventListener("abort", () => timeout.abort(), { once: true });
   const encoder = new TextEncoder();
   const stream = new ReadableStream({
@@ -1155,9 +1242,9 @@ async function runTurn(request, body, auth, deps, cors) {
         const waiting = pendingApprovalOf(await graph.getState(runCfg));
         if (waiting) send({ type: "approval.request", ...waiting });
       } catch (e) {
-        const msg = e.message ?? "error";
-        const code = /recursion/i.test(msg) ? "step_limit" : /timed out/i.test(msg) ? "timeout" : "error";
-        send({ type: "error", code, message: code === "error" ? "The agent failed. Try again." : msg });
+        const code = e instanceof GraphRecursionError ? "step_limit" : timedOut ? "timeout" : "error";
+        const message = code === "step_limit" ? e.message : timedOut ? "turn timed out" : void 0;
+        send({ type: "error", code, message: message ?? "The agent failed. Try again." });
       } finally {
         clearTimeout(timer);
         active.set(userId, Math.max(0, (active.get(userId) ?? 1) - 1));
@@ -1341,6 +1428,7 @@ function expressHandler(agent) {
 }
 export {
   KnowledgeBase,
+  LangGraphThreadStore,
   MemoryThreadStore,
   MemoryVectorStore,
   assertAllowedUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sideagent",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -54,8 +54,10 @@
     "@langchain/core": "^1.0.0",
     "@langchain/langgraph": "^1.5.2",
     "@langchain/openai": "^1.7.0",
+    "@langchain/textsplitters": "^1.0.2",
     "@radix-ui/react-icons": "^1.3.2",
     "@scalar/openapi-parser": "^0.29.16",
+    "htmlparser2": "^12.0.0",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
     "zod": "^4.0.0"