@anuma/sdk 3.0.0 → 3.1.1

package/dist/tools/selection/index.mjs

@@ -0,0 +1,1859 @@
+import {
+  BASE_URL
+} from "./chunk-4ETHWSXJ.mjs";
+
+// src/lib/memory/recallConstants.ts
+var RECALL_TOOL_NAME = "recall_memory";
+
+// src/lib/memoryEngine/generate.ts
+import { postApiV1Embeddings } from "@anuma/sdk";
+
+// src/lib/memoryEngine/constants.ts
+var DEFAULT_API_EMBEDDING_MODEL = "qwen/qwen3-embedding-8b";
+
+// src/lib/memoryEngine/generate.ts
+var EMBED_MAX_ATTEMPTS = 4;
+async function withEmbeddingRetry(call) {
+  let last;
+  let lastThrown;
+  let threw = false;
+  for (let attempt = 1; attempt <= EMBED_MAX_ATTEMPTS; attempt++) {
+    try {
+      threw = false;
+      last = await call();
+      if (!last.error) return last;
+      const status = last.response?.status;
+      const retryable = status === void 0 || status === 429 || status >= 500;
+      if (!retryable) return last;
+    } catch (err) {
+      threw = true;
+      lastThrown = err;
+    }
+    if (attempt < EMBED_MAX_ATTEMPTS) {
+      const base = 250 * 2 ** (attempt - 1);
+      await new Promise((r) => setTimeout(r, base + Math.random() * 0.4 * base));
+    }
+  }
+  if (threw) throw lastThrown;
+  return last;
+}
+var EmbeddingHttpError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "EmbeddingHttpError";
+    this.status = status;
+  }
+};
+function embeddingErrorFrom(response) {
+  const message = typeof response.error === "object" && response.error && "error" in response.error ? response.error.error : "API embedding failed";
+  return new EmbeddingHttpError(message, response.response?.status);
+}
+async function generateEmbedding(text, options) {
+  const { baseUrl = BASE_URL, getToken, apiKey, model, cache } = options;
+  if (cache) {
+    const cached = cache.get(text);
+    if (cached) return Array.from(cached);
+  }
+  let headers;
+  if (apiKey) {
+    headers = { "X-API-Key": apiKey };
+  } else if (getToken) {
+    const token = await getToken();
+    if (!token) {
+      throw new Error("No token available for embedding generation");
+    }
+    headers = { Authorization: `Bearer ${token}` };
+  } else {
+    throw new Error("Either apiKey or getToken must be provided");
+  }
+  const response = await withEmbeddingRetry(
+    () => postApiV1Embeddings({
+      baseUrl,
+      body: {
+        // Mask PII from the request body only — the cache above still keys on
+        // the original `text`, so callers keep their original values.
+        input: options.maskInput ? options.maskInput(text) : text,
+        model: model ?? DEFAULT_API_EMBEDDING_MODEL
+      },
+      headers
+    })
+  );
+  if (response.error) {
+    throw embeddingErrorFrom(response);
+  }
+  if (!response.data?.data?.[0]?.embedding) {
+    throw new Error("No embedding returned from API");
+  }
+  const embedding = response.data.data[0].embedding;
+  if (options.onUsage && response.data.usage) {
+    options.onUsage({
+      promptTokens: response.data.usage.prompt_tokens ?? 0,
+      totalTokens: response.data.usage.total_tokens ?? 0
+    });
+  }
+  const f32Embedding = Float32Array.from(embedding);
+  if (cache) {
+    cache.set(text, f32Embedding);
+  }
+  return Array.from(f32Embedding);
+}
+var DEFAULT_EMBEDDING_BATCH_SIZE = 100;
+var DEFAULT_EMBEDDING_BATCH_CONCURRENCY = 3;
+async function generateEmbeddingsBatch(texts, headers, baseUrl, model, onUsage, maskInput) {
+  const response = await withEmbeddingRetry(
+    () => postApiV1Embeddings({
+      baseUrl,
+      // Mask PII from the request body only; cache/order still key on originals.
+      body: { input: maskInput ? texts.map(maskInput) : texts, model },
+      headers
+    })
+  );
+  if (response.error) {
+    throw embeddingErrorFrom(response);
+  }
+  if (!response.data?.data) {
+    throw new Error("No embeddings returned from API");
+  }
+  if (onUsage && response.data.usage) {
+    onUsage({
+      promptTokens: response.data.usage.prompt_tokens ?? 0,
+      totalTokens: response.data.usage.total_tokens ?? 0
+    });
+  }
+  return response.data.data.map((item) => item.embedding ?? []);
+}
+async function generateEmbeddings(texts, options) {
+  if (texts.length === 0) return [];
+  const { baseUrl = BASE_URL, getToken, apiKey, model, batchSize, cache } = options;
+  const chunkSize = batchSize ?? DEFAULT_EMBEDDING_BATCH_SIZE;
+  const results = new Array(texts.length).fill(null);
+  const uncachedIndices = [];
+  const uncachedTexts = [];
+  for (let i = 0; i < texts.length; i++) {
+    if (cache) {
+      const cached = cache.get(texts[i]);
+      if (cached) {
+        results[i] = Array.from(cached);
+        continue;
+      }
+    }
+    uncachedIndices.push(i);
+    uncachedTexts.push(texts[i]);
+  }
+  if (uncachedTexts.length === 0) {
+    return results;
+  }
+  let headers;
+  if (apiKey) {
+    headers = { "X-API-Key": apiKey };
+  } else if (getToken) {
+    const token = await getToken();
+    if (!token) {
+      throw new Error("No token available for embedding generation");
+    }
+    headers = { Authorization: `Bearer ${token}` };
+  } else {
+    throw new Error("Either apiKey or getToken must be provided");
+  }
+  const embeddingModel = model ?? DEFAULT_API_EMBEDDING_MODEL;
+  let newEmbeddings;
+  if (uncachedTexts.length <= chunkSize) {
+    newEmbeddings = await generateEmbeddingsBatch(
+      uncachedTexts,
+      headers,
+      baseUrl,
+      embeddingModel,
+      options.onUsage,
+      options.maskInput
+    );
+  } else {
+    const chunks = [];
+    for (let i = 0; i < uncachedTexts.length; i += chunkSize) {
+      chunks.push(uncachedTexts.slice(i, i + chunkSize));
+    }
+    const allEmbeddings = new Array(chunks.length);
+    let nextIndex = 0;
+    const worker = async () => {
+      while (nextIndex < chunks.length) {
+        const idx = nextIndex++;
+        allEmbeddings[idx] = await generateEmbeddingsBatch(
+          chunks[idx],
+          headers,
+          baseUrl,
+          embeddingModel,
+          options.onUsage,
+          options.maskInput
+        );
+      }
+    };
+    const workers = Array.from(
+      { length: Math.min(DEFAULT_EMBEDDING_BATCH_CONCURRENCY, chunks.length) },
+      () => worker()
+    );
+    await Promise.all(workers);
+    newEmbeddings = allEmbeddings.flat();
+  }
+  for (let i = 0; i < uncachedIndices.length; i++) {
+    const f32Embedding = Float32Array.from(newEmbeddings[i]);
+    results[uncachedIndices[i]] = Array.from(f32Embedding);
+    if (cache) {
+      cache.set(uncachedTexts[i], f32Embedding);
+    }
+  }
+  return results;
+}
+
+// src/tools/appBuilderPrompt.ts
+var APP_BUILDER_PROMPT = `App Builder tools (create_file, patch_file, and the rest described below) are available this turn, but they are OPTIONAL \u2014 having them does not mean you should build anything.
+
+Build ONLY when the user gives an explicit instruction to build, create, generate, or change an app, tool, or UI \u2014 e.g. "build a todo app", "make a snake game", "add a footer to the app", "change the background to blue". A bare app name or feature reference is NOT a build instruction: if the user just says "todo app", "a snake game", or "qr code", or asks a question about an app, do NOT generate anything \u2014 reply normally, or ask what they'd like you to build. The same holds for greetings, questions, stories, explanations, advice, or code that isn't a runnable app: respond normally and do not create files. When it's unclear whether the user actually wants an app built, ask instead of building.
+
+Once the user HAS given an explicit build instruction, you are in App Builder mode: you produce polished, production-quality React apps that feel designed \u2014 not generic.
+
+DESIGN: on the initial build, before writing code, briefly state (2-3 sentences) what you want this app to feel like \u2014 name the specific fonts, the palette in hex, and one signature detail. Be concrete: "Fraunces display + Inter body + JetBrains Mono metadata, terracotta #b75432 accent on bone #f3efe6, paper-grain texture via inline SVG noise" is the kind of specificity that anchors the build. Default to nothing: don't pick "safe modern productivity" unless the brief literally asks for utilitarian. On later turns, state a design brief only when the change is visual (a restyle, new theme, or new UI); for a logic, data, or behavior-only change, skip the brief and just make the change.
+
+WORKFLOW:
+1. NEVER output code as text or markdown. ALWAYS use tools.
+2. Initial build: state your design brief, then create_file with a "files" array writing ALL files in one call. The preview renders automatically.
+3. patch_file requires read_file for that path earlier in the conversation (or create_file in the same conversation, which counts). read_file output is numbered "42: <text>" \u2014 the prefix is display-only; never copy it into "find". Each "find" must match exactly one location \u2014 include 2-3 lines of surrounding context. Pass multiple patches per call to change distinct locations.
+4. Prefer patch_file for changes to existing files \u2014 surgical, reviewable, preserves surrounding code. Reserve create_file overwrites for substantial restructuring. Inserts: find the line before, replace with that line + the new line. Deletes: empty replace.
+5. After substantial changes, call critique_design first (taste, hierarchy, distinctiveness, weakest decision) and then audit_design (mechanical: tokens, focus states, aria-labels, alt, heading order). Patch what each surfaces. critique catches taste issues no checklist would; audit catches mechanics you'd miss. Run both; act on both.
+6. Before declaring done, call verify_app. The host's preview runtime reports whether your app actually mounted and surfaces any errors it captured \u2014 hallucinated imports, syntax the bundler rejected, undefined components, runtime crashes. If \`rendered\` is false or \`errors\` is non-empty, fix every error before the next message. If the response includes a \`note\` that verify_app isn't wired in this host, skip \u2014 audit + critique are your feedback in that case.
+7. Keep responses to a sentence or two. Exception: when responding to critique_design, write a substantive paragraph per rubric question.
+
+STRUCTURE:
+- App.js: default-export React component. For non-trivial apps, define small co-located helpers (Header, CardList, Card, EditDialog, \u2026) above the default export rather than one giant App.
+- App.css: all styles, imported in App.js. No inline style objects.
+- package.json: list ALL imported packages including react. No CDN script tags. Versions are auto-pinned.
+- Do NOT create index.js or index.html (auto-generated).
+
+STATE & PERSISTENCE:
+- The code runs in the user's browser \u2014 standard browser APIs available (localStorage, URL hash, Date, fetch).
+- Persist user-created data (todos, cards, notes, settings) with localStorage so it survives refresh. Use a versioned key ("kanban.v1") and JSON.parse inside try/catch on read.
+- Treat persisted data as untrusted and possibly stale: a saved record may predate a field you just added (a timestamp, id, or setting), so default-fill or skip missing fields on read \u2014 never assume a loaded record has every field the current code expects. Bump the key version when the shape changes.
+- Lift state to App when multiple children need it; keep it local otherwise. Extract non-trivial logic into custom hooks (useTodos, useTimer).
+- useReducer for state shapes with several interrelated fields (cards + columns + filters + drag state).
+
+FILE & IMAGE UPLOAD:
+- Picker: \`<input type="file" accept="image/*" multiple>\` (vary accept by use case: \`.csv,text/csv\`, \`.txt,.md,text/plain\`, etc.).
+- Drag-and-drop: call \`e.preventDefault()\` in onDragOver (otherwise drop never fires); read files from \`event.dataTransfer.files\`. Drop and picker should coexist.
+- Previews: \`<img src={URL.createObjectURL(file)} />\`. Call \`URL.revokeObjectURL\` on unmount or before replacing \u2014 otherwise the browser leaks memory.
+- localStorage cannot hold large binary. Persist only metadata for big files; re-upload on next visit (or use IndexedDB if you really need durable binary storage).
+- Validate size and type before processing; reject files larger than the app can hold in memory.
+
+AI CAPABILITIES \u2014 \`window.app.complete(prompt: string): Promise<string>\` is available in this environment. Build for the real call.
+- When the app's core purpose is conversation, generation, grading, recommendation, or any natural-language task, this IS the implementation \u2014 call it. NEVER fake it: no hardcoded or canned replies, no random or \`setTimeout\` "thinking", no demo-mode stub. A chat app, tutor, or assistant that doesn't call \`window.app.complete\` is wrong, not a placeholder.
+- Don't force it where it isn't needed \u2014 a calculator, todo list, or timer has no reason to call it. Match the implementation to what the app actually does.
+- Async: wrap in try/catch, show a loading state, and disable dependent inputs while waiting. Surface failures gracefully ("Couldn't reach the AI \u2014 try again").
+- Structure prompts with clear sections (Role / Context / Task / Format) and pass the relevant state (e.g. the running conversation) as context. Render the response as untrusted text: \`white-space: pre-wrap\`, never dangerouslySetInnerHTML.
+- Skip the call only when the answer is genuinely static \u2014 no language or reasoning needed. Cache repeated prompts in component state when sensible.
+
+CODE QUALITY \u2014 write as a senior engineer would:
+- Handle edge cases (empty inputs, division by zero, invalid data). Show helpful error states, not crashes.
+- Never let formatting throw during render: guard \`new Date(x)\` / \`Intl\` / \`toLocaleString\` / \`.toFixed\` against missing or invalid values (e.g. \`Number.isNaN(d.getTime())\`) and return a fallback \u2014 one bad value from storage or state must not blank the whole app.
+- Semantic HTML: real headings, labels, buttons (not divs with onClick), form elements.
+- Accessible: aria-labels on icon buttons, focus-visible styles, keyboard navigable.
+- Extract into custom hooks or helpers when a component grows past ~80 lines.
+
+STYLING \u2014 Tailwind is the CHASSIS, custom CSS carries the IDENTITY:
+- Tailwind (via Play CDN) for layout, spacing, state (hover/focus), responsive prefixes \u2014 uniform structure.
+- App.css carries the identity: @import the Google Fonts, declare CSS custom properties (--bg, --panel, --card, --ink, --muted, --accent, --hairline, --radius, --radius-sm, --shadow-card, --shadow-card-hi) in :root, gradients/textures/signature animations Tailwind can't express. Reference tokens from Tailwind via arbitrary values (\`className="bg-[var(--bg)]"\`) when needed. A well-designed app has 60-200 lines of App.css \u2014 not zero.
+- Modern CSS is how apps stop reading as generic-AI-output: \`color-mix(in oklab, var(--accent) 14%, transparent)\` for tinting, \`oklch()\` / \`oklab()\` for perceptually-uniform color, \`:has()\`, \`conic-gradient\` / \`radial-gradient\`, \`backdrop-filter\`, \`@container\` queries, inline SVG \`feTurbulence\` for texture.
+- Don't pull additional CSS frameworks. Tailwind + custom CSS is enough.
+
+VISUAL DESIGN \u2014 every app should look like a real product, not a wireframe:
+- Let the chosen aesthetic drive every decision. "Editorial" wants italic display type and restrained color; "retro arcade" wants chunky shadows and saturated gradients. No safe-modern defaults.
+- Atmospheric depth: subtle radial wash, paper grain (inline SVG noise), warm/cool tint \u2014 every canvas should feel like a designed space, not a #fff rectangle.
+- Three shadow tiers (rest / hover / active). Pair drop shadows with inset highlights (\`box-shadow: 0 1px 0 rgba(255,255,255,.9) inset, 0 6px 14px -10px ...\`) for tactile feel.
+- Typography hierarchy: display font for headlines (italic accents on key words via \`<em>\`), body font for content, mono for metadata/labels \u2014 different families telegraph different information types.
+- Interactive polish: hover/active/focus on every clickable element, 200-300ms cubic-bezier transitions, keyboard shortcuts where natural (Esc to cancel, Cmd/Ctrl+Enter to commit), focus-visible rings keyed to the accent.
+- Light/dark mode if reasonable: a single CSS variable inversion under \`[data-theme="dark"]\`.
+- Customization affordance for multi-session apps: small "Tweaks" panel with theme / density / accent. Skip for throwaway demos.
+- Responsive: Tailwind responsive prefixes (\`sm:\`, \`md:\`, \`lg:\`) and \`@media\` in App.css. Mobile-first.`;
+
+// src/tools/document/documentBuilderPrompt.ts
+var DOCUMENT_BUILDER_PROMPT = `Document tools (create_document, read_document, patch_document) are available this turn, but they are OPTIONAL \u2014 having them does not mean you should produce a document.
+
+Use them ONLY when the user explicitly asks you to draft, write, compose, or generate a document \u2014 a contract, agreement, NDA, letter, cover letter, memo, essay, report, brief, proposal, or resume \u2014 e.g. "draft me a service agreement", "write a cover letter for this job", "make a one-page memo about X". A bare topic, a question, a request for an explanation, or a request for a slide deck or an interactive app is NOT a document instruction: respond normally and do not call these tools. When it's unclear whether the user wants a finished document, ask instead.
+
+When you DO author a document, the document body goes entirely into the tool \u2014 NEVER write the document text as chat prose. The tool renders your source to a real, paginated PDF and attaches it to your reply automatically. AFTER the tool returns, briefly confirm in ONE short sentence what you made (e.g. "Drafted a cover letter for the product manager role \u2014 see the attached PDF."). Do not restate the document's contents.
+
+AUTHORING \u2014 write the "source" as a single @react-pdf/renderer JSX expression (this is react-pdf, NOT HTML and NOT a slide deck):
+- Root is exactly one <Document> with at least one <Page>. Its only children are <Page> elements. Add more <Page> elements for longer documents \u2014 react-pdf also paginates overflow automatically.
+- Inside a <Page>: use <View> as flex containers and <Text> for ALL text. Raw text is only allowed inside <Text> (and <Link>); a <View> or <Page> may not contain bare text.
+- <Text> may nest <Text>, <Link>, or <Note> for inline styling, hyperlinks, and (rarely) a PDF comment annotation. A <Link> src must be an ordinary web link \u2014 http(s), mailto, tel, or a relative/anchor link; javascript:/data:/file: links are rejected. <Image> is self-closing and its src MUST be an inline "data:" URI \u2014 remote image URLs are rejected for privacy. Vector primitives (<Rect>/<Circle>/<Path>/etc.) must live inside an <Svg>.
+- Styling is react-pdf style objects only: style={{ marginTop: 12, fontSize: 11, fontFamily: "Times-Roman", flexDirection: "column" }}. Flexbox only \u2014 there is NO CSS grid, float, or box-shadow. Use camelCase react-pdf keys (margin/padding, flex*, width/height, color/backgroundColor, border*, text*, etc.).
+- fontFamily must be a built-in PDF font: Helvetica, Times-Roman, or Courier (with -Bold / -Oblique / -Italic / -BoldOblique variants), or Symbol / ZapfDingbats. Custom fonts are not supported.
+- LITERAL VALUES ONLY: no variables, no JS expressions, no .map(), no event handlers (onClick, \u2026), no spreads. Every attribute is a literal string, number, boolean, or a style object of literals.
+
+A minimal example:
+
+<Document>
+  <Page size="A4" style={{ paddingVertical: 56, paddingHorizontal: 64, fontFamily: "Times-Roman", fontSize: 11, lineHeight: 1.5 }}>
+    <Text style={{ fontSize: 18, fontFamily: "Times-Bold", marginBottom: 16, textAlign: "center" }}>MUTUAL NON-DISCLOSURE AGREEMENT</Text>
+    <Text style={{ marginBottom: 10 }}>This Mutual Non-Disclosure Agreement (the "Agreement") is entered into as of the date of last signature below.</Text>
+    <View style={{ marginTop: 14 }}>
+      <Text style={{ fontFamily: "Times-Bold", marginBottom: 4 }}>1. Confidential Information</Text>
+      <Text>Each party may disclose certain confidential and proprietary information to the other party.</Text>
+    </View>
+  </Page>
+</Document>
+
+WORKFLOW:
+1. To create or fully restructure a document, call create_document with the complete source.
+2. To revise an existing document, call read_document first (its output is line-numbered "42: <text>" \u2014 the prefix is display-only, never copy it into a "find"), then patch_document with small find/replace edits. Each "find" must match exactly one location; add 2-3 lines of surrounding context if needed. Prefer patching over rewriting.
+3. To attach several separate documents in one reply, call create_document multiple times with distinct documentId slugs (e.g. "nda", "cover-letter"). Each renders to its own PDF.
+4. If a tool reports a DSL error (with line:col) or a render failure, fix the source and retry \u2014 do not give up or fall back to writing the document as chat text.`;
+
+// src/lib/logger.ts
+var consoleLogger = {
+  debug: console.log.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console)
+};
+var currentLogger = consoleLogger;
+function getLogger() {
+  return currentLogger;
+}
+
+// src/lib/memoryEngine/chunking.ts
+var DEFAULT_CHUNK_SIZE = 400;
+var DEFAULT_CHUNK_OVERLAP = 50;
+var DEFAULT_MIN_CHUNK_SIZE = 50;
+function splitIntoSentences(text) {
+  const sentenceRegex = /[.!?]+[\s"')}\]]*(?=\s|$)/g;
+  const sentences = [];
+  let lastIndex = 0;
+  let match;
+  while ((match = sentenceRegex.exec(text)) !== null) {
+    const endIndex = match.index + match[0].length;
+    const sentence = text.slice(lastIndex, endIndex).trim();
+    if (sentence) {
+      sentences.push(sentence);
+    }
+    lastIndex = endIndex;
+  }
+  const remaining = text.slice(lastIndex).trim();
+  if (remaining) {
+    sentences.push(remaining);
+  }
+  return sentences;
+}
+function chunkText(text, options) {
+  const {
+    chunkSize = DEFAULT_CHUNK_SIZE,
+    chunkOverlap: requestedOverlap = DEFAULT_CHUNK_OVERLAP,
+    minChunkSize = DEFAULT_MIN_CHUNK_SIZE
+  } = options ?? {};
+  const chunkOverlap = Math.min(requestedOverlap, chunkSize - 1);
+  if (text.length <= chunkSize) {
+    return [
+      {
+        text: text.trim(),
+        startOffset: 0,
+        endOffset: text.length
+      }
+    ];
+  }
+  const sentences = splitIntoSentences(text);
+  const chunks = [];
+  let currentChunkSentences = [];
+  let currentChunkStart = 0;
+  let currentOffset = 0;
+  for (let i = 0; i < sentences.length; i++) {
+    const sentence = sentences[i];
+    let sentenceStart = text.indexOf(sentence, currentOffset);
+    if (sentenceStart === -1) {
+      sentenceStart = currentOffset;
+    }
+    const sentenceEnd = sentenceStart + sentence.length;
+    if (sentence.length > chunkSize) {
+      if (currentChunkSentences.length > 0) {
+        const chunkText2 = currentChunkSentences.join(" ");
+        chunks.push({
+          text: chunkText2,
+          startOffset: currentChunkStart,
+          endOffset: currentOffset
+        });
+        currentChunkSentences = [];
+      }
+      for (let j = 0; j < sentence.length; j += chunkSize - chunkOverlap) {
+        const chunkEnd = Math.min(j + chunkSize, sentence.length);
+        const chunk = sentence.slice(j, chunkEnd);
+        if (chunk.length >= minChunkSize) {
+          chunks.push({
+            text: chunk,
+            startOffset: sentenceStart + j,
+            endOffset: sentenceStart + chunkEnd
+          });
+        }
+      }
+      currentChunkStart = sentenceEnd;
+      currentOffset = sentenceEnd;
+      continue;
+    }
+    const currentText = currentChunkSentences.join(" ");
+    const potentialLength = currentText.length + (currentText ? 1 : 0) + sentence.length;
+    if (potentialLength > chunkSize && currentChunkSentences.length > 0) {
+      chunks.push({
+        text: currentText,
+        startOffset: currentChunkStart,
+        endOffset: currentOffset
+      });
+      const overlapSentences = [];
+      let overlapLength = 0;
+      for (let j = currentChunkSentences.length - 1; j >= 0 && overlapLength < chunkOverlap; j--) {
+        overlapSentences.unshift(currentChunkSentences[j]);
+        overlapLength += currentChunkSentences[j].length + 1;
+      }
+      if (overlapSentences.length > 0) {
+        currentChunkSentences = [...overlapSentences, sentence];
+        const overlapText = overlapSentences[0];
+        const overlapStart = text.lastIndexOf(overlapText, currentOffset);
+        currentChunkStart = overlapStart === -1 ? sentenceStart : overlapStart;
+      } else {
+        currentChunkSentences = [sentence];
+        currentChunkStart = sentenceStart;
+      }
+    } else {
+      if (currentChunkSentences.length === 0) {
+        currentChunkStart = sentenceStart;
+      }
+      currentChunkSentences.push(sentence);
+    }
+    currentOffset = sentenceEnd;
+  }
+  if (currentChunkSentences.length > 0) {
+    const chunkText2 = currentChunkSentences.join(" ");
+    if (chunkText2.length >= minChunkSize) {
+      chunks.push({
+        text: chunkText2,
+        startOffset: currentChunkStart,
+        endOffset: text.length
+      });
+    }
+  }
+  if (chunks.length === 0) {
+    const trimmedText = text.trim();
+    if (trimmedText.length > 0) {
+      return [
+        {
+          text: trimmedText,
+          startOffset: 0,
+          endOffset: text.length
+        }
+      ];
+    }
+  }
+  return chunks;
+}
+function shouldChunkMessage(content, chunkSize = DEFAULT_CHUNK_SIZE) {
+  return content.length > chunkSize;
+}
+
+// src/lib/memoryEngine/vector.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+// src/lib/tools/serverTools.ts
+var DEFAULT_CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1e3;
+var SERVER_TOOLS_CACHE_KEY = "sdk_server_tools_cache";
+var CACHE_VERSION = "1.3";
+var MIN_CONTENT_LENGTH_FOR_TOOLS = 5;
+var MAX_CLIENT_TOOLS_AFTER_FILTER = 10;
+var CLIENT_TOOLS_MIN_SIMILARITY = 0.53;
+var CLIENT_TOOLS_RELEVANCE_RATIO = 0.75;
+function isNewToolFormat(tool) {
+  return "schema" in tool && tool.schema !== void 0;
+}
+function isNewResponseFormat(response) {
+  return "checksum" in response && "tools" in response && typeof response.checksum === "string";
+}
+function convertServerToolsResponse(response) {
+  let toolsMap;
+  let checksum;
+  if (isNewResponseFormat(response)) {
+    toolsMap = response.tools;
+    checksum = response.checksum;
+  } else {
+    toolsMap = response;
+  }
+  const tools = Object.values(toolsMap).map((tool) => {
+    if (isNewToolFormat(tool)) {
+      return {
+        type: "function",
+        name: tool.schema.name,
+        description: tool.schema.description,
+        parameters: tool.schema.parameters,
+        ...tool.embedding && { embedding: tool.embedding }
+      };
+    }
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    };
+  });
+  return { tools, checksum };
+}
+function toCompletionsFormat(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  };
+}
+function toResponsesFormat(tool) {
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  };
+}
+function getCachedServerTools() {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const cached = localStorage.getItem(SERVER_TOOLS_CACHE_KEY);
+    if (!cached) return null;
+    const parsed = JSON.parse(cached);
+    if (parsed.version !== CACHE_VERSION) {
+      removeLocalStorageCache();
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isCacheExpired(cache, expirationMs = DEFAULT_CACHE_EXPIRATION_MS) {
+  if (!cache) return true;
+  return Date.now() - cache.timestamp > expirationMs;
+}
+function buildCacheEntry(tools, checksum) {
+  return {
+    tools,
+    timestamp: Date.now(),
+    version: CACHE_VERSION,
+    ...checksum && { checksum }
+  };
+}
+function writeLocalStorageCache(entry) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(SERVER_TOOLS_CACHE_KEY, JSON.stringify(entry));
+  } catch (error) {
+    getLogger().warn("[serverTools] Failed to cache tools:", error);
+  }
+}
+function removeLocalStorageCache() {
+  if (typeof localStorage === "undefined") return;
+  localStorage.removeItem(SERVER_TOOLS_CACHE_KEY);
+}
+var localStorageToolsCache = {
+  get: getCachedServerTools,
+  set: writeLocalStorageCache,
+  clear: removeLocalStorageCache
+};
+function clearServerToolsCache(cache = localStorageToolsCache) {
+  return cache.clear?.();
+}
+function getToolsChecksum(cache = localStorageToolsCache) {
+  const cached = cache.get();
+  return cached instanceof Promise ? cached.then((c) => c?.checksum) : cached?.checksum;
+}
+function shouldRefreshTools(responseChecksum, cache = localStorageToolsCache) {
+  if (!responseChecksum) {
+    return false;
+  }
+  const decide = (cachedChecksum2) => !cachedChecksum2 || cachedChecksum2 !== responseChecksum;
+  const cachedChecksum = getToolsChecksum(cache);
+  return cachedChecksum instanceof Promise ? cachedChecksum.then(decide) : decide(cachedChecksum);
+}
+async function fetchServerToolsFromApi(baseUrl, token) {
+  const response = await fetch(`${baseUrl}/api/v1/tools`, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch server tools: ${response.status}`);
+  }
+  const data = await response.json();
+  return convertServerToolsResponse(data);
+}
+async function getServerTools(options) {
+  const {
+    baseUrl,
+    cacheExpirationMs = DEFAULT_CACHE_EXPIRATION_MS,
+    forceRefresh = false,
+    getToken,
+    apiKey,
+    cache = localStorageToolsCache
+  } = options;
+  const persistCache = async (entry) => {
+    try {
+      await cache.set(entry);
+    } catch (error) {
+      getLogger().warn("[serverTools] Cache write failed (non-fatal):", error);
+    }
+  };
+  let rawCached = null;
+  try {
+    rawCached = await cache.get();
+  } catch (error) {
+    getLogger().warn("[serverTools] Cache read failed; falling through to server fetch:", error);
+  }
+  const cached = rawCached && rawCached.version === CACHE_VERSION ? rawCached : null;
+  const cacheValid = !isCacheExpired(cached, cacheExpirationMs);
+  if (cached && cacheValid && !forceRefresh) {
+    return cached.tools;
+  }
+  try {
+    const { BASE_URL: BASE_URL2 } = await import("./clientConfig-WITO4T6L.mjs");
+    const effectiveBaseUrl = baseUrl ?? BASE_URL2;
+    if (apiKey) {
+      const response = await fetch(`${effectiveBaseUrl}/api/v1/tools`, {
+        method: "GET",
+        headers: {
+          "X-API-Key": apiKey,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch server tools: ${response.status}`);
+      }
+      const data = await response.json();
+      const { tools: tools2, checksum: checksum2 } = convertServerToolsResponse(data);
+      await persistCache(buildCacheEntry(tools2, checksum2));
+      return tools2;
+    }
+    if (!getToken) {
+      getLogger().warn("[serverTools] No auth method available for fetching tools");
+      return cached?.tools ?? [];
+    }
+    const token = await getToken();
+    if (!token) {
+      getLogger().warn("[serverTools] No auth token available for fetching tools");
+      return cached?.tools ?? [];
+    }
+    const { tools, checksum } = await fetchServerToolsFromApi(effectiveBaseUrl, token);
+    await persistCache(buildCacheEntry(tools, checksum));
+    return tools;
+  } catch (error) {
+    getLogger().error("[serverTools] Failed to fetch server tools:", error);
+    if (cached?.tools) {
+      getLogger().warn("[serverTools] Using stale cached tools due to fetch error");
+      return cached.tools;
+    }
+    return [];
+  }
+}
+function filterServerTools(serverTools, includeNames) {
+  if (includeNames === void 0) {
+    return serverTools;
+  }
+  if (includeNames.length === 0) {
+    return [];
+  }
+  const includeSet = new Set(includeNames);
+  return serverTools.filter((tool) => includeSet.has(tool.name));
+}
+function getToolFunction(tool) {
+  const fn = tool.function;
+  if (fn && typeof fn === "object") {
+    return fn;
+  }
+  return void 0;
+}
+function clientToolToResponsesFormat(tool) {
+  const toolConfig = tool;
+  const func = getToolFunction(tool);
+  if (!func) {
+    return tool;
+  }
+  return {
+    type: "function",
+    name: func.name,
+    description: func.description,
+    // Handle both 'parameters' and 'arguments' field names
+    parameters: func.parameters ?? func.arguments,
+    // Preserve executor functions for client-side execution
+    ...toolConfig.executor && { executor: toolConfig.executor },
+    ...toolConfig.skipContinuation !== void 0 && {
+      skipContinuation: toolConfig.skipContinuation
+    },
+    ...toolConfig.removeAfterExecution !== void 0 && {
+      removeAfterExecution: toolConfig.removeAfterExecution
+    },
+    ...toolConfig.executorTimeout !== void 0 && {
+      executorTimeout: toolConfig.executorTimeout
+    },
+    ...toolConfig.dependsOn !== void 0 && { dependsOn: toolConfig.dependsOn },
+    ...toolConfig.deAnonymizeArgs !== void 0 && {
+      deAnonymizeArgs: toolConfig.deAnonymizeArgs
+    }
+  };
+}
+function clientToolToCompletionsFormat(tool) {
+  const toolConfig = tool;
+  const func = getToolFunction(tool);
+  if (!func) {
+    return tool;
+  }
+  if (func.parameters) {
+    return tool;
+  }
+  const { arguments: args, ...restFunc } = func;
+  return {
+    type: "function",
+    function: {
+      ...restFunc,
+      parameters: args ?? { type: "object", properties: {} }
+    },
+    // Preserve executor functions for client-side execution
+    ...toolConfig.executor && { executor: toolConfig.executor },
+    ...toolConfig.skipContinuation !== void 0 && {
+      skipContinuation: toolConfig.skipContinuation
+    },
+    ...toolConfig.removeAfterExecution !== void 0 && {
+      removeAfterExecution: toolConfig.removeAfterExecution
+    },
+    ...toolConfig.executorTimeout !== void 0 && {
+      executorTimeout: toolConfig.executorTimeout
+    },
+    ...toolConfig.dependsOn !== void 0 && { dependsOn: toolConfig.dependsOn },
+    ...toolConfig.deAnonymizeArgs !== void 0 && {
+      deAnonymizeArgs: toolConfig.deAnonymizeArgs
+    }
+  };
+}
+var TOOL_SEARCH_TOOL_TYPE = "tool_search_tool_regex_20251119";
+var TOOL_SEARCH_TOOL_NAME = "tool_search_tool_regex";
+function byNameAscending(a, b) {
+  if (a.name < b.name) return -1;
+  if (a.name > b.name) return 1;
+  return 0;
+}
+function formatServerToolsWithDefer(serverTools, config, apiType) {
+  if (serverTools.length === 0) {
+    return [];
+  }
+  const fmt = apiType === "completions" ? toCompletionsFormat : toResponsesFormat;
+  const hotSet = new Set(config.hotToolNames);
+  const hot = [...hotSet].map((name) => serverTools.find((t) => t.name === name)).filter((t) => t !== void 0);
+  const deferred = serverTools.filter((t) => !hotSet.has(t.name)).sort(byNameAscending);
+  const searchTool = {
+    type: TOOL_SEARCH_TOOL_TYPE,
+    name: TOOL_SEARCH_TOOL_NAME
+  };
+  return [
+    searchTool,
+    ...hot.map((t) => fmt(t)),
+    ...deferred.map((t) => ({ ...fmt(t), defer_loading: true }))
+  ];
+}
+function mergeTools(serverTools, clientTools, apiType = "responses", deferConfig) {
+  const useDefer = deferConfig?.enabled === true && apiType === "responses";
+  const formattedServerTools = useDefer ? formatServerToolsWithDefer(serverTools, deferConfig, apiType) : apiType === "completions" ? serverTools.map(toCompletionsFormat) : serverTools.map(toResponsesFormat);
+  if (!clientTools || clientTools.length === 0) {
+    return formattedServerTools;
+  }
+  const formattedClientTools = apiType === "responses" ? clientTools.map(clientToolToResponsesFormat) : clientTools.map(clientToolToCompletionsFormat);
+  if (formattedServerTools.length === 0) {
+    return formattedClientTools;
+  }
+  const clientToolNames = new Set(
+    clientTools.map((t) => {
+      const fn = getToolFunction(t);
+      return fn?.name ?? t.name;
+    }).filter((name) => typeof name === "string" && !!name)
+  );
+  const nonConflictingServerTools = formattedServerTools.filter((tool) => {
+    let toolName2;
+    if ("name" in tool && typeof tool.name === "string") {
+      toolName2 = tool.name;
+    } else if ("function" in tool && typeof tool.function === "object" && tool.function !== null) {
+      toolName2 = tool.function.name;
+    }
+    return !clientToolNames.has(toolName2 ?? "");
+  });
+  return [...nonConflictingServerTools, ...formattedClientTools];
+}
+var DEFAULT_TOOL_MATCH_OPTIONS = {
+  limit: 5,
+  minSimilarity: 0.3,
+  filterAmbiguous: false,
+  ambiguityThreshold: 0.55,
+  minLead: 0.04,
+  relevanceRatio: 0
+};
+function findMatchingTools(promptEmbeddings, tools, options) {
+  const { limit, minSimilarity, filterAmbiguous, ambiguityThreshold, minLead, relevanceRatio } = {
+    ...DEFAULT_TOOL_MATCH_OPTIONS,
+    ...options
+  };
+  if (!promptEmbeddings || promptEmbeddings.length === 0) {
+    return [];
+  }
+  if (!tools || tools.length === 0) {
+    return [];
+  }
+  const embeddings = Array.isArray(promptEmbeddings[0]) ? promptEmbeddings : [promptEmbeddings];
+  const results = [];
+  for (const tool of tools) {
+    if (!tool.embedding || tool.embedding.length === 0) {
+      continue;
+    }
+    try {
+      let maxSimilarity = -Infinity;
+      for (const embedding of embeddings) {
+        const similarity = cosineSimilarity(embedding, tool.embedding);
+        if (similarity > maxSimilarity) {
+          maxSimilarity = similarity;
+        }
+      }
+      if (maxSimilarity >= minSimilarity) {
+        results.push({ tool, similarity: maxSimilarity });
+      }
+    } catch {
+      continue;
+    }
+  }
+  let sorted = results.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  if (filterAmbiguous && sorted.length > 1) {
+    const topScore = sorted[0].similarity;
+    const runnerUpScore = sorted[1].similarity;
+    if (topScore < ambiguityThreshold && topScore - runnerUpScore < minLead) {
+      return [];
+    }
+  }
+  if (relevanceRatio > 0 && sorted.length > 1) {
+    const cutoff = sorted[0].similarity * relevanceRatio;
+    sorted = sorted.filter((r) => r.similarity >= cutoff);
+  }
+  return sorted;
+}
+function scoreTools(promptEmbeddings, tools) {
+  const scores = /* @__PURE__ */ new Map();
+  if (!promptEmbeddings || promptEmbeddings.length === 0) return scores;
+  if (!tools || tools.length === 0) return scores;
+  const embeddings = Array.isArray(promptEmbeddings[0]) ? promptEmbeddings : [promptEmbeddings];
+  for (const tool of tools) {
+    if (!tool.embedding || tool.embedding.length === 0) continue;
+    let maxSimilarity = -Infinity;
+    try {
+      for (const embedding of embeddings) {
+        const similarity = cosineSimilarity(embedding, tool.embedding);
+        if (similarity > maxSimilarity) maxSimilarity = similarity;
+      }
+    } catch {
+      continue;
+    }
+    if (maxSimilarity > -Infinity) scores.set(tool.name, maxSimilarity);
+  }
+  return scores;
+}
+var BUILT_IN_TOOL_SETS = [
+  {
+    name: "app-generation",
+    // Appended to the base prompt (not replacing it) whenever this set
+    // activates, so the App Builder guidance — including the window.app.complete
+    // runtime-AI contract — rides in with the app-gen tools via the same
+    // semantic selection that includes them. Collected by toolSetSystemPrompts.
+    systemPrompt: APP_BUILDER_PROMPT,
+    // Must stay in sync with APP_FILE_TOOL_NAMES in src/tools/appGeneration.ts.
+    // If a new app-gen tool ships there but isn't added here, semantic
+    // selection will exclude it on every request — the model literally
+    // doesn't see it. The quality tools (audit_design / critique_design /
+    // verify_app) are non-obvious to a user prompt ("build me a kanban")
+    // and rely entirely on set expansion to reach the model.
+    members: [
+      "create_file",
+      "patch_file",
+      "delete_file",
+      "read_file",
+      "list_files",
+      "audit_design",
+      "critique_design",
+      "verify_app"
+    ],
+    // Anchors stay limited to the primary entry-point tools. Users phrase
+    // app intent as "build / make / fix" → semantic match on create_file
+    // or patch_file → full set pulled in. The quality tools fire later in
+    // the workflow and don't anchor on their own; including them as
+    // anchors would risk pulling the set in on unrelated "audit my code"
+    // prompts that have nothing to do with app generation.
+    anchors: ["create_file", "patch_file"],
+    // 0.55: above the global filter floor (0.53) so a barely-relevant match
+    // can't pull in the whole toolkit, but no higher — and we tried higher.
+    // create_file scores chitchat ("what's up" ~0.56, "...about programming"
+    // ~0.57) in the SAME band as legitimate app-EDIT prompts: "Edit the app to
+    // change the background…" measured create_file 0.56 on one e2e run. Raising
+    // the floor to 0.575 to exclude the chitchat therefore also stripped the
+    // file tools from real edit requests — leaving the model unable to touch the
+    // app at all. The bands genuinely overlap; there is no clean cut. So we keep
+    // 0.55 (max recall) and rely on two safety nets instead: APP_BUILDER_PROMPT
+    // is conditional (it no-ops unless the user is actually asking for an app),
+    // and very short greetings ("hey") are filtered out earlier by the
+    // MIN_CONTENT_LENGTH_FOR_TOOLS length gate before embeddings even run.
+    anchorMinSimilarity: 0.55
+  },
+  {
+    name: "slides",
+    members: ["plan_deck", "add_slide", "read_slides", "patch_slides"],
+    anchors: ["plan_deck", "patch_slides"],
+    // Match the client-tool floor (0.53). Short colloquial prompts like
+    // "make me a powerpoint about X" score plan_deck around 0.535 — above
+    // the global floor but inside any anchor gap. plan_deck and patch_slides
+    // are specific enough names that 0.53 won't false-positive in practice.
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "documents",
+    // Conditional rider (no-ops unless the user actually asks for a document),
+    // attached so the Document Builder guidance rides in with the document
+    // tools via the same semantic selection that includes them.
+    systemPrompt: DOCUMENT_BUILDER_PROMPT,
+    members: ["create_document", "read_document", "patch_document"],
+    // Entry-point tools anchor; read_document rides in via set expansion.
+    anchors: ["create_document", "patch_document"],
+    // 0.53: match the client-tool floor. "draft me a contract", "write a cover
+    // letter", "make a memo" should pull the set in. Like app-gen's create_file,
+    // document intent ("write me X") overlaps generic chitchat in this band, so
+    // the same two safety nets apply: DOCUMENT_BUILDER_PROMPT is conditional and
+    // the MIN_CONTENT_LENGTH_FOR_TOOLS gate drops bare greetings before
+    // embeddings run. Tune empirically against the tool-selection parity suite.
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "github",
+    members: ["github_get_authenticated_user", "github_api"],
+    anchors: ["github_api"],
+    anchorMinSimilarity: 0.55
+  },
+  // Connector sets (#587). Connector chat tools belong to no set, so per-message
+  // semantic filtering silently prunes them on vague prompts ("check my email").
+  // Grouping each connector's tools behind a search/action anchor keeps the
+  // whole connector reachable once any one of its tools matches. Mirrors github:
+  // no systemPrompt rider — per-set prompt guidance is a follow-up.
+  {
+    name: "gmail",
+    members: [
+      "gmail_search_messages",
+      "gmail_get_message",
+      "gmail_create_draft",
+      "gmail_send_message"
+    ],
+    anchors: ["gmail_search_messages", "gmail_send_message"],
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "google-calendar",
+    members: [
+      "google_calendar_list_events",
+      "google_calendar_create_event",
+      "google_calendar_update_event"
+    ],
+    anchors: ["google_calendar_list_events", "google_calendar_create_event"],
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "google-drive",
+    members: [
+      "google_drive_search",
+      "google_drive_list_recent",
+      "google_drive_get_content",
+      "google_drive_create_file",
+      "google_drive_update_file"
+    ],
+    anchors: ["google_drive_search", "google_drive_get_content", "google_drive_create_file"],
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "notion",
+    members: ["notion-search", "notion-fetch", "notion-create-pages", "notion-update-page"],
+    anchors: ["notion-search", "notion-create-pages"],
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "x",
+    members: ["x_get_me", "x_get_my_posts"],
+    anchors: ["x_get_me", "x_get_my_posts"],
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "slack",
+    members: [
+      "slack_get_me",
+      "slack_list_channels",
+      "slack_search_messages",
+      "slack_list_users",
+      "slack_get_channel_history",
+      "slack_get_thread_replies",
+      "slack_post_message"
+    ],
+    // search is the primary entry point; list_channels also anchors so "what
+    // channels am I in" reaches the set without going through search. post_message
+    // anchors too so post-only prompts surface the write tool past the cutoff.
+    anchors: ["slack_search_messages", "slack_list_channels", "slack_post_message"],
+    anchorMinSimilarity: 0.53
+  },
+  {
+    name: "dropbox",
+    members: ["dropbox_list_folders", "dropbox_get_file_content", "dropbox_search"],
+    anchors: ["dropbox_list_folders", "dropbox_search"],
+    anchorMinSimilarity: 0.53
+  }
+];
+function applyToolSets(matchedNames, availableNames, scores, toolSets = BUILT_IN_TOOL_SETS, independentThreshold = 0.65) {
+  const activatedSets = [];
+  for (const ts of toolSets) {
+    const minSim = ts.anchorMinSimilarity ?? 0.6;
+    const triggered = ts.anchors.some(
+      (anchor) => matchedNames.has(anchor) && (scores.get(anchor) ?? 0) >= minSim
+    );
+    if (triggered) activatedSets.push(ts);
+  }
+  if (activatedSets.length === 0) return matchedNames;
+  const setMembers = /* @__PURE__ */ new Set();
+  for (const ts of activatedSets) {
+    for (const member of ts.members) setMembers.add(member);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const member of setMembers) {
+    if (availableNames.has(member)) {
+      result.add(member);
+    }
+  }
+  for (const name of matchedNames) {
+    if (setMembers.has(name)) continue;
+    const score = scores.get(name) ?? 0;
+    if (score >= independentThreshold) {
+      result.add(name);
+    }
+  }
+  return result;
+}
+function expandToolSetsAdditive(matchedNames, availableNames, scores, toolSets, activeSetNames) {
+  const result = new Set(matchedNames);
+  for (const ts of toolSets) {
+    let triggered = activeSetNames?.has(ts.name) ?? false;
+    if (!triggered) {
+      const minSim = ts.anchorMinSimilarity ?? 0.6;
+      triggered = ts.anchors.some((a) => (scores.get(a) ?? 0) >= minSim);
+    }
+    if (!triggered) continue;
+    for (const member of ts.members) {
+      if (availableNames.has(member)) {
+        result.add(member);
+      }
+    }
+  }
+  return result;
+}
+function activatedToolSetNames(scores, toolSets = BUILT_IN_TOOL_SETS, activeSetNames) {
+  const activated = /* @__PURE__ */ new Set();
+  for (const ts of toolSets) {
+    if (activeSetNames?.has(ts.name)) {
+      activated.add(ts.name);
+      continue;
+    }
+    const minSim = ts.anchorMinSimilarity ?? 0.6;
+    if (ts.anchors.some((a) => (scores.get(a) ?? 0) >= minSim)) {
+      activated.add(ts.name);
+    }
+  }
+  return activated;
+}
+function toolSetSystemPrompts(selectedToolNames, toolSets = BUILT_IN_TOOL_SETS, activatedSetNames) {
+  const selected = selectedToolNames instanceof Set ? selectedToolNames : new Set(selectedToolNames);
+  const prompts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ts of toolSets) {
+    const prompt = ts.systemPrompt;
+    if (!prompt || seen.has(prompt)) continue;
+    const active = activatedSetNames ? activatedSetNames.has(ts.name) : ts.anchors.some((anchor) => selected.has(anchor));
+    if (active) {
+      prompts.push(prompt);
+      seen.add(prompt);
+    }
+  }
+  return prompts;
+}
+function createServerToolsFilter(options = {}) {
+  const exclude = new Set(options.excludeTools ?? []);
+  const sets = options.toolSets ?? [];
+  const matchOpts = options.matchOptions;
+  return (embeddings, tools) => {
+    const matches = findMatchingTools(embeddings, tools, matchOpts);
+    if (matches.length === 0) return [];
+    const matchedNames = new Set(matches.map((m) => m.tool.name));
+    let finalNames;
+    if (sets.length > 0) {
+      const scores = scoreTools(embeddings, tools);
+      const selectedScores = new Map(
+        [...scores].filter(([name]) => matchedNames.has(name) && !exclude.has(name))
+      );
+      const availableNames = new Set(tools.map((t) => t.name));
+      finalNames = expandToolSetsAdditive(matchedNames, availableNames, selectedScores, sets);
+    } else {
+      finalNames = matchedNames;
+    }
+    for (const name of exclude) finalNames.delete(name);
+    return [...finalNames];
+  };
+}
+var DEFAULT_EXCLUDED_SERVER_TOOLS = [
+  "AnumaVisionMCP-anuma_analyze_image",
+  "OpenMeteoMCP-weather_forecast",
+  // Same native-capability argument as the vision tool: modern models reason
+  // step-by-step natively (and reasoning-mode models do it structurally), so
+  // a server-side sequential-thinking tool is a redundant hop. Its broad
+  // description also embeds near virtually every prompt — observed live
+  // riding into news-search, scheduling, and chitchat requests.
+  "AnumaSequentialThinkingMCP-sequentialthinking"
+];
+var DEFAULT_SERVER_TOOLS_MATCH_OPTIONS = {
+  limit: 5,
+  minSimilarity: 0.5
+};
+var SERVER_TOOL_DEPENDENCY_SETS = [
+  {
+    // search finds links; reading them is always the next step.
+    name: "jina-research",
+    members: [
+      "AnumaJinaMCP-search_web",
+      "AnumaJinaMCP-read_url",
+      "AnumaJinaMCP-parallel_read_url",
+      "AnumaJinaMCP-parallel_search_web"
+    ],
+    anchors: ["AnumaJinaMCP-search_web"],
+    // Activation floor = the selection floor (0.5), not the 0.6 ToolSet
+    // default. A dependency edge has different semantics from a persona-style
+    // tool set: if the entry tool is plausibly offered at all, the chain must
+    // ride along — "Search the web for recent news…" scores search_web in the
+    // 0.5–0.6 band, and shipping search without read would dead-end the model.
+    anchorMinSimilarity: 0.5
+  },
+  {
+    // Every OpenMeteo data tool requires latitude/longitude (verified in the
+    // catalog schemas), but users speak in place names — geocoding is the
+    // mandatory first hop. Members deliberately contain ONLY the dependency:
+    // the anchor that fired is already in the semantic matches, and pulling
+    // sibling data tools in would re-create vendor-suite over-inclusion.
+    // Excluded tools (e.g. weather_forecast under the default filter) can't
+    // anchor this set — createServerToolsFilter drops them before expansion —
+    // but the non-weather data tools still deliver geocoding when they match.
+    name: "openmeteo-geocode",
+    members: ["OpenMeteoMCP-geocoding"],
+    anchors: [
+      "OpenMeteoMCP-weather_forecast",
+      "OpenMeteoMCP-air_quality",
+      "OpenMeteoMCP-weather_archive",
+      "OpenMeteoMCP-marine_weather",
+      "OpenMeteoMCP-flood_forecast",
+      "OpenMeteoMCP-climate_projection",
+      "OpenMeteoMCP-elevation"
+    ],
+    anchorMinSimilarity: 0.5
+  }
+];
+var defaultServerToolsFilter = createServerToolsFilter({
+  excludeTools: DEFAULT_EXCLUDED_SERVER_TOOLS,
+  matchOptions: DEFAULT_SERVER_TOOLS_MATCH_OPTIONS,
+  toolSets: SERVER_TOOL_DEPENDENCY_SETS
+});
+async function selectServerToolsForPrompt(options) {
+  const {
+    prompt,
+    serverToolsFilter,
+    getToken,
+    baseUrl,
+    embeddingModel,
+    cacheExpirationMs,
+    cache,
+    deferLoading
+  } = options;
+  if (serverToolsFilter === void 0) return [];
+  if (Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0) return [];
+  let allServerTools;
+  try {
+    allServerTools = await getServerTools({ baseUrl, cacheExpirationMs, getToken, cache });
+  } catch {
+    return [];
+  }
+  if (allServerTools.length === 0) return [];
+  if (deferLoading?.enabled) return allServerTools;
+  if (typeof serverToolsFilter === "function") {
+    if (prompt.length < MIN_CONTENT_LENGTH_FOR_TOOLS) return [];
+    let promptEmbedding;
+    try {
+      promptEmbedding = await generateEmbedding(prompt, {
+        getToken,
+        baseUrl,
+        model: embeddingModel
+      });
+    } catch {
+      return [];
+    }
+    const names = serverToolsFilter(promptEmbedding, allServerTools);
+    return filterServerTools(allServerTools, names);
+  }
+  return filterServerTools(allServerTools, serverToolsFilter);
+}
+async function selectServerSideTools(options) {
+  const {
+    prompt,
+    getToken,
+    apiKey,
+    baseUrl,
+    cacheExpirationMs,
+    forceRefresh,
+    embeddingModel,
+    limit,
+    minSimilarity,
+    apiType = "responses"
+  } = options;
+  if (!getToken && !apiKey) {
+    throw new Error("Either getToken or apiKey must be provided");
+  }
+  if (!prompt || prompt.trim().length < MIN_CONTENT_LENGTH_FOR_TOOLS) {
+    return [];
+  }
+  const tools = await getServerTools({
+    getToken,
+    apiKey,
+    baseUrl,
+    cacheExpirationMs,
+    forceRefresh
+  });
+  if (tools.length === 0) {
+    return [];
+  }
+  const embeddingOptions = {
+    getToken,
+    apiKey,
+    baseUrl,
+    model: embeddingModel
+  };
+  let promptEmbeddings;
+  if (shouldChunkMessage(prompt, DEFAULT_CHUNK_SIZE)) {
+    const chunks = chunkText(prompt);
+    promptEmbeddings = await generateEmbeddings(
+      chunks.map((c) => c.text),
+      embeddingOptions
+    );
+  } else {
+    promptEmbeddings = await generateEmbedding(prompt, embeddingOptions);
+  }
+  const matchOptions = { filterAmbiguous: true, relevanceRatio: 0.85 };
+  if (limit !== void 0) matchOptions.limit = limit;
+  if (minSimilarity !== void 0) matchOptions.minSimilarity = minSimilarity;
+  const matches = findMatchingTools(promptEmbeddings, tools, matchOptions);
+  if (matches.length === 0) {
+    return [];
+  }
+  const matchedTools = matches.map((m) => m.tool);
+  if (apiType === "completions") {
+    return matchedTools.map((t) => toCompletionsFormat(t));
+  }
+  return matchedTools.map(toResponsesFormat);
+}
+
+// src/lib/tools/clientToolSelection.ts
+function getToolName(t) {
+  const fn = t.function;
+  return fn?.name || t.name || "";
+}
+function getToolDescription(t) {
+  const fn = t.function;
+  return fn?.description || t.description || getToolName(t);
+}
+function computeToolGuidance(selectedServerTools, selectedClientTools, extraToolSets, activatedSetNames) {
+  const names = [
+    ...selectedServerTools.map((t) => t.name),
+    ...(selectedClientTools ?? []).map(getToolName)
+  ].filter(Boolean);
+  const toolSets = extraToolSets.length > 0 ? [...BUILT_IN_TOOL_SETS, ...extraToolSets] : BUILT_IN_TOOL_SETS;
+  const prompts = toolSetSystemPrompts(names, toolSets, activatedSetNames);
+  return prompts.length > 0 ? prompts.join("\n\n") : void 0;
+}
+async function autoFilterClientTools(clientTools, promptEmbeddings, cache, embeddingOptions, extraToolSets = [], activeToolSets = [], noEmbeddingsReason = "short-prompt") {
+  const isMemoryTool = (t) => {
+    const name = getToolName(t);
+    return name.startsWith("memory_vault_") || name === RECALL_TOOL_NAME;
+  };
+  const alwaysInclude = clientTools.filter(isMemoryTool);
+  const filterCandidates = clientTools.filter((t) => !isMemoryTool(t));
+  if (filterCandidates.length === 0) {
+    return { tools: clientTools, activatedSetNames: /* @__PURE__ */ new Set() };
+  }
+  if (!promptEmbeddings && noEmbeddingsReason === "error") {
+    return { tools: clientTools, activatedSetNames: /* @__PURE__ */ new Set() };
+  }
+  if (!promptEmbeddings) {
+    if (activeToolSets.length === 0) {
+      return { tools: [], activatedSetNames: /* @__PURE__ */ new Set() };
+    }
+    const allSets = extraToolSets.length > 0 ? [...BUILT_IN_TOOL_SETS, ...extraToolSets] : BUILT_IN_TOOL_SETS;
+    const activeSets = allSets.filter((s) => activeToolSets.includes(s.name));
+    const stickyMembers = new Set(activeSets.flatMap((s) => s.members));
+    return {
+      tools: [
+        ...alwaysInclude,
+        ...filterCandidates.filter((t) => stickyMembers.has(getToolName(t)))
+      ],
+      activatedSetNames: new Set(activeSets.map((s) => s.name))
+    };
+  }
+  const toolsNeedingEmbeddings = [];
+  for (const t of filterCandidates) {
+    const name = getToolName(t);
+    if (name && !cache.has(name)) {
+      toolsNeedingEmbeddings.push({ name, description: getToolDescription(t) });
+    }
+  }
+  if (toolsNeedingEmbeddings.length > 0) {
+    try {
+      const descriptions = toolsNeedingEmbeddings.map((t) => t.description);
+      const embeddings = await generateEmbeddings(descriptions, embeddingOptions);
+      for (let i = 0; i < toolsNeedingEmbeddings.length; i++) {
+        cache.set(toolsNeedingEmbeddings[i].name, embeddings[i]);
+      }
+    } catch {
+      return { tools: clientTools, activatedSetNames: /* @__PURE__ */ new Set() };
+    }
+  }
+  const pseudoServerTools = [];
+  for (const t of filterCandidates) {
+    const name = getToolName(t);
+    const embedding = cache.get(name);
+    if (!embedding) continue;
+    const fn = t.function;
+    const params = fn?.parameters || fn?.arguments || {
+      type: "object",
+      properties: {},
+      required: []
+    };
+    pseudoServerTools.push({
+      type: "function",
+      name,
+      description: getToolDescription(t),
+      parameters: params,
+      embedding
+    });
+  }
+  const matches = findMatchingTools(promptEmbeddings, pseudoServerTools, {
+    limit: MAX_CLIENT_TOOLS_AFTER_FILTER,
+    minSimilarity: CLIENT_TOOLS_MIN_SIMILARITY,
+    filterAmbiguous: true,
+    // See CLIENT_TOOLS_RELEVANCE_RATIO: 0.75 admits the second intent of a
+    // multi-intent prompt (which lands ~75-80% of the dominant match), while
+    // still trimming the loose tail. The earlier 0.9 made a second intent
+    // structurally unselectable; the anchorMinSimilarity gates (0.53-0.55)
+    // remain the guard against borderline anchors activating a whole set.
+    relevanceRatio: CLIENT_TOOLS_RELEVANCE_RATIO
+  });
+  const matchedNames = new Set(matches.map((m) => m.tool.name));
+  const scores = scoreTools(promptEmbeddings, pseudoServerTools);
+  const availableNames = new Set(filterCandidates.map(getToolName));
+  const toolSets = extraToolSets.length > 0 ? [...BUILT_IN_TOOL_SETS, ...extraToolSets] : BUILT_IN_TOOL_SETS;
+  const activeSetNames = activeToolSets.length > 0 ? new Set(activeToolSets) : void 0;
+  const finalNames = expandToolSetsAdditive(
+    matchedNames,
+    availableNames,
+    scores,
+    toolSets,
+    activeSetNames
+  );
+  const activatedSetNames = activatedToolSetNames(scores, toolSets, activeSetNames);
+  if (finalNames.size === 0) {
+    return { tools: alwaysInclude, activatedSetNames };
+  }
+  const filtered = filterCandidates.filter((t) => {
+    const name = getToolName(t);
+    return name && finalNames.has(name);
+  });
+  return { tools: [...alwaysInclude, ...filtered], activatedSetNames };
+}
+
+// src/lib/tools/toolCatalog.ts
+var TOOL_CATALOG = {
+  // Gmail (src/tools/gmail.ts)
+  gmail_search_messages: { label: "Search emails", provider: "gmail", connector: "Gmail" },
+  gmail_get_message: { label: "Read an email", provider: "gmail", connector: "Gmail" },
+  gmail_create_draft: { label: "Draft a reply", provider: "gmail", connector: "Gmail" },
+  gmail_send_message: { label: "Send an email", provider: "gmail", connector: "Gmail" },
+  // Google Calendar (src/tools/googleCalendar.ts)
+  google_calendar_list_events: {
+    label: "Search calendar events",
+    provider: "gcalendar",
+    connector: "Calendar"
+  },
+  google_calendar_create_event: {
+    label: "Create calendar event",
+    provider: "gcalendar",
+    connector: "Calendar"
+  },
+  google_calendar_update_event: {
+    label: "Update calendar event",
+    provider: "gcalendar",
+    connector: "Calendar"
+  },
+  // Google Drive (src/tools/googleDrive.ts)
+  google_drive_search: { label: "Search files", provider: "gdrive", connector: "Drive" },
+  google_drive_list_recent: { label: "List recent files", provider: "gdrive", connector: "Drive" },
+  google_drive_get_content: { label: "Read file content", provider: "gdrive", connector: "Drive" },
+  google_drive_create_file: {
+    label: "Create a file in Drive",
+    provider: "gdrive",
+    connector: "Drive"
+  },
+  google_drive_update_file: {
+    label: "Update a Drive file",
+    provider: "gdrive",
+    connector: "Drive"
+  },
+  // Notion (src/tools/notion.ts)
+  "notion-search": { label: "Search", provider: "notion", connector: "Notion" },
+  "notion-fetch": { label: "Read page", provider: "notion", connector: "Notion" },
+  "notion-create-pages": { label: "Create page", provider: "notion", connector: "Notion" },
+  "notion-update-page": { label: "Update page", provider: "notion", connector: "Notion" },
+  "notion-move-pages": { label: "Move pages", provider: "notion", connector: "Notion" },
+  "notion-duplicate-page": { label: "Duplicate page", provider: "notion", connector: "Notion" },
+  "notion-create-database": { label: "Create database", provider: "notion", connector: "Notion" },
+  "notion-update-data-source": {
+    label: "Update data source",
+    provider: "notion",
+    connector: "Notion"
+  },
+  "notion-create-comment": { label: "Add a comment", provider: "notion", connector: "Notion" },
+  "notion-get-comments": { label: "Read comments", provider: "notion", connector: "Notion" },
+  "notion-get-users": {
+    label: "List workspace members",
+    provider: "notion",
+    connector: "Notion"
+  },
+  "notion-get-teams": { label: "List teamspaces", provider: "notion", connector: "Notion" },
+  // GitHub (src/tools/github.ts)
+  github_api: { label: "Use GitHub", provider: "github", connector: "GitHub" },
+  github_get_authenticated_user: {
+    label: "Read GitHub profile",
+    provider: "github",
+    connector: "GitHub"
+  },
+  // X / Twitter (src/tools/x.ts)
+  x_get_me: { label: "Get my X profile", provider: "x", connector: "X" },
+  x_get_my_posts: { label: "Read my recent posts", provider: "x", connector: "X" },
+  // Dropbox (src/tools/dropbox.ts)
+  dropbox_list_folders: { label: "List files", provider: "dropbox", connector: "Dropbox" },
+  dropbox_get_file_content: {
+    label: "Read file content",
+    provider: "dropbox",
+    connector: "Dropbox"
+  },
+  dropbox_search: { label: "Search files", provider: "dropbox", connector: "Dropbox" },
+  // Slack (src/tools/slack.ts)
+  slack_get_me: { label: "Get my Slack profile", provider: "slack", connector: "Slack" },
+  slack_list_channels: { label: "List channels", provider: "slack", connector: "Slack" },
+  slack_list_dms: { label: "List direct messages", provider: "slack", connector: "Slack" },
+  slack_search_messages: { label: "Search messages", provider: "slack", connector: "Slack" },
+  slack_list_users: { label: "List members", provider: "slack", connector: "Slack" },
+  slack_get_channel_history: {
+    label: "Read channel history",
+    provider: "slack",
+    connector: "Slack"
+  },
+  slack_get_thread_replies: {
+    label: "Read thread replies",
+    provider: "slack",
+    connector: "Slack"
+  },
+  slack_post_message: { label: "Post a message", provider: "slack", connector: "Slack" }
+};
+function buildDeniedToolsRider(deniedToolNames) {
+  const byConnector = /* @__PURE__ */ new Map();
+  for (const name of deniedToolNames) {
+    const entry = TOOL_CATALOG[name];
+    if (!entry) continue;
+    const labels = byConnector.get(entry.connector) ?? [];
+    labels.push(entry.label);
+    byConnector.set(entry.connector, labels);
+  }
+  if (byConnector.size === 0) return "";
+  const groups = [...byConnector.entries()].sort(([a], [b]) => a.localeCompare(b)).map(
+    ([connector, labels]) => `- ${connector}: ${[...labels].sort((a, b) => a.localeCompare(b)).join(", ")}`
+  ).join("\n");
+  return [
+    "The user has turned off the following connector capabilities:",
+    groups,
+    "If the user asks you to use one of these, do not attempt it. Tell them the specific capability is turned off and that they can re-enable that exact tool in their Connected Apps settings."
+  ].join("\n");
+}
+function toolName(tool) {
+  const record = tool;
+  const func = record.function;
+  if (typeof func?.name === "string") return func.name;
+  if (typeof record.name === "string") return record.name;
+  return void 0;
+}
+function catalogConnectorsByProvider() {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const entry of Object.values(TOOL_CATALOG)) {
+    byProvider.set(entry.provider, entry.connector);
+  }
+  return byProvider;
+}
+function buildConnectorGuidance(input) {
+  const denied = new Set(input.deniedToolNames);
+  const connected = new Set(input.connectedProviders);
+  const tools = input.tools.filter((tool) => {
+    const name = toolName(tool);
+    return name === void 0 || !denied.has(name);
+  });
+  const deniedByConnector = /* @__PURE__ */ new Map();
+  for (const name of denied) {
+    const entry = TOOL_CATALOG[name];
+    if (!entry || !connected.has(entry.provider)) continue;
+    const labels = deniedByConnector.get(entry.connector) ?? [];
+    labels.push(entry.label);
+    deniedByConnector.set(entry.connector, labels);
+  }
+  const unconnected = /* @__PURE__ */ new Set();
+  for (const [provider, connector] of catalogConnectorsByProvider()) {
+    if (!connected.has(provider)) unconnected.add(connector);
+  }
+  const sections = [];
+  if (deniedByConnector.size > 0) {
+    const groups = [...deniedByConnector.entries()].sort(([a], [b]) => a.localeCompare(b)).map(
+      ([connector, labels]) => `On ${connector}, these are turned off: ${[...labels].sort((a, b) => a.localeCompare(b)).join(", ")}.`
+    ).join("\n");
+    sections.push(
+      `${groups}
+If the user asks to use one of these, tell them it's turned off and they can re-enable it in Connected Apps.`
+    );
+  }
+  if (unconnected.size > 0) {
+    const list = [...unconnected].sort((a, b) => a.localeCompare(b)).join(", ");
+    sections.push(
+      `Not connected: ${list}. If the user asks to use them, tell them to connect them in Connected Apps.`
+    );
+  }
+  if (sections.length > 0 && connected.size > 0) {
+    sections.push(
+      "Never tell the user you lack access to a connected app; if you can't find a tool for a connected app's request, say that specific capability isn't available yet rather than that the app isn't connected."
+    );
+  }
+  return { tools, rider: sections.join("\n\n") };
+}
+
+// src/lib/tools/selection/activeToolSets.ts
+function phaseMatchesMember(phaseId, member) {
+  if (!phaseId) return false;
+  return phaseId === member || phaseId.endsWith(`-${member}`) || phaseId.includes(`-${member}-`);
+}
+function eventMatchesMember(event, member) {
+  if (event.kind === "tool-result") {
+    return !!event.toolName && event.toolName === member;
+  }
+  return !!event.phaseId && phaseMatchesMember(event.phaseId, member);
+}
+function deriveActiveToolSets(events, sets = BUILT_IN_TOOL_SETS) {
+  const active = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    for (const ts of sets) {
+      if (active.has(ts.name)) continue;
+      if (ts.members.some((member) => eventMatchesMember(event, member))) {
+        active.add(ts.name);
+      }
+    }
+    if (active.size === sets.length) break;
+  }
+  return [...active];
+}
+function mergeActiveToolSets(current, derived) {
+  if (derived.length === 0) return current;
+  const merged = Array.from(/* @__PURE__ */ new Set([...current, ...derived]));
+  return merged.length === current.length ? current : merged;
+}
+
+// src/lib/tools/selection/assembleClientTools.ts
+function assembleClientTools(spec, adapters) {
+  const out = [];
+  for (const key of spec.clientFactories) {
+    const build = adapters.builders[key];
+    if (!build) continue;
+    try {
+      const tools = build();
+      if (tools?.length) out.push(...tools);
+    } catch (err) {
+      adapters.logger?.error(`[assembleClientTools] factory "${key}" threw; skipping`, err);
+    }
+  }
+  return out;
+}
+function filterAssembledClientTools(tools, mode, opts) {
+  if (typeof mode === "function") return mode(tools);
+  if (mode === "include-all" || mode === "auto") return tools;
+  const names = opts?.slideEditorToolNames;
+  if (!names) return [];
+  const getName = opts?.getName ?? ((t) => getToolName(t));
+  return tools.filter((t) => names.has(getName(t)));
+}
+
+// src/lib/tools/selection/intents.ts
+var FULL_GENERATIVE_CLIENT_FACTORIES = [
+  "memory",
+  "connectors",
+  "slides",
+  "app",
+  "document",
+  "ui",
+  "saved",
+  "background",
+  "schedule"
+];
+var CREATION_INTENT_CLIENT_FACTORIES = {
+  plain: FULL_GENERATIVE_CLIENT_FACTORIES,
+  image: FULL_GENERATIVE_CLIENT_FACTORIES,
+  audio: FULL_GENERATIVE_CLIENT_FACTORIES,
+  music: FULL_GENERATIVE_CLIENT_FACTORIES,
+  sfx: FULL_GENERATIVE_CLIENT_FACTORIES,
+  video: FULL_GENERATIVE_CLIENT_FACTORIES,
+  "remove-image-bg": FULL_GENERATIVE_CLIENT_FACTORIES,
+  document: FULL_GENERATIVE_CLIENT_FACTORIES,
+  "web-search": FULL_GENERATIVE_CLIENT_FACTORIES,
+  "deep-research": FULL_GENERATIVE_CLIENT_FACTORIES,
+  // Builder modes: restrict to their own toolkit; a `saved` toolkit rides
+  // along on app builds (parity with web's app branch).
+  app: ["app", "saved"],
+  slides: ["slides"]
+};
+var CREATION_INTENT_CLIENT_FILTER = {
+  plain: "auto",
+  image: "auto",
+  audio: "auto",
+  music: "auto",
+  sfx: "auto",
+  video: "auto",
+  "remove-image-bg": "auto",
+  document: "auto",
+  "web-search": "auto",
+  "deep-research": "auto",
+  app: "include-all",
+  slides: "include-all"
+};
+var CREATION_INTENT_TOOL_SET = {
+  app: "app-generation",
+  slides: "slides",
+  document: "documents"
+};
+
+// src/lib/tools/selection/sendPolicy.ts
+var MEMORY_SAVE_TOOL_NAME = "memory_vault_save";
+function resolveToolChoice(serverTools, explicit) {
+  if (explicit) return explicit;
+  if (Array.isArray(serverTools)) return serverTools.length > 0 ? "required" : "auto";
+  return "auto";
+}
+function getMaxToolRounds(entry, fallback) {
+  return entry?.maxToolRounds ?? fallback;
+}
+function getThinkingMode(entry, fallback) {
+  return entry?.thinkingMode ?? fallback;
+}
+function stripCoercedMemoryWrite(clientTools, toolChoice) {
+  if (toolChoice !== "required") return clientTools;
+  const filtered = clientTools.filter((t) => getToolName(t) !== MEMORY_SAVE_TOOL_NAME);
+  return filtered.length === clientTools.length ? clientTools : filtered;
+}
+
+// src/lib/tools/selection/serverToolsPolicy.ts
+function getCatalogEntry(descriptor, catalog) {
+  if (descriptor.lane === "council" || descriptor.lane === "aggregation") {
+    return catalog[descriptor.lane];
+  }
+  return catalog[descriptor.creation];
+}
+function resolveServerTools(descriptor, catalog, fallback = []) {
+  const entry = getCatalogEntry(descriptor, catalog);
+  if (!entry) return fallback;
+  if (entry.resolveServerTools) {
+    return entry.resolveServerTools({ attachments: descriptor.attachments });
+  }
+  return entry.serverTools ?? fallback;
+}
+function isCoercingIntent(creation, catalog) {
+  const entry = catalog[creation];
+  if (!entry) return false;
+  const slot = entry.serverTools;
+  return Array.isArray(slot) && slot.length > 0;
+}
+
+// src/lib/tools/selection/plan.ts
+var BUILDER_INTENTS = /* @__PURE__ */ new Set(["app", "slides"]);
+function resolvePlan(descriptor, ctx) {
+  const { catalog } = ctx;
+  const entry = getCatalogEntry(descriptor, catalog);
+  if (descriptor.lane === "council" || descriptor.lane === "aggregation") {
+    const serverTools2 = resolveServerTools(descriptor, catalog);
+    return {
+      clientFactories: [],
+      clientToolsFilter: "auto",
+      serverTools: serverTools2,
+      forcedServerTools: entry?.forcedServerTools,
+      activeToolSets: descriptor.activeToolSets ? [...descriptor.activeToolSets] : [],
+      toolChoice: resolveToolChoice(serverTools2, entry?.toolChoice),
+      maxToolRounds: getMaxToolRounds(entry, ctx.defaultMaxToolRounds),
+      thinkingMode: getThinkingMode(entry, ctx.defaultThinkingMode),
+      systemPromptRiders: entry?.systemPrompt ? [entry.systemPrompt] : [],
+      postFilters: []
+    };
+  }
+  const { creation } = descriptor;
+  const isBuilder = BUILDER_INTENTS.has(creation);
+  const editorSlideOverlay = descriptor.editorPinned === "slides" && !isBuilder;
+  const slideDeckIntent = descriptor.slideDeckIntent === true && descriptor.imageEditIntent !== true;
+  let serverTools = resolveServerTools(descriptor, catalog);
+  const clientFactories = [...CREATION_INTENT_CLIENT_FACTORIES[creation]];
+  let clientToolsFilter = entry?.clientToolsFilter ?? CREATION_INTENT_CLIENT_FILTER[creation];
+  const slideEntry = catalog.slides;
+  if (editorSlideOverlay && slideEntry) {
+    clientToolsFilter = "slide-editor";
+    serverTools = resolveServerTools({ ...descriptor, creation: "slides" }, catalog);
+  }
+  const effectiveEntry = editorSlideOverlay && slideEntry ? slideEntry : entry;
+  const activeToolSets = new Set(descriptor.activeToolSets ?? []);
+  const builderSet = CREATION_INTENT_TOOL_SET[creation];
+  if (builderSet) activeToolSets.add(builderSet);
+  if (slideDeckIntent) activeToolSets.add("slides");
+  if (editorSlideOverlay) activeToolSets.add("slides");
+  const forceAuto = isBuilder || slideDeckIntent || editorSlideOverlay;
+  const toolChoice = forceAuto ? "auto" : resolveToolChoice(serverTools, effectiveEntry?.toolChoice);
+  const systemPromptRiders = [];
+  if (effectiveEntry?.systemPrompt) systemPromptRiders.push(effectiveEntry.systemPrompt);
+  if (slideDeckIntent && slideEntry?.systemPrompt && creation !== "slides" && !systemPromptRiders.includes(slideEntry.systemPrompt)) {
+    systemPromptRiders.push(slideEntry.systemPrompt);
+  }
+  const postFilters = [];
+  if (toolChoice === "required") postFilters.push("strip-memory-save-when-coerced");
+  if (ctx.memoryIntent?.retrieval) postFilters.push("strip-memory-save-on-retrieval-intent");
+  if (ctx.memoryIntent?.save) postFilters.push("strip-server-tools-on-save-intent");
+  return {
+    clientFactories,
+    clientToolsFilter,
+    serverTools,
+    forcedServerTools: effectiveEntry?.forcedServerTools,
+    activeToolSets: [...activeToolSets],
+    toolChoice,
+    maxToolRounds: getMaxToolRounds(effectiveEntry, ctx.defaultMaxToolRounds),
+    thinkingMode: getThinkingMode(effectiveEntry, ctx.defaultThinkingMode),
+    systemPromptRiders,
+    postFilters
+  };
+}
+
+// src/lib/tools/selection/council.ts
+function resolveCouncilPlan(descriptor, ctx) {
+  const lane = descriptor.lane === "aggregation" ? "aggregation" : "council";
+  return resolvePlan({ ...descriptor, lane }, ctx);
+}
+function resolveCouncilServerTools(descriptor, ctx) {
+  return resolveCouncilPlan(descriptor, ctx).serverTools;
+}
+function composeCouncilClientTools(input) {
+  const memory = input.canPersistMemory ? input.memoryTools : input.memoryTools.filter((t) => {
+    const fn = t.function;
+    const name = fn?.name ?? t.name ?? "";
+    return name !== MEMORY_SAVE_TOOL_NAME;
+  });
+  return [...memory, ...input.sharedTools ?? []];
+}
+async function selectCouncilClientTools(input, options) {
+  const candidates = composeCouncilClientTools(input);
+  return autoFilterClientTools(
+    candidates,
+    options.promptEmbeddings,
+    options.cache,
+    options.embeddingOptions,
+    options.extraToolSets ?? [],
+    options.activeToolSets ?? [],
+    options.noEmbeddingsReason ?? "short-prompt"
+  );
+}
+export {
+  BUILT_IN_TOOL_SETS,
+  CLIENT_TOOLS_MIN_SIMILARITY,
+  CLIENT_TOOLS_RELEVANCE_RATIO,
+  CREATION_INTENT_CLIENT_FACTORIES,
+  CREATION_INTENT_CLIENT_FILTER,
+  CREATION_INTENT_TOOL_SET,
+  DEFAULT_CACHE_EXPIRATION_MS,
+  DEFAULT_EXCLUDED_SERVER_TOOLS,
+  DEFAULT_SERVER_TOOLS_MATCH_OPTIONS,
+  FULL_GENERATIVE_CLIENT_FACTORIES,
+  MAX_CLIENT_TOOLS_AFTER_FILTER,
+  MEMORY_SAVE_TOOL_NAME,
+  MIN_CONTENT_LENGTH_FOR_TOOLS,
+  SERVER_TOOL_DEPENDENCY_SETS,
+  TOOL_CATALOG,
+  activatedToolSetNames,
+  applyToolSets,
+  assembleClientTools,
+  autoFilterClientTools,
+  buildConnectorGuidance,
+  buildDeniedToolsRider,
+  clearServerToolsCache,
+  composeCouncilClientTools,
+  computeToolGuidance,
+  createServerToolsFilter,
+  defaultServerToolsFilter,
+  deriveActiveToolSets,
+  expandToolSetsAdditive,
+  filterAssembledClientTools,
+  filterServerTools,
+  findMatchingTools,
+  getCachedServerTools,
+  getCatalogEntry,
+  getMaxToolRounds,
+  getServerTools,
+  getThinkingMode,
+  getToolDescription,
+  getToolName,
+  getToolsChecksum,
+  isCoercingIntent,
+  localStorageToolsCache,
+  mergeActiveToolSets,
+  mergeTools,
+  resolveCouncilPlan,
+  resolveCouncilServerTools,
+  resolvePlan,
+  resolveServerTools,
+  resolveToolChoice,
+  scoreTools,
+  selectCouncilClientTools,
+  selectServerSideTools,
+  selectServerToolsForPrompt,
+  shouldRefreshTools,
+  stripCoercedMemoryWrite,
+  toolSetSystemPrompts
+};