mindcache 3.5.3 → 3.7.0

package/dist/index.js

@@ -6,7 +6,11 @@ var decoding = require('lib0/decoding');
 var Y = require('yjs');
 var yIndexeddb = require('y-indexeddb');
 var diff = require('fast-diff');
-var react = require('react');
+var ai = require('ai');
+var zod = require('zod');
+var React2 = require('react');
+var openai = require('@ai-sdk/openai');
+var jsxRuntime = require('react/jsx-runtime');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -33,6 +37,7 @@ var encoding__namespace = /*#__PURE__*/_interopNamespace(encoding);
 var decoding__namespace = /*#__PURE__*/_interopNamespace(decoding);
 var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
 var diff__default = /*#__PURE__*/_interopDefault(diff);
+var React2__default = /*#__PURE__*/_interopDefault(React2);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -212,7 +217,6 @@ var init_CloudAdapter = __esm({
         if (!config.baseUrl) {
           throw new Error("MindCache Cloud: baseUrl is required. Please provide the cloud API URL in your configuration.");
         }
-        this.validateConfig(config);
         this.setupNetworkDetection();
       }
       ws = null;
@@ -228,43 +232,6 @@ var init_CloudAdapter = __esm({
       handleOnline = null;
       handleOffline = null;
       _synced = false;
-      /**
-       * Validate configuration and warn about common mistakes
-       */
-      validateConfig(config) {
-        const baseUrl = config.baseUrl;
-        if (!baseUrl) {
-          return;
-        }
-        console.log("\u2601\uFE0F MindCache Cloud Config:", {
-          baseUrl,
-          instanceId: config.instanceId,
-          hasTokenProvider: !!config.tokenProvider,
-          hasApiKey: !!config.apiKey
-        });
-        try {
-          const url = new URL(baseUrl);
-          if (url.hostname === "mindcache.dev") {
-            console.error(
-              '\u26A0\uFE0F MindCache Cloud WARNING: baseUrl is set to "mindcache.dev" but the API is at "api.mindcache.dev".\n   Current: ' + baseUrl + "\n   Expected: https://api.mindcache.dev\n   This will cause WebSocket connection failures (404 errors)."
-            );
-          }
-          if (url.protocol === "ws:" || url.protocol === "wss:") {
-            console.warn(
-              "\u26A0\uFE0F MindCache Cloud: baseUrl uses WebSocket protocol (" + url.protocol + "). Consider using http:// or https:// - CloudAdapter will handle the WebSocket upgrade automatically."
-            );
-          }
-          if (url.hostname === "localhost" && url.port !== "8787" && url.port !== "3000") {
-            console.warn(
-              "\u26A0\uFE0F MindCache Cloud: localhost URL detected with non-standard port " + url.port + ". Default MindCache dev server runs on port 8787."
-            );
-          }
-          const wsUrl = baseUrl.replace("https://", "wss://").replace("http://", "ws://");
-          console.log("\u2601\uFE0F WebSocket will connect to:", wsUrl + "/sync/" + config.instanceId);
-        } catch (e) {
-          console.error("\u26A0\uFE0F MindCache Cloud: Invalid baseUrl format:", baseUrl);
-        }
-      }
       /** Browser network status - instantly updated via navigator.onLine */
       get isOnline() {
         return this._isOnline;
@@ -517,6 +484,76 @@ var SystemTagHelpers = {
   hasTemplateInjection: (attrs) => attrs.systemTags.includes("ApplyTemplate")
 };
 
+// src/core/SchemaParser.ts
+var SchemaParser = class {
+  /**
+   * Parse a markdown schema string into a CustomTypeDefinition
+   * @param schema - Markdown schema string
+   * @returns Parsed type definition
+   * @throws Error if schema format is invalid
+   */
+  static parse(schema) {
+    const lines = schema.trim().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    if (lines.length === 0) {
+      throw new Error("Schema cannot be empty");
+    }
+    const typeNameMatch = lines[0].match(/^#\s*(\w+)$/);
+    if (!typeNameMatch) {
+      throw new Error(`Invalid schema: first line must be "#TypeName", got "${lines[0]}"`);
+    }
+    const typeName = typeNameMatch[1];
+    const fields = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      const fieldMatch = line.match(/^\*\s*([^:]+):\s*(.+)$/);
+      if (fieldMatch) {
+        fields.push({
+          name: fieldMatch[1].trim(),
+          description: fieldMatch[2].trim()
+        });
+      }
+    }
+    if (fields.length === 0) {
+      throw new Error(`Schema "${typeName}" must have at least one field`);
+    }
+    return {
+      name: typeName,
+      fields,
+      rawSchema: schema
+    };
+  }
+  /**
+   * Generate a markdown representation of a type definition
+   * Useful for including in LLM prompts
+   */
+  static toMarkdown(typeDef) {
+    const lines = [`#${typeDef.name}`];
+    for (const field of typeDef.fields) {
+      lines.push(`* ${field.name}: ${field.description}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate a prompt-friendly description of the type
+   * More verbose than toMarkdown, better for LLM guidance
+   */
+  static toPromptDescription(typeDef) {
+    const fieldDescs = typeDef.fields.map((f) => `  - ${f.name}: ${f.description}`).join("\n");
+    return `Type "${typeDef.name}" with fields:
+${fieldDescs}`;
+  }
+  /**
+   * Generate an example value structure based on the type definition
+   */
+  static generateExample(typeDef) {
+    const lines = [`#${typeDef.name.toLowerCase()}`];
+    for (const field of typeDef.fields) {
+      lines.push(`* ${field.name}: [${field.description}]`);
+    }
+    return lines.join("\n");
+  }
+};
+
 // src/core/MarkdownSerializer.ts
 var MarkdownSerializer = class {
   /**
@@ -863,18 +900,16 @@ var MarkdownSerializer = class {
     return result;
   }
 };
-
-// src/core/AIToolBuilder.ts
 var AIToolBuilder = class _AIToolBuilder {
   /**
-     * Sanitize key name for use in tool names
-     */
+   * Sanitize key name for use in tool names
+   */
   static sanitizeKeyForTool(key) {
     return key.replace(/[^a-zA-Z0-9_-]/g, "_");
   }
   /**
-     * Find original key from sanitized tool name
-     */
+   * Find original key from sanitized tool name
+   */
   static findKeyFromSanitizedTool(mc, sanitizedKey) {
     for (const key of mc.keys()) {
       if (_AIToolBuilder.sanitizeKeyForTool(key) === sanitizedKey) {
@@ -884,15 +919,174 @@ var AIToolBuilder = class _AIToolBuilder {
     return void 0;
   }
   /**
-     * Generate Vercel AI SDK compatible tools for writable keys.
-     * For document type keys, generates additional tools: append_, insert_, edit_
-     *
-     * Security: All tools use llm_set_key internally which:
-     * - Only modifies VALUES, never attributes/systemTags
-     * - Prevents LLMs from escalating privileges
-     */
+   * Generate framework-agnostic tools with raw JSON Schema.
+   * Works with: OpenAI SDK, Anthropic SDK, LangChain, etc.
+   *
+   * Tool format:
+   * {
+   *   description: string,
+   *   parameters: { type: 'object', properties: {...}, required: [...] },
+   *   execute: async (args) => result
+   * }
+   */
+  static createTools(mc) {
+    return _AIToolBuilder._buildTools(mc);
+  }
+  /**
+   * Generate Vercel AI SDK v5 compatible tools using Zod schemas.
+   * Uses tool() helper with Zod for full AI SDK v5 compatibility.
+   *
+   * Use this with: generateText(), streamText() from 'ai' package
+   */
   static createVercelAITools(mc) {
     const tools = {};
+    const registeredTypes = mc.getRegisteredTypes();
+    const typeDesc = registeredTypes.length > 0 ? `Optional type: ${registeredTypes.join(" | ")}` : "No types registered";
+    tools["create_key"] = ai.tool({
+      description: `Create a new key in MindCache. ${registeredTypes.length > 0 ? `Available types: ${registeredTypes.join(", ")}` : ""}`,
+      inputSchema: zod.z.object({
+        key: zod.z.string().describe('The key name (e.g., "contact_john_doe")'),
+        value: zod.z.string().describe("The value (JSON string for structured data)"),
+        type: zod.z.string().optional().describe(typeDesc)
+      }),
+      execute: async ({ key, value, type }) => {
+        if (mc.has(key)) {
+          return { result: `Key "${key}" exists. Use write_${_AIToolBuilder.sanitizeKeyForTool(key)}`, error: true };
+        }
+        if (type && !mc.getTypeSchema(type)) {
+          return { result: `Type "${type}" not registered`, error: true };
+        }
+        mc.set_value(key, value, { systemTags: ["SystemPrompt", "LLMRead", "LLMWrite"] });
+        if (type) {
+          mc.setType(key, type);
+        }
+        return { result: `Created "${key}"${type ? ` (${type})` : ""}`, key, value };
+      }
+    });
+    for (const key of mc.keys()) {
+      if (key.startsWith("$") || !mc.keyMatchesContext(key)) {
+        continue;
+      }
+      const attrs = mc.get_attributes(key);
+      if (!attrs?.systemTags?.includes("LLMWrite")) {
+        continue;
+      }
+      const sanitized = _AIToolBuilder.sanitizeKeyForTool(key);
+      const customTypeName = mc.getKeyType(key);
+      const customType = customTypeName ? mc.getTypeSchema(customTypeName) : void 0;
+      let desc = `Write to "${key}"`;
+      if (customType) {
+        desc = `Write to "${key}" (${customTypeName}). ${SchemaParser.toPromptDescription(customType)}`;
+      }
+      tools[`write_${sanitized}`] = ai.tool({
+        description: desc,
+        inputSchema: zod.z.object({
+          value: zod.z.string().describe(customType ? `JSON following ${customTypeName} schema` : "Value to write")
+        }),
+        execute: async ({ value }) => {
+          const success = mc.llm_set_key(key, value);
+          return success ? { result: `Wrote to ${key}`, key, value } : { result: `Failed to write to ${key}`, error: true };
+        }
+      });
+      if (attrs?.type === "document") {
+        tools[`append_${sanitized}`] = ai.tool({
+          description: `Append to "${key}" document`,
+          inputSchema: zod.z.object({ text: zod.z.string().describe("Text to append") }),
+          execute: async ({ text }) => {
+            const yText = mc.get_document(key);
+            if (yText) {
+              yText.insert(yText.length, text);
+              return { result: "Appended", key };
+            }
+            return { result: "Not found", error: true };
+          }
+        });
+        tools[`insert_${sanitized}`] = ai.tool({
+          description: `Insert text at position in "${key}" document`,
+          inputSchema: zod.z.object({
+            index: zod.z.number().describe("Position (0 = start)"),
+            text: zod.z.string().describe("Text to insert")
+          }),
+          execute: async ({ index, text }) => {
+            mc.insert_text(key, index, text);
+            return { result: `Inserted at ${index}`, key };
+          }
+        });
+        tools[`edit_${sanitized}`] = ai.tool({
+          description: `Find and replace in "${key}" document`,
+          inputSchema: zod.z.object({
+            find: zod.z.string().describe("Text to find"),
+            replace: zod.z.string().describe("Replacement")
+          }),
+          execute: async ({ find, replace }) => {
+            const yText = mc.get_document(key);
+            if (yText) {
+              const text = yText.toString();
+              const idx = text.indexOf(find);
+              if (idx !== -1) {
+                yText.delete(idx, find.length);
+                yText.insert(idx, replace);
+                return { result: `Replaced "${find}"`, key };
+              }
+              return { result: `"${find}" not found`, error: true };
+            }
+            return { result: "Document not found", error: true };
+          }
+        });
+      }
+    }
+    return tools;
+  }
+  /**
+   * Internal: Build tools with raw JSON Schema (framework-agnostic).
+   */
+  static _buildTools(mc) {
+    const tools = {};
+    const registeredTypes = mc.getRegisteredTypes();
+    const typeInfo = registeredTypes.length > 0 ? `Available types: ${registeredTypes.join(", ")}` : "No custom types registered";
+    tools["create_key"] = {
+      description: `Create a new key in MindCache. ${typeInfo}. The new key will be readable and writable by the LLM.`,
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: 'The key name to create (e.g., "contact_john_doe")' },
+          value: { type: "string", description: "The value to store (use JSON string for structured data)" },
+          type: {
+            type: "string",
+            description: registeredTypes.length > 0 ? `Optional: custom type name (${registeredTypes.join(" | ")})` : "Optional: custom type name (none registered)"
+          }
+        },
+        required: ["key", "value"]
+      },
+      execute: async ({ key, value, type }) => {
+        if (mc.has(key)) {
+          return {
+            result: `Key "${key}" already exists. Use write_${_AIToolBuilder.sanitizeKeyForTool(key)} to update it.`,
+            key,
+            error: true
+          };
+        }
+        if (type && !mc.getTypeSchema(type)) {
+          return {
+            result: `Type "${type}" is not registered. Available types: ${registeredTypes.join(", ") || "none"}`,
+            key,
+            error: true
+          };
+        }
+        mc.set_value(key, value, {
+          systemTags: ["SystemPrompt", "LLMRead", "LLMWrite"]
+        });
+        if (type) {
+          mc.setType(key, type);
+        }
+        return {
+          result: `Successfully created key "${key}"${type ? ` with type "${type}"` : ""}`,
+          key,
+          value,
+          type
+        };
+      }
+    };
     for (const key of mc.keys()) {
       if (key.startsWith("$")) {
         continue;
@@ -907,12 +1101,28 @@ var AIToolBuilder = class _AIToolBuilder {
       }
       const sanitizedKey = _AIToolBuilder.sanitizeKeyForTool(key);
       const isDocument = attributes?.type === "document";
+      const customTypeName = mc.getKeyType(key);
+      const customType = customTypeName ? mc.getTypeSchema(customTypeName) : void 0;
+      let writeDescription;
+      if (customType) {
+        const schemaGuidance = SchemaParser.toPromptDescription(customType);
+        const example = SchemaParser.generateExample(customType);
+        writeDescription = `Write a value to "${key}" that must follow this schema:
+${schemaGuidance}
+
+Example format:
+${example}`;
+      } else if (isDocument) {
+        writeDescription = `Rewrite the entire "${key}" document`;
+      } else {
+        writeDescription = `Write a value to the STM key: ${key}`;
+      }
       tools[`write_${sanitizedKey}`] = {
-        description: isDocument ? `Rewrite the entire "${key}" document` : `Write a value to the STM key: ${key}`,
-        inputSchema: {
+        description: writeDescription,
+        parameters: {
           type: "object",
           properties: {
-            value: { type: "string", description: isDocument ? "New document content" : "The value to write" }
+            value: { type: "string", description: customType ? `Value following ${customTypeName} schema` : isDocument ? "New document content" : "The value to write" }
           },
           required: ["value"]
         },
@@ -935,7 +1145,7 @@ var AIToolBuilder = class _AIToolBuilder {
       if (isDocument) {
         tools[`append_${sanitizedKey}`] = {
           description: `Append text to the end of "${key}" document`,
-          inputSchema: {
+          parameters: {
             type: "object",
             properties: {
               text: { type: "string", description: "Text to append" }
@@ -960,7 +1170,7 @@ var AIToolBuilder = class _AIToolBuilder {
         };
         tools[`insert_${sanitizedKey}`] = {
           description: `Insert text at a position in "${key}" document`,
-          inputSchema: {
+          parameters: {
             type: "object",
             properties: {
               index: { type: "number", description: "Position to insert at (0 = start)" },
@@ -983,7 +1193,7 @@ var AIToolBuilder = class _AIToolBuilder {
         };
         tools[`edit_${sanitizedKey}`] = {
           description: `Find and replace text in "${key}" document`,
-          inputSchema: {
+          parameters: {
             type: "object",
             properties: {
               find: { type: "string", description: "Text to find" },
@@ -1020,11 +1230,16 @@ var AIToolBuilder = class _AIToolBuilder {
     return tools;
   }
   /**
-     * Generate a system prompt containing all visible STM keys and their values.
-     * Indicates which tools can be used to modify writable keys.
-     */
+   * Generate a system prompt containing all visible STM keys and their values.
+   * Indicates which tools can be used to modify writable keys.
+   */
   static getSystemPrompt(mc) {
     const lines = [];
+    const registeredTypes = mc.getRegisteredTypes();
+    if (registeredTypes.length > 0) {
+      lines.push(`[create_key tool available - registered types: ${registeredTypes.join(", ")}]`);
+      lines.push("");
+    }
     for (const key of mc.keys()) {
       if (key.startsWith("$")) {
         continue;
@@ -1042,8 +1257,18 @@ var AIToolBuilder = class _AIToolBuilder {
       const isWritable = attributes?.systemTags?.includes("LLMWrite");
       const isDocument = attributes?.type === "document";
       const sanitizedKey = _AIToolBuilder.sanitizeKeyForTool(key);
+      const customTypeName = mc.getKeyType(key);
+      const customType = customTypeName ? mc.getTypeSchema(customTypeName) : void 0;
       if (isWritable) {
-        if (isDocument) {
+        if (customType) {
+          const schemaInfo = SchemaParser.toMarkdown(customType);
+          lines.push(
+            `${key} (type: ${customTypeName}): ${displayValue}
+Schema:
+${schemaInfo}
+Tool: write_${sanitizedKey}`
+          );
+        } else if (isDocument) {
           lines.push(
             `${key}: ${displayValue}. Document tools: write_${sanitizedKey}, append_${sanitizedKey}, edit_${sanitizedKey}`
           );
@@ -1054,15 +1279,19 @@ var AIToolBuilder = class _AIToolBuilder {
           );
         }
       } else {
-        lines.push(`${key}: ${displayValue}`);
+        if (customTypeName) {
+          lines.push(`${key} (type: ${customTypeName}): ${displayValue}`);
+        } else {
+          lines.push(`${key}: ${displayValue}`);
+        }
       }
     }
     return lines.join("\n");
   }
   /**
-     * Execute a tool call by name with the given value.
-     * Returns the result or null if tool not found.
-     */
+   * Execute a tool call by name with the given value.
+   * Returns the result or null if tool not found.
+   */
   static executeToolCall(mc, toolName, value) {
     const match = toolName.match(/^(write|append|insert|edit)_(.+)$/);
     if (!match) {
@@ -1389,7 +1618,7 @@ var MindCache = class {
   listeners = {};
   globalListeners = [];
   // Metadata
-  version = "3.3.2";
+  version = "3.6.0";
   // Internal flag to prevent sync loops when receiving remote updates
   // (Less critical with Yjs but kept for API compat)
   normalizeSystemTags(tags) {
@@ -1426,6 +1655,8 @@ var MindCache = class {
   _history = [];
   _historyOptions = { maxEntries: 100, snapshotInterval: 10 };
   _historyEnabled = false;
+  // Custom type registry
+  _typeRegistry = /* @__PURE__ */ new Map();
   constructor(options) {
     this.doc = options?.doc || new Y__namespace.Doc();
     this.rootMap = this.doc.getMap("mindcache");
@@ -2382,6 +2613,71 @@ var MindCache = class {
   systemGetKeysByTag(tag) {
     return TagManager.systemGetKeysByTag(this, tag);
   }
+  // ============================================
+  // Custom Type Methods
+  // ============================================
+  /**
+   * Register a custom type with a markdown schema definition.
+   *
+   * Schema format:
+   * ```
+   * #TypeName
+   * * fieldName: description of the field
+   * * anotherField: description
+   * ```
+   *
+   * @param name - Type name (e.g., 'Contact')
+   * @param schema - Markdown schema definition
+   * @throws Error if schema format is invalid
+   */
+  registerType(name, schema) {
+    const typeDef = SchemaParser.parse(schema);
+    typeDef.name = name;
+    this._typeRegistry.set(name, typeDef);
+  }
+  /**
+   * Assign a custom type to a key.
+   * The key must exist and the type must be registered.
+   * Also sets the underlying type to 'json' since custom types are structured JSON data.
+   *
+   * @param key - Key to assign type to
+   * @param typeName - Registered type name
+   * @throws Error if key doesn't exist or type is not registered
+   */
+  setType(key, typeName) {
+    if (!this.rootMap.has(key)) {
+      throw new Error(`Key "${key}" does not exist`);
+    }
+    if (!this._typeRegistry.has(typeName)) {
+      throw new Error(`Type "${typeName}" is not registered. Use registerType() first.`);
+    }
+    this.set_attributes(key, { type: "json", customType: typeName });
+  }
+  /**
+   * Get a registered type schema definition.
+   *
+   * @param typeName - Type name to look up
+   * @returns The type definition or undefined if not registered
+   */
+  getTypeSchema(typeName) {
+    return this._typeRegistry.get(typeName);
+  }
+  /**
+   * Get all registered type names.
+   */
+  getRegisteredTypes() {
+    return Array.from(this._typeRegistry.keys());
+  }
+  /**
+   * Get the custom type assigned to a key.
+   *
+   * @param key - Key to check
+   * @returns Type name or undefined if no custom type assigned
+   */
+  getKeyType(key) {
+    const attrs = this.get_attributes(key);
+    return attrs?.customType;
+  }
   /**
    * Helper to get sorted keys (by zIndex).
    * Respects context filtering when set.
@@ -2643,9 +2939,28 @@ var MindCache = class {
   findKeyFromSanitizedTool(sanitizedKey) {
     return AIToolBuilder.findKeyFromSanitizedTool(this, sanitizedKey);
   }
+  /**
+   * Generate framework-agnostic tools with raw JSON Schema.
+   * Works with: OpenAI SDK, Anthropic SDK, LangChain, and other frameworks.
+   *
+   * Tool format:
+   * {
+   *   description: string,
+   *   parameters: { type: 'object', properties: {...}, required: [...] },
+   *   execute: async (args) => result
+   * }
+   *
+   * Security: All tools use llm_set_key internally which:
+   * - Only modifies VALUES, never attributes/systemTags
+   * - Prevents LLMs from escalating privileges
+   */
+  create_tools() {
+    return AIToolBuilder.createTools(this);
+  }
   /**
    * Generate Vercel AI SDK compatible tools for writable keys.
-   * For document type keys, generates additional tools: append_, insert_, edit_
+   * Wraps parameters with jsonSchema() for AI SDK v5 compatibility.
+   * Use this with: generateText(), streamText() from 'ai' package.
    *
    * Security: All tools use llm_set_key internally which:
    * - Only modifies VALUES, never attributes/systemTags
@@ -2688,8 +3003,6 @@ init_CloudAdapter();
 init_CloudAdapter();
 
 // src/cloud/OAuthClient.ts
-var DEFAULT_API_URL = "https://api.mindcache.dev";
-var DEFAULT_USERINFO_URL = DEFAULT_API_URL + "/oauth/userinfo";
 var TOKEN_REFRESH_BUFFER = 5 * 60 * 1e3;
 function generateRandomString(length2) {
   const array = new Uint8Array(length2);
@@ -2718,6 +3031,21 @@ var OAuthClient = class {
   tokens = null;
   refreshPromise = null;
   constructor(config) {
+    if (!config.baseUrl) {
+      throw new Error(
+        'MindCache OAuth: baseUrl is required!\n  For production: baseUrl: "https://api.mindcache.dev"\n  For local dev:  baseUrl: "http://localhost:8787"'
+      );
+    }
+    try {
+      const url = new URL(config.baseUrl);
+      if (url.hostname === "mindcache.dev") {
+        console.error(
+          '\u274C MindCache OAuth ERROR: baseUrl should be "api.mindcache.dev" not "mindcache.dev"\n   Current: ' + config.baseUrl + "\n   Correct: https://api.mindcache.dev"
+        );
+      }
+    } catch {
+      throw new Error("MindCache OAuth: Invalid baseUrl format: " + config.baseUrl);
+    }
     let redirectUri = config.redirectUri;
     if (!redirectUri && typeof window !== "undefined") {
       const url = new URL(window.location.href);
@@ -2725,55 +3053,54 @@ var OAuthClient = class {
       url.hash = "";
       redirectUri = url.toString();
     }
-    const baseUrl = config.baseUrl || config.apiUrl || DEFAULT_API_URL;
-    const authUrl = config.authUrl || baseUrl + "/oauth/authorize";
-    const tokenUrl = config.tokenUrl || baseUrl + "/oauth/token";
-    const apiUrl = config.apiUrl || baseUrl;
+    const baseUrl = config.baseUrl.replace(/\/$/, "");
     this.config = {
       clientId: config.clientId,
+      baseUrl,
       redirectUri: redirectUri || "",
       scopes: config.scopes || ["read", "write"],
-      baseUrl,
-      authUrl,
-      tokenUrl,
-      apiUrl,
       usePKCE: config.usePKCE !== false,
       // Default true
       storagePrefix: config.storagePrefix || "mindcache_oauth"
     };
-    console.log("\u{1F510} MindCache OAuth Config:", {
+    console.log("\u{1F510} MindCache OAuth:", {
       baseUrl: this.config.baseUrl,
-      authUrl: this.config.authUrl,
-      tokenUrl: this.config.tokenUrl,
-      apiUrl: this.config.apiUrl,
+      authUrl: this.authUrl,
+      tokenUrl: this.tokenUrl,
       clientId: this.config.clientId.substring(0, 20) + "..."
     });
     this.validateApi();
     this.loadTokens();
   }
+  /** Derived auth URL */
+  get authUrl() {
+    return this.config.baseUrl + "/oauth/authorize";
+  }
+  /** Derived token URL */
+  get tokenUrl() {
+    return this.config.baseUrl + "/oauth/token";
+  }
+  /** Derived userinfo URL */
+  get userinfoUrl() {
+    return this.config.baseUrl + "/oauth/userinfo";
+  }
   /**
-   * Validate the API is reachable and warn about common misconfigurations
+   * Validate the API is reachable
    */
   async validateApi() {
     try {
-      const response = await fetch(`${this.config.apiUrl}/oauth/apps/info`, {
+      const response = await fetch(`${this.config.baseUrl}/oauth/apps/info`, {
         method: "GET",
         headers: { "Accept": "application/json" }
       });
       if (response.status === 404) {
         console.error(
-          "\u274C MindCache OAuth ERROR: API not found at " + this.config.apiUrl + '\n   The server returned 404. Common causes:\n   - Wrong domain: Use "api.mindcache.dev" not "mindcache.dev"\n   - Wrong port: Local dev server is usually on port 8787\n   - Server not running: Make sure the MindCache server is started'
+          "\u274C MindCache OAuth ERROR: API not found at " + this.config.baseUrl + '\n   The server returned 404. Common causes:\n   - Wrong domain: Use "api.mindcache.dev" not "mindcache.dev"\n   - Wrong port: Local dev server is usually on port 8787\n   - Server not running: Make sure the MindCache server is started'
         );
-      } else if (!response.ok) {
-        console.warn(
-          "\u26A0\uFE0F MindCache OAuth: API responded with status " + response.status + "\n   URL: " + this.config.apiUrl
-        );
-      } else {
-        console.log("\u2705 MindCache OAuth: API is reachable at " + this.config.apiUrl);
       }
     } catch (error) {
       console.error(
-        "\u274C MindCache OAuth ERROR: Cannot reach API at " + this.config.apiUrl + "\n   Error: " + (error instanceof Error ? error.message : String(error)) + "\n   Check your network connection and baseUrl configuration."
+        "\u274C MindCache OAuth ERROR: Cannot reach API at " + this.config.baseUrl + "\n   Error: " + (error instanceof Error ? error.message : String(error))
       );
     }
   }
@@ -2802,7 +3129,7 @@ var OAuthClient = class {
   async authorize(options) {
     const state = options?.state || generateRandomString(32);
     this.setStorage("state", state);
-    const url = new URL(this.config.authUrl);
+    const url = new URL(this.authUrl);
     url.searchParams.set("response_type", "code");
     url.searchParams.set("client_id", this.config.clientId);
     url.searchParams.set("redirect_uri", this.config.redirectUri);
@@ -2865,7 +3192,7 @@ var OAuthClient = class {
       }
       body.code_verifier = codeVerifier;
     }
-    const response = await fetch(this.config.tokenUrl, {
+    const response = await fetch(this.tokenUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -2917,7 +3244,7 @@ var OAuthClient = class {
       throw new Error("No refresh token available");
     }
     try {
-      const response = await fetch(this.config.tokenUrl, {
+      const response = await fetch(this.tokenUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -2951,7 +3278,7 @@ var OAuthClient = class {
      */
   async getUserInfo() {
     const token = await this.getAccessToken();
-    const response = await fetch(DEFAULT_USERINFO_URL, {
+    const response = await fetch(this.userinfoUrl, {
       headers: {
         Authorization: `Bearer ${token}`
       }
@@ -2973,7 +3300,7 @@ var OAuthClient = class {
   async logout() {
     if (this.tokens?.accessToken) {
       try {
-        await fetch(this.config.tokenUrl.replace("/token", "/revoke"), {
+        await fetch(this.tokenUrl.replace("/token", "/revoke"), {
           method: "POST",
           headers: {
             "Content-Type": "application/json"
@@ -2996,7 +3323,7 @@ var OAuthClient = class {
   }
   /**
    * Token provider for MindCache cloud config
-   * This fetches a WebSocket token (short-lived) using the OAuth access token
+   * This fetches a WebSocket token using the OAuth access token
    * Use this with MindCacheCloudOptions.tokenProvider
    */
   tokenProvider = async () => {
@@ -3005,7 +3332,7 @@ var OAuthClient = class {
     if (!instanceId) {
       throw new Error("No instance ID available. Complete OAuth flow first.");
     }
-    const response = await fetch(`${this.config.apiUrl}/api/ws-token`, {
+    const response = await fetch(`${this.config.baseUrl}/api/ws-token`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -3025,7 +3352,6 @@ var OAuthClient = class {
   };
   /**
    * Get raw OAuth access token (for API calls, not WebSocket)
-   * Use getAccessToken() for most cases
    */
   accessTokenProvider = async () => {
     return this.getAccessToken();
@@ -3077,11 +3403,11 @@ function createOAuthClient(config) {
 // src/local/index.ts
 init_IndexedDBAdapter();
 function useMindCache(options) {
-  const [isLoaded, setIsLoaded] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const mindcacheRef = react.useRef(null);
-  const initializingRef = react.useRef(false);
-  react.useEffect(() => {
+  const [isLoaded, setIsLoaded] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  const mindcacheRef = React2.useRef(null);
+  const initializingRef = React2.useRef(false);
+  React2.useEffect(() => {
     if (initializingRef.current) {
       return;
     }
@@ -3110,16 +3436,1029 @@ function useMindCache(options) {
     error
   };
 }
+function createModel(provider, model, apiKey) {
+  switch (provider) {
+    case "openai": {
+      const openai$1 = openai.createOpenAI({ apiKey });
+      return openai$1(model);
+    }
+    case "anthropic":
+      throw new Error("Anthropic provider not yet implemented. Use modelProvider for custom providers.");
+    default:
+      throw new Error(`Unknown provider: ${provider}. Use modelProvider for custom providers.`);
+  }
+}
+var MindCacheContext = React2.createContext(null);
+function useMindCacheContext() {
+  const context = React2.useContext(MindCacheContext);
+  if (!context) {
+    throw new Error("useMindCacheContext must be used within a MindCacheProvider");
+  }
+  return context;
+}
+function MindCacheProvider({
+  mindcache: mcOptions,
+  sync: syncConfig,
+  ai: aiConfig = {},
+  children
+}) {
+  const [mindcache2, setMindcache] = React2.useState(null);
+  const [isLoaded, setIsLoaded] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  const [hasApiKey, setHasApiKey] = React2.useState(false);
+  const [lastSyncAt, setLastSyncAt] = React2.useState(null);
+  const [isSyncing, setIsSyncing] = React2.useState(false);
+  const initRef = React2.useRef(false);
+  const resolvedAiConfig = {
+    provider: "openai",
+    model: "gpt-4o",
+    keyStorage: "localStorage",
+    storageKey: "ai_api_key",
+    ...aiConfig
+  };
+  React2.useEffect(() => {
+    if (initRef.current) {
+      return;
+    }
+    initRef.current = true;
+    const init = async () => {
+      try {
+        const options = mcOptions || {
+          indexedDB: {
+            dbName: "mindcache_local_first",
+            storeName: "mindcache_store",
+            debounceMs: 1e3
+          }
+        };
+        const mc = new MindCache(options);
+        await mc.waitForSync();
+        setMindcache(mc);
+        setIsLoaded(true);
+        if (resolvedAiConfig.keyStorage === "localStorage" && typeof window !== "undefined") {
+          const stored = localStorage.getItem(resolvedAiConfig.storageKey || "openai_api_key");
+          setHasApiKey(!!stored);
+        } else if (resolvedAiConfig.apiKey) {
+          setHasApiKey(true);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setIsLoaded(true);
+      }
+    };
+    init();
+    return () => {
+      if (mindcache2) {
+        mindcache2.disconnect();
+      }
+    };
+  }, []);
+  const getApiKey = () => {
+    if (resolvedAiConfig.apiKey) {
+      return resolvedAiConfig.apiKey;
+    }
+    if (resolvedAiConfig.keyStorage === "localStorage" && typeof window !== "undefined") {
+      return localStorage.getItem(resolvedAiConfig.storageKey || "openai_api_key");
+    }
+    return null;
+  };
+  const setApiKey = (key) => {
+    if (resolvedAiConfig.keyStorage === "localStorage" && typeof window !== "undefined") {
+      localStorage.setItem(resolvedAiConfig.storageKey || "openai_api_key", key);
+      setHasApiKey(true);
+    }
+  };
+  const getModel = () => {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      throw new Error("API key not configured. Call setApiKey() first or configure ai.apiKey.");
+    }
+    if (resolvedAiConfig.modelProvider) {
+      return resolvedAiConfig.modelProvider(apiKey);
+    }
+    const provider = resolvedAiConfig.provider || "openai";
+    const model = resolvedAiConfig.model || "gpt-4o";
+    return createModel(provider, model, apiKey);
+  };
+  const syncToGitStore = async () => {
+    if (!mindcache2 || !syncConfig?.gitstore) {
+      return;
+    }
+    setIsSyncing(true);
+    try {
+      let gitStoreModule;
+      try {
+        gitStoreModule = await Function('return import("@mindcache/gitstore")')();
+      } catch {
+        throw new Error("@mindcache/gitstore is not installed. Run: npm install @mindcache/gitstore");
+      }
+      const { GitStore, MindCacheSync } = gitStoreModule;
+      const token = typeof syncConfig.gitstore.token === "function" ? await syncConfig.gitstore.token() : syncConfig.gitstore.token;
+      const gitStore = new GitStore({
+        owner: syncConfig.gitstore.owner,
+        repo: syncConfig.gitstore.repo,
+        tokenProvider: async () => token
+      });
+      const sync = new MindCacheSync(gitStore, mindcache2, {
+        filePath: syncConfig.gitstore.path || "mindcache.md"
+      });
+      await sync.save({ message: "Auto-sync from MindCache" });
+      setLastSyncAt(/* @__PURE__ */ new Date());
+    } catch (err) {
+      console.error("[MindCacheProvider] Sync error:", err);
+      throw err;
+    } finally {
+      setIsSyncing(false);
+    }
+  };
+  const value = {
+    mindcache: mindcache2,
+    isLoaded,
+    error,
+    aiConfig: resolvedAiConfig,
+    syncConfig,
+    getApiKey,
+    setApiKey,
+    hasApiKey,
+    getModel,
+    syncToGitStore,
+    lastSyncAt,
+    isSyncing
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(MindCacheContext.Provider, { value, children });
+}
+function generateId() {
+  return Math.random().toString(36).substring(2, 15) + Date.now().toString(36);
+}
+function useClientChat(options = {}) {
+  const context = useMindCacheContext();
+  const mc = options.mindcache || context.mindcache;
+  const [messages, setMessages] = React2.useState(options.initialMessages || []);
+  const [status, setStatus] = React2.useState("idle");
+  const [error, setError] = React2.useState(null);
+  const [streamingContent, setStreamingContent] = React2.useState("");
+  const abortControllerRef = React2.useRef(null);
+  const {
+    systemPrompt,
+    onMindCacheChange,
+    onFinish,
+    onError,
+    maxToolCalls = 5
+  } = options;
+  const apiKey = context.getApiKey();
+  const addMessage = React2.useCallback((msg) => {
+    const newMessage = {
+      ...msg,
+      id: generateId(),
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    setMessages((prev) => [...prev, newMessage]);
+    return newMessage;
+  }, []);
+  const clearMessages = React2.useCallback(() => {
+    setMessages([]);
+    setError(null);
+    setStreamingContent("");
+  }, []);
+  const stop = React2.useCallback(() => {
+    abortControllerRef.current?.abort();
+    setStatus("idle");
+  }, []);
+  const sendMessage = React2.useCallback(async (content) => {
+    if (!mc) {
+      const err = new Error("MindCache not initialized");
+      setError(err);
+      onError?.(err);
+      return;
+    }
+    if (!apiKey) {
+      const err = new Error("API key not configured. Please set your API key.");
+      setError(err);
+      onError?.(err);
+      return;
+    }
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = new AbortController();
+    const userMessage = addMessage({ role: "user", content });
+    setStatus("loading");
+    setError(null);
+    setStreamingContent("");
+    try {
+      const model = context.getModel();
+      const finalSystemPrompt = systemPrompt || mc.get_system_prompt();
+      const tools = mc.create_vercel_ai_tools();
+      const apiMessages = messages.concat(userMessage).map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      setStatus("streaming");
+      const parts = [];
+      let accumulatedText = "";
+      const result = await ai.streamText({
+        model,
+        system: finalSystemPrompt,
+        messages: apiMessages,
+        tools,
+        stopWhen: ai.stepCountIs(maxToolCalls),
+        abortSignal: abortControllerRef.current.signal,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        onStepFinish: async (step) => {
+          if (step.toolCalls && step.toolCalls.length > 0) {
+            for (const toolCall of step.toolCalls) {
+              const toolName = toolCall.toolName;
+              const args = toolCall.args || toolCall.input || {};
+              parts.push({
+                type: "tool-call",
+                toolCallId: toolCall.toolCallId,
+                toolName,
+                args
+              });
+              if (typeof toolName === "string" && (toolName.startsWith("write_") || toolName === "create_key")) {
+                const value = args.value;
+                const result2 = mc.executeToolCall(toolName, value);
+                parts.push({
+                  type: "tool-result",
+                  toolCallId: toolCall.toolCallId,
+                  toolName,
+                  result: result2
+                });
+                onMindCacheChange?.();
+              }
+            }
+          }
+          if (step.text) {
+            accumulatedText += step.text;
+          }
+        }
+      });
+      for await (const chunk of result.textStream) {
+        accumulatedText += chunk;
+        setStreamingContent(accumulatedText);
+      }
+      if (accumulatedText) {
+        parts.unshift({ type: "text", text: accumulatedText });
+      }
+      const assistantMessage = {
+        id: generateId(),
+        role: "assistant",
+        content: accumulatedText,
+        parts: parts.length > 0 ? parts : void 0,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      setMessages((prev) => [...prev, assistantMessage]);
+      setStreamingContent("");
+      setStatus("idle");
+      onFinish?.(assistantMessage);
+    } catch (err) {
+      if (err.name === "AbortError") {
+        if (streamingContent) {
+          const partialMessage = {
+            id: generateId(),
+            role: "assistant",
+            content: streamingContent + " [stopped]",
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          setMessages((prev) => [...prev, partialMessage]);
+        }
+        setStreamingContent("");
+        setStatus("idle");
+        return;
+      }
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      setStatus("error");
+      setStreamingContent("");
+      onError?.(error2);
+    }
+  }, [
+    mc,
+    apiKey,
+    context,
+    messages,
+    systemPrompt,
+    maxToolCalls,
+    addMessage,
+    onMindCacheChange,
+    onFinish,
+    onError,
+    streamingContent
+  ]);
+  React2.useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  return {
+    messages,
+    status,
+    error,
+    sendMessage,
+    clearMessages,
+    isLoading: status === "loading" || status === "streaming",
+    addMessage,
+    stop,
+    streamingContent
+  };
+}
+var defaultTheme = {
+  background: "#000",
+  userBubble: "#1a1a2e",
+  assistantBubble: "#0d0d0d",
+  textColor: "#22c55e",
+  secondaryTextColor: "#6b7280",
+  borderColor: "#333",
+  primaryColor: "#22c55e",
+  fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'
+};
+function DefaultMessage({
+  message,
+  theme
+}) {
+  const isUser = message.role === "user";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        display: "flex",
+        justifyContent: isUser ? "flex-end" : "flex-start",
+        marginBottom: "12px"
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          style: {
+            maxWidth: "80%",
+            padding: "12px 16px",
+            borderRadius: "12px",
+            backgroundColor: isUser ? theme.userBubble : theme.assistantBubble,
+            border: `1px solid ${theme.borderColor}`
+          },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                style: {
+                  fontSize: "10px",
+                  color: theme.secondaryTextColor,
+                  marginBottom: "4px",
+                  textTransform: "uppercase"
+                },
+                children: isUser ? "You" : "Assistant"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                style: {
+                  color: theme.textColor,
+                  whiteSpace: "pre-wrap",
+                  wordBreak: "break-word",
+                  lineHeight: 1.5
+                },
+                children: message.content
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+}
+function ApiKeyInput({
+  theme,
+  onSubmit
+}) {
+  const [key, setKey] = React2.useState("");
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    if (key.trim()) {
+      onSubmit(key.trim());
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        height: "100%",
+        padding: "20px"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              fontSize: "14px",
+              color: theme.textColor,
+              marginBottom: "16px",
+              textAlign: "center"
+            },
+            children: "Enter your API key to start chatting"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, style: { width: "100%", maxWidth: "400px" }, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "password",
+              value: key,
+              onChange: (e) => setKey(e.target.value),
+              placeholder: "sk-...",
+              style: {
+                width: "100%",
+                padding: "12px",
+                backgroundColor: theme.assistantBubble,
+                border: `1px solid ${theme.borderColor}`,
+                borderRadius: "8px",
+                color: theme.textColor,
+                fontFamily: theme.fontFamily,
+                fontSize: "14px",
+                marginBottom: "12px"
+              }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "submit",
+              disabled: !key.trim(),
+              style: {
+                width: "100%",
+                padding: "12px",
+                backgroundColor: theme.primaryColor,
+                border: "none",
+                borderRadius: "8px",
+                color: "#000",
+                fontFamily: theme.fontFamily,
+                fontSize: "14px",
+                fontWeight: "bold",
+                cursor: key.trim() ? "pointer" : "not-allowed",
+                opacity: key.trim() ? 1 : 0.5
+              },
+              children: "Save & Start"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              fontSize: "11px",
+              color: theme.secondaryTextColor,
+              marginTop: "16px",
+              textAlign: "center"
+            },
+            children: "Your key is stored locally and never sent to our servers."
+          }
+        )
+      ]
+    }
+  );
+}
+function MindCacheChat({
+  theme: customTheme,
+  placeholder = "Type a message...",
+  welcomeMessage = "Hello! I'm ready to help you.",
+  showApiKeyInput = true,
+  className,
+  style,
+  renderMessage,
+  header,
+  footer,
+  initialMessages,
+  ...chatOptions
+}) {
+  const context = useMindCacheContext();
+  const theme = { ...defaultTheme, ...customTheme };
+  const messagesEndRef = React2.useRef(null);
+  const inputRef = React2.useRef(null);
+  const [inputValue, setInputValue] = React2.useState("");
+  const defaultInitialMessages = welcomeMessage ? [
+    {
+      id: "welcome",
+      role: "assistant",
+      content: welcomeMessage,
+      createdAt: /* @__PURE__ */ new Date()
+    }
+  ] : [];
+  const {
+    messages,
+    sendMessage,
+    isLoading,
+    error,
+    streamingContent,
+    stop
+  } = useClientChat({
+    ...chatOptions,
+    initialMessages: initialMessages || defaultInitialMessages,
+    mindcache: context.mindcache || void 0
+  });
+  React2.useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+  const handleSubmit = async (e) => {
+    e?.preventDefault();
+    if (!inputValue.trim() || isLoading) {
+      return;
+    }
+    const message = inputValue.trim();
+    setInputValue("");
+    await sendMessage(message);
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      handleSubmit();
+    }
+  };
+  if (showApiKeyInput && !context.hasApiKey && context.aiConfig.keyStorage !== "memory") {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className,
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          height: "100%",
+          backgroundColor: theme.background,
+          fontFamily: theme.fontFamily,
+          ...style
+        },
+        children: [
+          header,
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ApiKeyInput,
+            {
+              theme,
+              onSubmit: (key) => context.setApiKey(key)
+            }
+          ),
+          footer
+        ]
+      }
+    );
+  }
+  if (!context.isLoaded) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className,
+        style: {
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          height: "100%",
+          backgroundColor: theme.background,
+          color: theme.textColor,
+          fontFamily: theme.fontFamily,
+          ...style
+        },
+        children: "Loading..."
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className,
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        height: "100%",
+        backgroundColor: theme.background,
+        fontFamily: theme.fontFamily,
+        ...style
+      },
+      children: [
+        header,
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              flex: 1,
+              overflowY: "auto",
+              padding: "16px"
+            },
+            children: [
+              messages.map((message) => renderMessage ? /* @__PURE__ */ jsxRuntime.jsx(React2__default.default.Fragment, { children: renderMessage(message) }, message.id) : /* @__PURE__ */ jsxRuntime.jsx(DefaultMessage, { message, theme }, message.id)),
+              streamingContent && /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    justifyContent: "flex-start",
+                    marginBottom: "12px"
+                  },
+                  children: /* @__PURE__ */ jsxRuntime.jsxs(
+                    "div",
+                    {
+                      style: {
+                        maxWidth: "80%",
+                        padding: "12px 16px",
+                        borderRadius: "12px",
+                        backgroundColor: theme.assistantBubble,
+                        border: `1px solid ${theme.borderColor}`
+                      },
+                      children: [
+                        /* @__PURE__ */ jsxRuntime.jsx(
+                          "div",
+                          {
+                            style: {
+                              fontSize: "10px",
+                              color: theme.secondaryTextColor,
+                              marginBottom: "4px",
+                              textTransform: "uppercase"
+                            },
+                            children: "Assistant"
+                          }
+                        ),
+                        /* @__PURE__ */ jsxRuntime.jsxs(
+                          "div",
+                          {
+                            style: {
+                              color: theme.textColor,
+                              whiteSpace: "pre-wrap",
+                              wordBreak: "break-word",
+                              lineHeight: 1.5
+                            },
+                            children: [
+                              streamingContent,
+                              /* @__PURE__ */ jsxRuntime.jsx("span", { style: { opacity: 0.5, animation: "blink 1s infinite" }, children: "\u258A" })
+                            ]
+                          }
+                        )
+                      ]
+                    }
+                  )
+                }
+              ),
+              isLoading && !streamingContent && /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    justifyContent: "flex-start",
+                    marginBottom: "12px"
+                  },
+                  children: /* @__PURE__ */ jsxRuntime.jsx(
+                    "div",
+                    {
+                      style: {
+                        padding: "12px 16px",
+                        borderRadius: "12px",
+                        backgroundColor: theme.assistantBubble,
+                        border: `1px solid ${theme.borderColor}`,
+                        color: theme.secondaryTextColor
+                      },
+                      children: "Thinking..."
+                    }
+                  )
+                }
+              ),
+              error && /* @__PURE__ */ jsxRuntime.jsxs(
+                "div",
+                {
+                  style: {
+                    padding: "12px",
+                    marginBottom: "12px",
+                    borderRadius: "8px",
+                    backgroundColor: "rgba(239, 68, 68, 0.1)",
+                    border: "1px solid rgba(239, 68, 68, 0.3)",
+                    color: "#ef4444",
+                    fontSize: "13px"
+                  },
+                  children: [
+                    "Error: ",
+                    error.message
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { ref: messagesEndRef })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "form",
+          {
+            onSubmit: handleSubmit,
+            style: {
+              padding: "12px 16px",
+              borderTop: `1px solid ${theme.borderColor}`
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsxs(
+              "div",
+              {
+                style: {
+                  display: "flex",
+                  gap: "8px",
+                  alignItems: "flex-end"
+                },
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "textarea",
+                    {
+                      ref: inputRef,
+                      value: inputValue,
+                      onChange: (e) => {
+                        setInputValue(e.target.value);
+                        e.target.style.height = "auto";
+                        e.target.style.height = Math.min(e.target.scrollHeight, 120) + "px";
+                      },
+                      onKeyDown: handleKeyDown,
+                      placeholder: isLoading ? "Waiting for response..." : placeholder,
+                      disabled: isLoading,
+                      rows: 1,
+                      style: {
+                        flex: 1,
+                        padding: "12px",
+                        backgroundColor: theme.assistantBubble,
+                        border: `1px solid ${theme.borderColor}`,
+                        borderRadius: "8px",
+                        color: theme.textColor,
+                        fontFamily: theme.fontFamily,
+                        fontSize: "16px",
+                        // Prevents iOS zoom on focus
+                        resize: "none",
+                        minHeight: "44px",
+                        // Apple touch target minimum
+                        maxHeight: "120px",
+                        outline: "none",
+                        WebkitAppearance: "none"
+                        // Remove iOS styling
+                      }
+                    }
+                  ),
+                  isLoading ? /* @__PURE__ */ jsxRuntime.jsx(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: stop,
+                      style: {
+                        padding: "12px 20px",
+                        minWidth: "44px",
+                        // Touch target
+                        minHeight: "44px",
+                        // Touch target
+                        backgroundColor: "#ef4444",
+                        border: "none",
+                        borderRadius: "8px",
+                        color: "#fff",
+                        fontFamily: theme.fontFamily,
+                        fontSize: "16px",
+                        fontWeight: "bold",
+                        cursor: "pointer",
+                        transition: "opacity 0.2s",
+                        WebkitTapHighlightColor: "transparent",
+                        touchAction: "manipulation"
+                        // Faster touch response
+                      },
+                      children: "Stop"
+                    }
+                  ) : /* @__PURE__ */ jsxRuntime.jsx(
+                    "button",
+                    {
+                      type: "submit",
+                      disabled: !inputValue.trim(),
+                      style: {
+                        padding: "12px 20px",
+                        minWidth: "44px",
+                        // Touch target
+                        minHeight: "44px",
+                        // Touch target
+                        backgroundColor: theme.primaryColor,
+                        border: "none",
+                        borderRadius: "8px",
+                        color: "#000",
+                        fontFamily: theme.fontFamily,
+                        fontSize: "16px",
+                        fontWeight: "bold",
+                        cursor: !inputValue.trim() ? "not-allowed" : "pointer",
+                        opacity: !inputValue.trim() ? 0.5 : 1,
+                        transition: "opacity 0.2s",
+                        WebkitTapHighlightColor: "transparent",
+                        touchAction: "manipulation"
+                        // Faster touch response
+                      },
+                      children: "Send"
+                    }
+                  )
+                ]
+              }
+            )
+          }
+        ),
+        footer
+      ]
+    }
+  );
+}
+function useLocalFirstSync(options) {
+  const {
+    mindcache: mindcache2,
+    gitstore,
+    server,
+    autoSyncInterval = 0,
+    saveDebounceMs = 5e3,
+    loadOnMount = true,
+    mergeOnLoad = true
+  } = options;
+  const [status, setStatus] = React2.useState("idle");
+  const [error, setError] = React2.useState(null);
+  const [lastSyncAt, setLastSyncAt] = React2.useState(null);
+  const [hasLocalChanges, setHasLocalChanges] = React2.useState(false);
+  const saveTimeoutRef = React2.useRef(null);
+  const syncIntervalRef = React2.useRef(null);
+  const mountedRef = React2.useRef(true);
+  const getToken = React2.useCallback(async () => {
+    if (!gitstore) {
+      throw new Error("GitStore not configured");
+    }
+    return typeof gitstore.token === "function" ? await gitstore.token() : gitstore.token;
+  }, [gitstore]);
+  const load = React2.useCallback(async () => {
+    if (!mindcache2) {
+      return;
+    }
+    setStatus("loading");
+    setError(null);
+    try {
+      if (gitstore) {
+        let gitStoreModule;
+        try {
+          gitStoreModule = await Function('return import("@mindcache/gitstore")')();
+        } catch {
+          throw new Error("@mindcache/gitstore is not installed. Run: npm install @mindcache/gitstore");
+        }
+        const { GitStore, MindCacheSync } = gitStoreModule;
+        const token = await getToken();
+        const store = new GitStore({
+          owner: gitstore.owner,
+          repo: gitstore.repo,
+          branch: gitstore.branch,
+          tokenProvider: async () => token
+        });
+        const sync2 = new MindCacheSync(store, mindcache2, {
+          filePath: gitstore.path || "mindcache.md"
+        });
+        await sync2.load({ merge: mergeOnLoad });
+      } else if (server) {
+        const response = await fetch(server.url, {
+          headers: server.authToken ? { Authorization: `Bearer ${server.authToken}` } : {}
+        });
+        if (response.ok) {
+          const markdown = await response.text();
+          mindcache2.fromMarkdown(markdown, mergeOnLoad);
+        }
+      }
+      if (mountedRef.current) {
+        setLastSyncAt(/* @__PURE__ */ new Date());
+        setStatus("idle");
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStatus("error");
+      }
+      throw err;
+    }
+  }, [mindcache2, gitstore, server, getToken, mergeOnLoad]);
+  const save = React2.useCallback(async (message) => {
+    if (!mindcache2) {
+      return;
+    }
+    setStatus("saving");
+    setError(null);
+    try {
+      if (gitstore) {
+        let gitStoreModule;
+        try {
+          gitStoreModule = await Function('return import("@mindcache/gitstore")')();
+        } catch {
+          throw new Error("@mindcache/gitstore is not installed. Run: npm install @mindcache/gitstore");
+        }
+        const { GitStore, MindCacheSync } = gitStoreModule;
+        const token = await getToken();
+        const store = new GitStore({
+          owner: gitstore.owner,
+          repo: gitstore.repo,
+          branch: gitstore.branch,
+          tokenProvider: async () => token
+        });
+        const sync2 = new MindCacheSync(store, mindcache2, {
+          filePath: gitstore.path || "mindcache.md"
+        });
+        await sync2.save({ message: message || "MindCache sync" });
+      } else if (server) {
+        await fetch(server.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "text/plain",
+            ...server.authToken ? { Authorization: `Bearer ${server.authToken}` } : {}
+          },
+          body: mindcache2.toMarkdown()
+        });
+      }
+      if (mountedRef.current) {
+        setLastSyncAt(/* @__PURE__ */ new Date());
+        setHasLocalChanges(false);
+        setStatus("idle");
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStatus("error");
+      }
+      throw err;
+    }
+  }, [mindcache2, gitstore, server, getToken]);
+  const sync = React2.useCallback(async () => {
+    setStatus("syncing");
+    try {
+      await load();
+      if (hasLocalChanges) {
+        await save();
+      }
+    } catch (err) {
+    }
+  }, [load, save, hasLocalChanges]);
+  const markSaved = React2.useCallback(() => {
+    setHasLocalChanges(false);
+  }, []);
+  React2.useEffect(() => {
+    if (!mindcache2 || !gitstore || saveDebounceMs <= 0) {
+      return;
+    }
+    const unsubscribe = mindcache2.subscribeToAll(() => {
+      setHasLocalChanges(true);
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+      }
+      saveTimeoutRef.current = setTimeout(() => {
+        save("Auto-save").catch(console.error);
+      }, saveDebounceMs);
+    });
+    return () => {
+      unsubscribe();
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+      }
+    };
+  }, [mindcache2, gitstore, saveDebounceMs, save]);
+  React2.useEffect(() => {
+    if (!mindcache2 || autoSyncInterval <= 0) {
+      return;
+    }
+    syncIntervalRef.current = setInterval(() => {
+      sync().catch(console.error);
+    }, autoSyncInterval);
+    return () => {
+      if (syncIntervalRef.current) {
+        clearInterval(syncIntervalRef.current);
+      }
+    };
+  }, [mindcache2, autoSyncInterval, sync]);
+  React2.useEffect(() => {
+    if (loadOnMount && mindcache2 && (gitstore || server)) {
+      load().catch(console.error);
+    }
+  }, [mindcache2, gitstore, server, loadOnMount]);
+  React2.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  return {
+    status,
+    error,
+    lastSyncAt,
+    hasLocalChanges,
+    load,
+    save,
+    sync,
+    markSaved
+  };
+}
 
 // src/index.ts
 var mindcache = new MindCache();
 
 exports.DEFAULT_KEY_ATTRIBUTES = DEFAULT_KEY_ATTRIBUTES;
 exports.MindCache = MindCache;
+exports.MindCacheChat = MindCacheChat;
+exports.MindCacheProvider = MindCacheProvider;
 exports.OAuthClient = OAuthClient;
+exports.SchemaParser = SchemaParser;
 exports.SystemTagHelpers = SystemTagHelpers;
 exports.createOAuthClient = createOAuthClient;
 exports.mindcache = mindcache;
+exports.useClientChat = useClientChat;
+exports.useLocalFirstSync = useLocalFirstSync;
 exports.useMindCache = useMindCache;
+exports.useMindCacheContext = useMindCacheContext;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map