@anuma/sdk 3.0.0 → 3.1.1

package/dist/expo/index.mjs

@@ -21,7 +21,6 @@ import {
   createConversationOp,
   createMemoryVaultSearchTool,
   createMessageOp,
-  createSseClient,
   createSupersedingMemoryOp,
   createVaultEmbeddingCache,
   createVaultMemoriesBatchOp,
@@ -44,9 +43,6 @@ import {
   generateEmbeddings,
   getAllVaultMemoriesOp,
   getAllVaultMemoryContentsOp,
-  getApiV1CreditsBalance,
-  getApiV1CreditsPacks,
-  getApiV1Models,
   getConversationOp,
   getConversationsByProjectLazyOp,
   getConversationsLazyOp,
@@ -59,6 +55,7 @@ import {
   getMessagesOp,
   getMessagesPageOp,
   getToolCallEvents,
+  getToolsChecksum,
   getUnfiledVaultMemoriesOp,
   getVaultMemoryOp,
   hasEncryptionKey,
@@ -69,7 +66,6 @@ import {
   makeSyntheticStoredMessage,
   onClearAllEncryptionState,
   onKeyAvailable,
-  postApiV1CreditsPurchase,
   preEmbedVaultMemories,
   recall,
   replaceMemoryEntitiesGuardedOp,
@@ -83,6 +79,7 @@ import {
   supersedeVaultMemoryOp,
   updateConversationPinnedOp,
   updateConversationTitleOp,
+  updateMessageChunksOp,
   updateMessageEmbeddingOp,
   updateMessageErrorOp,
   updateVaultMemoryEmbeddingOp,
@@ -90,7 +87,7 @@ import {
   upsertMessageOp,
   useEncryption,
   vaultMemoryToStored
-} from "./chunk-IY7NNIYM.mjs";
+} from "./chunk-IP2B74KE.mjs";
 import {
   PII_PATTERNS,
   PiiRedactor,
@@ -111,7 +108,8 @@ import {
 import {
   BASE_URL,
   MCP_R2_DOMAIN,
-  __decorateClass
+  __decorateClass,
+  createClientConfig
 } from "./chunk-GYKJOWEO.mjs";
 
 // src/lib/chat/cryptoPriceCentroids.ts
@@ -281,6 +279,141 @@ function createWebSearchPreProcessor(options = {}) {
   };
 }
 
+// src/client/core/serverSentEvents.gen.ts
+var createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep3 = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok)
+          throw new Error(
+            `SSE failed: ${response.status} ${response.statusText}`
+          );
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(
+                    line.replace(/^retry:\s*/, ""),
+                    10
+                  );
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(
+          retryDelay * 2 ** (attempt - 1),
+          sseMaxRetryDelay ?? 3e4
+        );
+        await sleep3(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
 // src/lib/chat/runHooks.ts
 function composeHooks(hooks) {
   const handlers = hooks.filter((h) => h !== void 0 && h !== null);
@@ -3725,6 +3858,702 @@ var xhrTransport = (options) => {
 
 // src/react/useCredits.ts
 import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/client/core/bodySerializer.gen.ts
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(
+    body,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  )
+};
+
+// src/client/core/pathSerializer.gen.ts
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [
+        ...values,
+        key,
+        allowReserved ? v : encodeURIComponent(v)
+      ];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(
+    ([key, v]) => serializePrimitiveParam({
+      allowReserved,
+      name: style === "deepObject" ? `${name}[${key}]` : key,
+      value: v
+    })
+  ).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// src/client/core/utils.gen.ts
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+
+// src/client/core/auth.gen.ts
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// src/client/client/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(
+          match,
+          serializeArrayParam({ explode, name, style, value })
+        );
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value,
+            valueOnly: true
+          })
+        );
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value
+          })}`
+        );
+        continue;
+      }
+      const replaceValue = encodeURIComponent(
+        style === "label" ? `.${value}` : value
+      );
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+var createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some(
+    (type) => cleanContent.startsWith(type)
+  )) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+var setAuthParams = async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+};
+var buildUrl = (options) => {
+  const url = getUrl({
+    baseUrl: options.baseUrl,
+    path: options.path,
+    query: options.query,
+    querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+    url: options.url
+  });
+  return url;
+};
+var getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+var mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header || typeof header !== "object") {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : value
+        );
+      }
+    }
+  }
+  return mergedHeaders;
+};
+var Interceptors = class {
+  constructor() {
+    this.fns = [];
+  }
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+};
+var createInterceptors = () => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+
+// src/client/client/client.gen.ts
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        await fn(opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    const requestInit = {
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let response = await _fetch(url, requestInit);
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, opts);
+      }
+    }
+    const result = {
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData();
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "json":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "stream":
+          return {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+    }
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        const requestInit = {
+          ...init,
+          method: init.method,
+          url: url2
+        };
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            await fn(requestInit);
+            request2 = new Request(requestInit.url, requestInit);
+          }
+        }
+        return request2;
+      },
+      url
+    });
+  };
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+
+// src/client/client.gen.ts
+var client = createClient(createClientConfig(createConfig()));
+
+// src/client/sdk.gen.ts
+var getApiV1CreditsBalance = (options) => {
+  return (options?.client ?? client).get({
+    url: "/api/v1/credits/balance",
+    ...options
+  });
+};
+var getApiV1CreditsPacks = (options) => {
+  return (options?.client ?? client).get({
+    url: "/api/v1/credits/packs",
+    ...options
+  });
+};
+var postApiV1CreditsPurchase = (options) => {
+  return (options.client ?? client).post({
+    url: "/api/v1/credits/purchase",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
+var getApiV1Models = (options) => {
+  return (options?.client ?? client).get({
+    url: "/api/v1/models",
+    ...options
+  });
+};
+
+// src/react/useCredits.ts
 function useCredits(options = {}) {
   const { getToken, baseUrl = BASE_URL, autoFetch = true, onError } = options;
   const [balance, setBalance] = useState(null);
@@ -4116,6 +4945,7 @@ function useChat(options) {
       memoryContext,
       searchContext,
       fileContext,
+      toolGuidance,
       // Responses API options
       temperature,
       maxOutputTokens,
@@ -4187,6 +5017,13 @@ function useChat(options) {
           };
           messagesWithContext = [fileSystemMessage, ...messagesWithContext];
         }
+        if (toolGuidance) {
+          const toolGuidanceMessage = {
+            role: "system",
+            content: [{ type: "text", text: toolGuidance }]
+          };
+          messagesWithContext = [toolGuidanceMessage, ...messagesWithContext];
+        }
         const result = await runToolLoop({
           messages: messagesWithContext,
           model,
@@ -6688,9 +7525,11 @@ function createChunkVectorCache(maxSize = DEFAULT_CHUNK_CACHE_SIZE) {
   return new LRUCache(maxSize);
 }
 
-// src/lib/memory/recallTool.ts
+// src/lib/memory/recallConstants.ts
 var RECALL_TOOL_NAME = "recall_memory";
 var RECALL_MAX_LIMIT = 50;
+
+// src/lib/memory/recallTool.ts
 var DEFAULT_LIMIT = 8;
 var DEFAULT_BUDGET = "low";
 function formatEventTime(start, end, kind) {
@@ -7452,10 +8291,116 @@ function createMemoryVaultTool(vaultCtx, options, embeddingOptions, cache) {
   };
 }
 
+// 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/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;
 }
@@ -7515,7 +8460,7 @@ function getCachedServerTools() {
     if (!cached) return null;
     const parsed = JSON.parse(cached);
     if (parsed.version !== CACHE_VERSION) {
-      clearServerToolsCache();
+      removeLocalStorageCache();
       return null;
     }
     return parsed;
@@ -7527,24 +8472,46 @@ function isCacheExpired(cache, expirationMs = DEFAULT_CACHE_EXPIRATION_MS) {
   if (!cache) return true;
   return Date.now() - cache.timestamp > expirationMs;
 }
-function cacheServerTools(tools, checksum) {
-  if (typeof localStorage === "undefined") return;
-  const cacheData = {
+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(cacheData));
+    localStorage.setItem(SERVER_TOOLS_CACHE_KEY, JSON.stringify(entry));
   } catch (error) {
     getLogger().warn("[serverTools] Failed to cache tools:", error);
   }
 }
-function clearServerToolsCache() {
+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 getToolsChecksum2(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 = getToolsChecksum2(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",
@@ -7565,9 +8532,23 @@ async function getServerTools(options) {
     cacheExpirationMs = DEFAULT_CACHE_EXPIRATION_MS,
     forceRefresh = false,
     getToken,
-    apiKey
+    apiKey,
+    cache = localStorageToolsCache
   } = options;
-  const cached = getCachedServerTools();
+  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;
@@ -7588,7 +8569,7 @@ async function getServerTools(options) {
       }
       const data = await response.json();
       const { tools: tools2, checksum: checksum2 } = convertServerToolsResponse(data);
-      cacheServerTools(tools2, checksum2);
+      await persistCache(buildCacheEntry(tools2, checksum2));
       return tools2;
     }
     if (!getToken) {
@@ -7601,7 +8582,7 @@ async function getServerTools(options) {
       return cached?.tools ?? [];
     }
     const { tools, checksum } = await fetchServerToolsFromApi(effectiveBaseUrl, token);
-    cacheServerTools(tools, checksum);
+    await persistCache(buildCacheEntry(tools, checksum));
     return tools;
   } catch (error) {
     getLogger().error("[serverTools] Failed to fetch server tools:", error);
@@ -7817,6 +8798,158 @@ function scoreTools(promptEmbeddings, tools) {
   }
   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 expandToolSetsAdditive(matchedNames, availableNames, scores, toolSets, activeSetNames) {
   const result = new Set(matchedNames);
   for (const ts of toolSets) {
@@ -7834,6 +8967,35 @@ function expandToolSetsAdditive(matchedNames, availableNames, scores, toolSets,
   }
   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 ?? [];
@@ -7918,10 +9080,128 @@ var defaultServerToolsFilter = createServerToolsFilter({
   toolSets: SERVER_TOOL_DEPENDENCY_SETS
 });
 
+// src/lib/tools/clientToolSelection.ts
+function getToolName2(t) {
+  const fn = t.function;
+  return fn?.name || t.name || "";
+}
+function getToolDescription(t) {
+  const fn = t.function;
+  return fn?.description || t.description || getToolName2(t);
+}
+function computeToolGuidance(selectedServerTools, selectedClientTools, extraToolSets, activatedSetNames) {
+  const names = [
+    ...selectedServerTools.map((t) => t.name),
+    ...(selectedClientTools ?? []).map(getToolName2)
+  ].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 = getToolName2(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(getToolName2(t)))
+      ],
+      activatedSetNames: new Set(activeSets.map((s) => s.name))
+    };
+  }
+  const toolsNeedingEmbeddings = [];
+  for (const t of filterCandidates) {
+    const name = getToolName2(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 = getToolName2(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(getToolName2));
+  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 = getToolName2(t);
+    return name && finalNames.has(name);
+  });
+  return { tools: [...alwaysInclude, ...filtered], activatedSetNames };
+}
+
 // src/expo/useChatStorage.ts
 var CONVERSATION_REDACTOR_LIMIT = 50;
 var NO_CONVERSATION_KEY = "__no_conversation__";
 var conversationRedactors = /* @__PURE__ */ new Map();
+var clientToolFilterCache = /* @__PURE__ */ new Map();
 function getConversationRedactor(conversationId, nerDetector) {
   const key = conversationId ?? NO_CONVERSATION_KEY;
   const cached = conversationRedactors.get(key);
@@ -8037,6 +9317,8 @@ function useChatStorage(options) {
     getWalletAddress,
     enableQueue = true,
     autoFlushOnKeyAvailable = true,
+    extraToolSets,
+    activeToolSets,
     serverTools: serverToolsConfig,
     autoEmbedMessages = true,
     embeddingModel = DEFAULT_API_EMBEDDING_MODEL,
@@ -8045,6 +9327,7 @@ function useChatStorage(options) {
     resumable = false,
     onCancelResult,
     onStreamMeta,
+    onToolSelection,
     piiRedaction,
     onPiiRedacted,
     nerDetector,
@@ -8259,12 +9542,24 @@ function useChatStorage(options) {
       if (!autoEmbedMessages || !getToken) return;
       if (message.content.length < minContentLength) return;
       try {
-        const embedding = await generateEmbedding(mask(message.content), {
-          getToken,
-          baseUrl,
-          model: embeddingModel
-        });
-        await updateMessageEmbeddingOp(storageCtx, message.uniqueId, embedding, embeddingModel);
+        const opts = { getToken, baseUrl, model: embeddingModel };
+        if (shouldChunkMessage(message.content, DEFAULT_CHUNK_SIZE)) {
+          const textChunks = chunkText(message.content);
+          const embeddings = await generateEmbeddings(
+            textChunks.map((c) => mask(c.text)),
+            opts
+          );
+          const messageChunks = textChunks.map((chunk, i) => ({
+            text: chunk.text,
+            vector: embeddings[i],
+            startOffset: chunk.startOffset,
+            endOffset: chunk.endOffset
+          }));
+          await updateMessageChunksOp(storageCtx, message.uniqueId, messageChunks, embeddingModel);
+        } else {
+          const embedding = await generateEmbedding(mask(message.content), opts);
+          await updateMessageEmbeddingOp(storageCtx, message.uniqueId, embedding, embeddingModel);
+        }
       } catch (err) {
         getLogger().warn("[useChatStorage] Failed to embed message:", err);
       }
@@ -8614,6 +9909,10 @@ function useChatStorage(options) {
     }
     throw new Error("No conversation ID provided and autoCreateConversation is disabled");
   }, [currentConversationId, getConversation, autoCreateConversation, createConversation]);
+  const activeToolSetsRef = useRef4(activeToolSets);
+  activeToolSetsRef.current = activeToolSets;
+  const getTokenRef = useRef4(getToken);
+  getTokenRef.current = getToken;
   const sendMessage = useCallback4(
     async (args) => {
       const {
@@ -8640,6 +9939,7 @@ function useChatStorage(options) {
         maxOutputTokens,
         clientTools,
         serverTools: serverToolsFilter,
+        clientToolsFilter,
         toolChoice,
         reasoning,
         thinking,
@@ -8666,6 +9966,13 @@ function useChatStorage(options) {
       };
       pendingResumeRef.current = null;
       const effectiveAssistantUniqueId = assistantUniqueId ?? (resumable ? `msg_${uuidv73()}` : void 0);
+      const embedToolText = (text12, mask, token) => {
+        const opts = { getToken: token, baseUrl, model: embeddingModel };
+        return shouldChunkMessage(text12, DEFAULT_CHUNK_SIZE) ? generateEmbeddings(
+          chunkText(text12).map((c) => mask(c.text)),
+          opts
+        ) : generateEmbedding(mask(text12), opts);
+      };
       if (walletAddress && signMessage && !hasEncryptionKey(walletAddress)) {
         try {
           await requestEncryptionKey(walletAddress, signMessage, embeddedWalletSigner);
@@ -8676,40 +9983,95 @@ function useChatStorage(options) {
         const effectiveApiType2 = resolveApiType(requestApiType ?? apiType ?? "auto", model);
         const { callPiiRedaction: callPiiRedaction2, maskForCall: maskForCall2 } = resolvePiiForCall(currentConversationId);
         let mergedTools2 = void 0;
-        let filteredServerTools = [];
+        let filteredServerTools2 = [];
         const isServerToolsFunction2 = typeof serverToolsFilter === "function";
-        if (getToken && effectiveApiType2 === "responses" && !(Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0)) {
+        const extracted2 = extractUserMessageFromMessages(messages);
+        const messageContent = resolveStoredUserContent(
+          storedUserContent,
+          extracted2?.content ?? ""
+        );
+        let skipUserEmbedding;
+        let skipEmbeddingFailed = false;
+        if (getTokenRef.current && effectiveApiType2 === "responses" && !(Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0)) {
           try {
             const allServerTools = await getServerTools({
               baseUrl,
               cacheExpirationMs: serverToolsConfig?.cacheExpirationMs,
-              getToken
+              getToken: getTokenRef.current,
+              cache: serverToolsConfig?.cache
             });
-            if (isServerToolsFunction2) {
-              const extracted2 = extractUserMessageFromMessages(messages);
-              const messageContent = resolveStoredUserContent(
-                storedUserContent,
-                extracted2?.content ?? ""
-              );
-              if (messageContent.length >= minContentLength) {
-                const embedding = await generateEmbedding(maskForCall2(messageContent), {
-                  getToken,
-                  baseUrl,
-                  model: embeddingModel
-                });
-                const toolNames = serverToolsFilter(embedding, allServerTools);
-                filteredServerTools = filterServerTools(allServerTools, toolNames);
-              } else {
-                filteredServerTools = allServerTools;
+            if (serverToolsConfig?.deferLoading?.enabled) {
+              filteredServerTools2 = allServerTools;
+            } else if (isServerToolsFunction2) {
+              if (messageContent.length >= MIN_CONTENT_LENGTH_FOR_TOOLS) {
+                skipUserEmbedding = await embedToolText(
+                  messageContent,
+                  maskForCall2,
+                  getTokenRef.current
+                );
+                const toolNames = serverToolsFilter(skipUserEmbedding, allServerTools);
+                filteredServerTools2 = filterServerTools(allServerTools, toolNames);
               }
             } else {
-              filteredServerTools = filterServerTools(allServerTools, serverToolsFilter);
+              filteredServerTools2 = filterServerTools(allServerTools, serverToolsFilter);
             }
           } catch {
           }
         }
-        if (filteredServerTools.length > 0 || clientTools && clientTools.length > 0) {
-          mergedTools2 = mergeTools(filteredServerTools, clientTools, effectiveApiType2);
+        let narrowedClientTools2 = clientTools;
+        let clientActivatedSetNames2;
+        if (clientTools?.length) {
+          try {
+            if (!skipUserEmbedding && getTokenRef.current && messageContent.length >= MIN_CONTENT_LENGTH_FOR_TOOLS) {
+              try {
+                skipUserEmbedding = await embedToolText(
+                  messageContent,
+                  maskForCall2,
+                  getTokenRef.current
+                );
+              } catch {
+                skipEmbeddingFailed = true;
+              }
+            }
+            if (typeof clientToolsFilter === "function") {
+              if (!skipEmbeddingFailed) {
+                const keep = new Set(clientToolsFilter(skipUserEmbedding ?? null, clientTools));
+                narrowedClientTools2 = clientTools.filter((t) => keep.has(getToolName2(t)));
+              }
+            } else if (getTokenRef.current) {
+              const { tools: autoTools, activatedSetNames } = await autoFilterClientTools(
+                clientTools,
+                skipUserEmbedding ?? null,
+                clientToolFilterCache,
+                { getToken: getTokenRef.current, baseUrl, model: embeddingModel },
+                extraToolSets ?? [],
+                activeToolSetsRef.current ?? [],
+                skipEmbeddingFailed ? "error" : "short-prompt"
+              );
+              narrowedClientTools2 = autoTools;
+              clientActivatedSetNames2 = activatedSetNames;
+            }
+          } catch (error) {
+            getLogger().warn("[useChatStorage] client tool filtering failed (skipStorage):", error);
+          }
+        }
+        if (filteredServerTools2.length > 0 || narrowedClientTools2 && narrowedClientTools2.length > 0) {
+          mergedTools2 = mergeTools(
+            filteredServerTools2,
+            narrowedClientTools2,
+            effectiveApiType2,
+            serverToolsConfig?.deferLoading
+          );
+        }
+        if (onToolSelection) {
+          try {
+            onToolSelection({
+              prompt: messageContent,
+              clientToolNames: (narrowedClientTools2 ?? []).map(getToolName2).filter(Boolean),
+              serverToolNames: filteredServerTools2.map((t) => t.name)
+            });
+          } catch {
+          }
         }
         const result2 = await baseSendMessage({
           messages,
@@ -8719,6 +10081,12 @@ function useChatStorage(options) {
           memoryContext,
           searchContext,
           fileContext,
+          toolGuidance: computeToolGuidance(
+            filteredServerTools2,
+            narrowedClientTools2,
+            extraToolSets ?? [],
+            clientActivatedSetNames2
+          ),
           temperature,
           maxOutputTokens,
           tools: mergedTools2,
@@ -8746,6 +10114,24 @@ function useChatStorage(options) {
             error: result2.error || "Unknown error"
           };
         }
+        const skipRefreshGetToken = getTokenRef.current;
+        const skipRefreshData = result2.data;
+        if (skipRefreshGetToken) {
+          Promise.resolve().then(
+            () => shouldRefreshTools(getToolsChecksum(skipRefreshData), serverToolsConfig?.cache)
+          ).then((refresh) => {
+            if (refresh) {
+              return getServerTools({
+                baseUrl,
+                getToken: skipRefreshGetToken,
+                forceRefresh: true,
+                cache: serverToolsConfig?.cache
+              });
+            }
+          }).catch((err) => {
+            getLogger().warn("[useChatStorage] Failed to refresh server tools cache:", err);
+          });
+        }
         return {
           data: result2.data,
           error: null,
@@ -8784,12 +10170,12 @@ function useChatStorage(options) {
       if (includeHistory) {
         const validMessages = storedMessages.filter((msg) => !msg.error);
         const limitedMessages = validMessages.slice(-maxHistoryMessages);
-        if (summarizeHistory && !getToken) {
+        if (summarizeHistory && !getTokenRef.current) {
           getLogger().warn(
             "[summarize] summarizeHistory is enabled but getToken is not provided \u2014 summarization will be skipped"
           );
         }
-        const summaryToken = summarizeHistory && getToken ? await getToken() : null;
+        const summaryToken = summarizeHistory && getTokenRef.current ? await getTokenRef.current() : null;
         const { messagesToConvert, summarySystemMessage } = await maybeSummarizeHistory({
           database,
           conversationId: convId,
@@ -8848,50 +10234,131 @@ function useChatStorage(options) {
       const effectiveApiType = resolveApiType(requestApiType ?? apiType ?? "auto", model);
       let mergedTools = clientTools;
       let userMessageEmbedding;
+      let userMessageEmbeddingFailed = false;
+      let filteredServerTools = [];
       const isServerToolsFunction = typeof serverToolsFilter === "function";
-      if (getToken && !(Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0)) {
+      if (getTokenRef.current && !(Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0)) {
         try {
           const allServerTools = await getServerTools({
             baseUrl,
             cacheExpirationMs: serverToolsConfig?.cacheExpirationMs,
-            getToken
+            getToken: getTokenRef.current,
+            cache: serverToolsConfig?.cache
           });
-          let filteredServerTools;
-          if (isServerToolsFunction) {
-            if (contentForStorage.length >= minContentLength) {
-              userMessageEmbedding = await generateEmbedding(maskForCall(contentForStorage), {
-                getToken,
-                baseUrl,
-                model: embeddingModel
-              });
+          if (serverToolsConfig?.deferLoading?.enabled && effectiveApiType === "responses") {
+            filteredServerTools = allServerTools;
+          } else if (isServerToolsFunction) {
+            if (contentForStorage.length >= MIN_CONTENT_LENGTH_FOR_TOOLS) {
+              userMessageEmbedding = await embedToolText(
+                contentForStorage,
+                maskForCall,
+                getTokenRef.current
+              );
               const toolNames = serverToolsFilter(userMessageEmbedding, allServerTools);
               filteredServerTools = filterServerTools(allServerTools, toolNames);
-            } else {
-              filteredServerTools = allServerTools;
             }
           } else {
             filteredServerTools = filterServerTools(allServerTools, serverToolsFilter);
           }
           if (filteredServerTools.length > 0) {
-            mergedTools = mergeTools(filteredServerTools, clientTools, effectiveApiType);
+            mergedTools = mergeTools(
+              filteredServerTools,
+              clientTools,
+              effectiveApiType,
+              serverToolsConfig?.deferLoading
+            );
           }
         } catch (error) {
           getLogger().warn("[useChatStorage] Failed to fetch server tools:", error);
         }
       }
+      let narrowedClientTools = clientTools;
+      let clientActivatedSetNames;
+      if (clientTools?.length) {
+        try {
+          if (!userMessageEmbedding && getTokenRef.current && contentForStorage.length >= MIN_CONTENT_LENGTH_FOR_TOOLS) {
+            try {
+              userMessageEmbedding = await embedToolText(
+                contentForStorage,
+                maskForCall,
+                getTokenRef.current
+              );
+            } catch {
+              userMessageEmbeddingFailed = true;
+            }
+          }
+          if (typeof clientToolsFilter === "function") {
+            if (!userMessageEmbeddingFailed) {
+              const keep = new Set(clientToolsFilter(userMessageEmbedding ?? null, clientTools));
+              narrowedClientTools = clientTools.filter((t) => keep.has(getToolName2(t)));
+            }
+          } else if (getTokenRef.current) {
+            const { tools: autoTools, activatedSetNames } = await autoFilterClientTools(
+              clientTools,
+              userMessageEmbedding ?? null,
+              clientToolFilterCache,
+              { getToken: getTokenRef.current, baseUrl, model: embeddingModel },
+              extraToolSets ?? [],
+              activeToolSetsRef.current ?? [],
+              userMessageEmbeddingFailed ? "error" : "short-prompt"
+            );
+            narrowedClientTools = autoTools;
+            clientActivatedSetNames = activatedSetNames;
+          }
+          mergedTools = filteredServerTools.length > 0 || (narrowedClientTools?.length ?? 0) > 0 ? mergeTools(
+            filteredServerTools,
+            narrowedClientTools,
+            effectiveApiType,
+            serverToolsConfig?.deferLoading
+          ) : void 0;
+        } catch (error) {
+          getLogger().warn("[useChatStorage] client tool filtering failed:", error);
+        }
+      }
       if (!userMsgQueueId) {
         if (userMessageEmbedding && autoEmbedMessages) {
-          updateMessageEmbeddingOp(
-            storageCtx,
-            storedUserMessage.uniqueId,
-            userMessageEmbedding,
-            embeddingModel
-          ).catch(() => {
-          });
+          if (Array.isArray(userMessageEmbedding[0])) {
+            const textChunks = chunkText(contentForStorage);
+            const messageChunks = textChunks.map((chunk, i) => ({
+              text: chunk.text,
+              vector: userMessageEmbedding[i],
+              startOffset: chunk.startOffset,
+              endOffset: chunk.endOffset
+            }));
+            updateMessageChunksOp(
+              storageCtx,
+              storedUserMessage.uniqueId,
+              messageChunks,
+              embeddingModel
+            ).catch((err) => {
+              getLogger().warn(
+                "[useChatStorage] Failed to persist chunked embeddings for user message:",
+                err
+              );
+            });
+          } else {
+            updateMessageEmbeddingOp(
+              storageCtx,
+              storedUserMessage.uniqueId,
+              userMessageEmbedding,
+              embeddingModel
+            ).catch(() => {
+            });
+          }
         } else {
           void embedMessageAsync(storedUserMessage, maskForCall);
         }
       }
+      if (onToolSelection) {
+        try {
+          onToolSelection({
+            prompt: contentForStorage,
+            clientToolNames: (narrowedClientTools ?? []).map(getToolName2).filter(Boolean),
+            serverToolNames: filteredServerTools.map((t) => t.name)
+          });
+        } catch {
+        }
+      }
       const result = await baseSendMessage({
         messages: messagesToSend,
         model,
@@ -8900,6 +10367,12 @@ function useChatStorage(options) {
         memoryContext,
         searchContext,
         fileContext,
+        toolGuidance: computeToolGuidance(
+          filteredServerTools,
+          narrowedClientTools,
+          extraToolSets ?? [],
+          clientActivatedSetNames
+        ),
         apiType: requestApiType,
         // Responses API options
         temperature,
@@ -9101,6 +10574,21 @@ function useChatStorage(options) {
           userMessage: storedUserMessage
         };
       }
+      const refreshGetToken = getTokenRef.current;
+      if (refreshGetToken) {
+        Promise.resolve().then(() => shouldRefreshTools(getToolsChecksum(responseData), serverToolsConfig?.cache)).then((refresh) => {
+          if (refresh) {
+            return getServerTools({
+              baseUrl,
+              getToken: refreshGetToken,
+              forceRefresh: true,
+              cache: serverToolsConfig?.cache
+            });
+          }
+        }).catch((err) => {
+          getLogger().warn("[useChatStorage] Failed to refresh server tools cache:", err);
+        });
+      }
       return {
         data: responseData,
         error: null,
@@ -10666,6 +12154,7 @@ async function updateVaultFolderOp(ctx, id, opts) {
     if (record.isDeleted) return null;
     const scopeChanged = opts.scope !== void 0 && opts.scope !== record.scope;
     const updated = await ctx.database.write(async () => {
+      const memories = scopeChanged ? await ctx.vaultMemoryCollection.query(Q5.where("folder_id", id), Q5.where("is_deleted", false)).fetch() : [];
       const updates = [];
       updates.push(
         record.prepareUpdate((r) => {
@@ -10673,15 +12162,12 @@ async function updateVaultFolderOp(ctx, id, opts) {
           if (opts.scope !== void 0) r._setRaw("scope", opts.scope);
         })
       );
-      if (scopeChanged) {
-        const memories = await ctx.vaultMemoryCollection.query(Q5.where("folder_id", id), Q5.where("is_deleted", false)).fetch();
-        for (const memory of memories) {
-          updates.push(
-            memory.prepareUpdate((r) => {
-              r._setRaw("scope", opts.scope);
-            })
-          );
-        }
+      for (const memory of memories) {
+        updates.push(
+          memory.prepareUpdate((r) => {
+            r._setRaw("scope", opts.scope);
+          })
+        );
       }
       await ctx.database.batch(...updates);
       return ctx.vaultFolderCollection.find(id);