@cachly-dev/mcp-server 0.10.0 → 0.10.2

package/src/index.ts

@@ -52,22 +52,19 @@ import { Redis } from 'ioredis';
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
 let JWT = process.env.CACHLY_JWT ?? '';
 const EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.10.0';
+const CURRENT_VERSION = '0.9.17';
 
 // ── Default Instance Resolution (for Smithery & single-credential setups) ────
 // When CACHLY_BRAIN_INSTANCE_ID is set, tools can omit the instance_id parameter.
 // When neither is set, we auto-fetch the first running instance once per process.
 let _defaultInstanceId: string = process.env.CACHLY_BRAIN_INSTANCE_ID ?? '';
-// Timestamp of last failed fetch — retries after 30 s (not permanently blocked).
-let _defaultInstanceLastAttempt = 0;
+let _defaultInstanceFetched = false;
 
 async function resolveDefaultInstanceId(): Promise<string> {
   if (_defaultInstanceId) return _defaultInstanceId;
+  if (_defaultInstanceFetched) return '';
+  _defaultInstanceFetched = true;
   if (!JWT) return '';
-  // Cooldown: don't hammer the API on every tool call after a transient failure.
-  const now = Date.now();
-  if (_defaultInstanceLastAttempt > 0 && now - _defaultInstanceLastAttempt < 30_000) return '';
-  _defaultInstanceLastAttempt = now;
   try {
     const res = await fetch(`${API_URL}/api/v1/instances`, {
       headers: { Authorization: `Bearer ${JWT}`, Accept: 'application/json' },
@@ -75,15 +72,9 @@ async function resolveDefaultInstanceId(): Promise<string> {
     });
     if (!res.ok) return '';
     const data = await res.json() as { data?: Array<{ id: string; status: string }> };
-    const instances = (data?.data ?? []) as Array<{ id: string; status: string }>;
-    // Prefer running, fall back to provisioning so the ID is resolved even during startup.
-    const best = instances.find(i => i.status === 'running') ?? instances.find(i => i.status === 'provisioning');
-    if (best) {
-      _defaultInstanceId = best.id;
-      _defaultInstanceLastAttempt = 0;
-      return _defaultInstanceId;
-    }
-  } catch { /* transient error — will retry after cooldown */ }
+    const running = (data?.data ?? []).filter(i => i.status === 'running');
+    if (running.length > 0) { _defaultInstanceId = running[0].id; return _defaultInstanceId; }
+  } catch { /* non-fatal — caller will surface missing instance_id error */ }
   return '';
 }
 
@@ -158,55 +149,24 @@ async function pollDeviceFlow(flow: DeviceFlowState): Promise<'pending' | 'expir
       JWT = apiKey;
       setEmbedJwt(apiKey); // keep embeddings.ts in sync
       _deviceFlow = null;
-      // Auto-provision: find or create the user's brain instance.
-      _defaultInstanceLastAttempt = 0;
+      // Auto-provision instance
+      _defaultInstanceFetched = false;
       await resolveDefaultInstanceId();
       if (!_defaultInstanceId) {
+        // Try auto-provision
         try {
           const autoRes = await fetch(`${API_URL}/api/v1/instances/auto`, {
             method: 'POST',
             headers: { Authorization: `Bearer ${JWT}`, 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(12000),
+            signal: AbortSignal.timeout(10000),
           });
           if (autoRes.ok) {
-            const body = await autoRes.json() as {
-              instance?: { id: string; status?: string };
-              instance_id?: string;
-              status?: string;
-            };
+            const body = await autoRes.json() as { instance?: { id: string }; instance_id?: string };
             const id = body.instance?.id ?? body.instance_id;
             if (id) _defaultInstanceId = id;
           }
         } catch { /* non-fatal */ }
       }
-      // Give a provisioning instance a head-start so getConnection's wait is shorter.
-      // The instance is almost always ready by the time the user's tool re-enters.
-      if (_defaultInstanceId) {
-        try {
-          const checkRes = await fetch(`${API_URL}/api/v1/instances/${_defaultInstanceId}`, {
-            headers: { Authorization: `Bearer ${JWT}`, Accept: 'application/json' },
-            signal: AbortSignal.timeout(4000),
-          });
-          if (checkRes.ok) {
-            const checkInst = await checkRes.json() as { status?: string };
-            if (checkInst.status === 'provisioning') {
-              // Wait up to 20s here so the re-entered tool call lands on a running instance.
-              const pDeadline = Date.now() + 20_000;
-              while (checkInst.status === 'provisioning' && Date.now() < pDeadline) {
-                await new Promise(r => setTimeout(r, 3000));
-                const rr = await fetch(`${API_URL}/api/v1/instances/${_defaultInstanceId}`, {
-                  headers: { Authorization: `Bearer ${JWT}`, Accept: 'application/json' },
-                  signal: AbortSignal.timeout(4000),
-                }).catch(() => null);
-                if (rr?.ok) {
-                  const ri = await rr.json() as { status?: string };
-                  (checkInst as { status?: string }).status = ri.status;
-                } else { break; }
-              }
-            }
-          }
-        } catch { /* non-fatal — getConnection will handle the wait if still provisioning */ }
-      }
       return 'done';
     }
     if (data.error === 'slow_down') flow.pollInterval = Math.min(flow.pollInterval + 2000, 15000);
@@ -256,48 +216,18 @@ interface SemanticSearchResponse {
 const pool = new Map<string, Redis>();
 
 async function getConnection(instance_id: string): Promise<Redis> {
-  if (!instance_id) {
-    throw new McpError(
-      ErrorCode.InvalidRequest,
-      'No instance_id provided and no running instance could be resolved automatically.\n\n' +
-      '• Set CACHLY_BRAIN_INSTANCE_ID in your MCP config, or\n' +
-      '• Pass instance_id explicitly to the tool, or\n' +
-      '• Run `list_instances` to see your available instances.'
-    );
-  }
-
   if (pool.has(instance_id)) return pool.get(instance_id)!;
 
-  // Fetch instance, waiting up to 25 s if it is still provisioning.
-  // This covers the zero-friction path: device-flow auth → auto-provision → first tool call
-  // all happen in quick succession and the instance isn't running yet.
-  let inst = await apiFetch<Instance>(`/api/v1/instances/${instance_id}`);
-  if (inst.status === 'provisioning') {
-    const deadline = Date.now() + 25_000;
-    while (inst.status === 'provisioning' && Date.now() < deadline) {
-      await new Promise(r => setTimeout(r, 3000));
-      inst = await apiFetch<Instance>(`/api/v1/instances/${instance_id}`);
-    }
-  }
-
+  const inst = await apiFetch<Instance>(`/api/v1/instances/${instance_id}`);
   if (inst.status !== 'running') {
-    // Telemetry: unreachable instance so the team can proactively investigate
-    void fetch(`${API_URL}/api/v1/telemetry/mcp`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', ...(JWT ? { Authorization: `Bearer ${JWT}` } : {}) },
-      body: JSON.stringify({ event: 'instance_not_reachable', instance_id, status: inst.status, version: CURRENT_VERSION }),
-      signal: AbortSignal.timeout(3000),
-    }).catch(() => {});
-    const hint = inst.status === 'provisioning'
-      ? `⏳ Brain instance "${inst.name}" is still starting up.\n\nThis usually finishes within 30 seconds. Please try again in a moment.`
-      : `Brain instance "${inst.name}" is not reachable (status: ${inst.status}).\n\n` +
-        `• View your instance at: https://cachly.dev/instances\n` +
-        `• Run \`get_api_status\` for a full diagnostic.`;
-    throw new McpError(ErrorCode.InvalidRequest, hint);
+    throw new McpError(
+      ErrorCode.InvalidRequest,
+      `Instance "${inst.name}" is not running (status: ${inst.status}). ` +
+        `It may still be provisioning or awaiting payment.`
+    );
   }
   if (!inst.host || !inst.port) {
-    throw new McpError(ErrorCode.InternalError,
-      `Instance "${inst.name}" is running but has no host/port — contact support@cachly.dev.`);
+    throw new McpError(ErrorCode.InternalError, `Instance "${inst.name}" has no host/port yet.`);
   }
 
   // Fetch connection details (includes password) from the dedicated endpoint.
@@ -310,7 +240,7 @@ async function getConnection(instance_id: string): Promise<Redis> {
     password = conn.password ?? undefined;
     tlsEnabled = conn.tls_enabled !== false;
   } catch {
-    // Fallback: use TLS flag from instance metadata
+    // Fallback: no password, use TLS default from instance
   }
 
   const client = new Redis({
@@ -318,33 +248,26 @@ async function getConnection(instance_id: string): Promise<Redis> {
     port: inst.port,
     password: password || undefined,
     ...(tlsEnabled ? { tls: {} } : {}),
-    lazyConnect: true,
+    lazyConnect: true,          // don't auto-connect — we connect explicitly below
     enableReadyCheck: true,
-    connectTimeout: 8000,
+    connectTimeout: 5000,
     retryStrategy: () => null,  // fail fast, no reconnect loops in MCP context
   });
 
-  const evict = () => pool.delete(instance_id);
-  client.on('error', evict);
-  client.on('end', evict);
+  client.on('error', () => {
+    pool.delete(instance_id); // remove stale connection on error
+  });
 
+  // Connect explicitly so we can catch connection errors as a proper rejected
+  // Promise instead of an unhandled 'error' event that would kill the process.
   try {
     await client.connect();
   } catch (err: unknown) {
     client.disconnect();
     const msg = err instanceof Error ? err.message : String(err);
-    void fetch(`${API_URL}/api/v1/telemetry/mcp`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', ...(JWT ? { Authorization: `Bearer ${JWT}` } : {}) },
-      body: JSON.stringify({ event: 'redis_connect_failed', instance_id, host: inst.host, port: inst.port, error: msg, version: CURRENT_VERSION }),
-      signal: AbortSignal.timeout(3000),
-    }).catch(() => {});
     throw new McpError(
       ErrorCode.InternalError,
-      `Could not reach Brain instance "${inst.name}" (${inst.host}:${inst.port}).\n\n` +
-      `• Check your network connection\n` +
-      `• Run \`get_api_status\` to verify instance status\n` +
-      `• Technical detail: ${msg}`
+      `Could not connect to instance "${inst.name}" (${inst.host}:${inst.port}): ${msg}`
     );
   }
 
@@ -460,6 +383,61 @@ async function sendAnonymousTelemetry(toolName: string): Promise<void> {
 }
 
 async function handleTool(name: string, args: Record<string, unknown>): Promise<string> {
+  // ── sign_in: explicit device-flow trigger — works even without JWT ────────
+  if (name === 'sign_in') {
+    if (JWT) {
+      return '✅ **Already signed in.** Your cachly AI Brain is ready — all 63 tools available.';
+    }
+    // Poll if flow already in progress
+    if (_deviceFlow) {
+      const result = await pollDeviceFlow(_deviceFlow);
+      if (result === 'done') {
+        return [
+          '✅ **Sign-in complete!** Your cachly AI Brain is ready.',
+          '',
+          'All 63 brain tools are now available. Start with `session_start` to load context from your last session.',
+        ].join('\n');
+      }
+      if (result === 'expired') {
+        _deviceFlow = null;
+        // fall through to start a new flow
+      } else {
+        return [
+          '⏳ **Waiting for you to approve in the browser...**',
+          '',
+          `Sign in at: **${_deviceFlow.verifyUrl}**`,
+          `Code: **${_deviceFlow.userCode}**`,
+          '',
+          'After approving, call `sign_in` again — it will complete automatically.',
+        ].join('\n');
+      }
+    }
+    const flow = await startDeviceFlow();
+    if (flow) {
+      _deviceFlow = flow;
+      return [
+        '🧠 **cachly AI Brain — One-click sign in**',
+        '',
+        '1. Open this URL (it may open automatically):',
+        `   **${flow.verifyUrl}**`,
+        '',
+        `2. If prompted for a code, enter: **${flow.userCode}**`,
+        '',
+        '3. After approving in your browser, call `sign_in` again — it will complete automatically.',
+        '',
+        '✨ Free tier: 1 Brain instance · persistent memory · 63 MCP tools · no credit card required.',
+      ].join('\n');
+    }
+    return [
+      '🧠 **cachly AI Brain — Setup required**',
+      '',
+      'Run once in your terminal:',
+      '   `npx @cachly-dev/mcp-server@latest setup`',
+      '',
+      'Or sign up at: https://cachly.dev/setup-ai',
+    ].join('\n');
+  }
+
   // Guard: if no JWT, return actionable onboarding message instead of HTTP 401
   if (!JWT) {
     void sendAnonymousTelemetry(name);
@@ -614,44 +592,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         authInfo = '❌ JWT decode failed – check CACHLY_JWT format';
       }
 
-      // List instances + connectivity
-      let instanceInfo = '';
-      try {
-        const listRes = await apiFetch<{ data: Instance[] }>('/api/v1/instances');
-        const instances = listRes.data ?? [];
-        if (instances.length === 0) {
-          instanceInfo = '\n\n🧠 **Brain Instances:** none — create one at https://cachly.dev/instances';
-        } else {
-          const lines: string[] = ['\n\n🧠 **Brain Instances:**'];
-          for (const inst of instances) {
-            const badge = inst.status === 'running' ? '🟢' : inst.status === 'provisioning' ? '🟡' : '🔴';
-            const defaultMark = inst.id === _defaultInstanceId ? ' ← active' : '';
-            lines.push(`  ${badge} **${inst.name}** (\`${inst.id}\`) · ${inst.status}${defaultMark}`);
-            if (inst.status === 'running' && inst.host) {
-              // Try a quick ping on the cached connection
-              const pooled = pool.get(inst.id);
-              if (pooled) {
-                try {
-                  await pooled.ping();
-                  lines.push(`     💓 Redis: connected`);
-                } catch {
-                  lines.push(`     ⚠️  Redis: pooled but ping failed — will reconnect on next use`);
-                }
-              } else {
-                lines.push(`     💤 Redis: not connected yet (connects on first tool use)`);
-              }
-            } else if (inst.status === 'provisioning') {
-              lines.push(`     ⏳ Still provisioning — check back in ~30 s`);
-            } else if (inst.status !== 'running') {
-              lines.push(`     ❌ Not reachable (status: ${inst.status})`);
-            }
-          }
-          instanceInfo = lines.join('\n');
-        }
-      } catch (e) {
-        instanceInfo = `\n\n🧠 **Brain Instances:** could not fetch — ${(e as Error).message}`;
-      }
-
       return [
         `📡 **cachly API Status**`,
         ``,
@@ -660,7 +600,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         ``,
         `🔑 **Auth:**`,
         authInfo,
-        instanceInfo,
       ].join('\n');
     }
 
@@ -674,7 +613,15 @@ const server = new Server(
   { capabilities: { tools: {} } }
 );
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  if (!JWT) {
+    // Surface sign_in as the only prominent tool when not authenticated,
+    // so AI assistants proactively call it before attempting any brain tool.
+    const signInTool = TOOLS.find(t => t.name === 'sign_in');
+    return { tools: signInTool ? [signInTool] : TOOLS };
+  }
+  return { tools: TOOLS };
+});
 
 // ── Auto-session management ───────────────────────────────────────────────────
 // Transparently starts a Brain session on the first tool call of a process
@@ -698,9 +645,8 @@ async function autoStartSession(instanceId: string): Promise<void> {
     _autoSessionInstanceId = instanceId;
     try {
       await handleTool('session_start', { instance_id: instanceId, focus: 'auto (MCP session)' });
-    } catch { /* non-fatal — session tracking is a best-effort feature */ } finally {
-      _autoSessionStarting = null;
-    }
+    } catch { /* non-fatal — session tracking is a best-effort feature */ }
+    _autoSessionStarting = null;
   })();
   await _autoSessionStarting;
 
@@ -749,9 +695,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   // Skip session management tools to avoid recursion.
   const sessionTools = new Set(['session_start', 'session_end', 'auto_learn_session']);
   if (!sessionTools.has(name) && !_autoSessionStarted && !_autoSessionStarting) {
-    const instanceId = ((args as Record<string, unknown>)?.instance_id as string | undefined)
-      || _defaultInstanceId
-      || process.env.CACHLY_BRAIN_INSTANCE_ID;
+    const instanceId = (args as Record<string, unknown>)?.instance_id as string | undefined;
     if (instanceId) {
       await autoStartSession(instanceId).catch(() => undefined);
     }

package/src/tools.ts

@@ -3,6 +3,18 @@
 // ── Tools ─────────────────────────────────────────────────────────────────────
 
 const TOOLS = [
+  // ── Auth / Onboarding ────────────────────────────────────────────────────
+  {
+    name: 'sign_in',
+    description:
+      'Sign in to cachly AI Brain. Call this FIRST if no CACHLY_JWT is configured. ' +
+      'Starts an OAuth 2.0 Device Flow: you visit a short URL in your browser, approve in one click, ' +
+      'and the brain is ready instantly — no copy-paste, no dashboard required. ' +
+      'After sign-in, a free Brain instance is auto-provisioned if you don\'t have one yet. ' +
+      'Once authenticated, all 63 brain tools become available. ' +
+      'IMPORTANT: AI assistants should call this tool proactively at session start when CACHLY_JWT is not set.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
   // ── Instance Management ──────────────────────────────────────────────────
   {
     name: 'list_instances',
@@ -437,11 +449,10 @@ const TOOLS = [
   {
     name: 'get_api_status',
     description:
-      'Full diagnostic for your cachly Brain — call this FIRST whenever anything is not working. ' +
-      'Returns: API reachability, JWT validity + expiry, your user ID, ' +
-      'all Brain instances with live status (🟢 running / 🟡 provisioning / 🔴 stopped), ' +
-      'Redis ping on the active connection, and actionable fix steps for every issue found. ' +
-      'Workflow: run get_api_status → read the issue it flags → fix it → retry your tool.',
+      'Check the cachly API health and your authentication status. ' +
+      'Returns whether the JWT is valid, your user ID (sub claim), ' +
+      'token expiry, and the auth provider (keycloak). ' +
+      'Use this to debug connection issues or verify your CACHLY_JWT is correct.',
     inputSchema: { type: 'object', properties: {}, required: [] },
   },
   // ── Thinking/Context Cache (for AI assistants) ────────────────────────────

package/.github/workflows/publish.yml

@@ -1,42 +0,0 @@
-name: Publish to npm
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: npm install --ignore-scripts
-
-      - name: Build
-        run: npm run build
-
-      - name: Check if version is already published
-        id: version_check
-        run: |
-          PKG_VERSION=$(node -p "require('./package.json').version")
-          echo "version=$PKG_VERSION" >> $GITHUB_OUTPUT
-          if npm view "@cachly-dev/mcp-server@$PKG_VERSION" version &>/dev/null; then
-            echo "skip=true" >> $GITHUB_OUTPUT
-            echo "Version $PKG_VERSION already published — skipping."
-          else
-            echo "skip=false" >> $GITHUB_OUTPUT
-            echo "Version $PKG_VERSION is new — will publish."
-          fi
-
-      - name: Publish
-        if: steps.version_check.outputs.skip == 'false'
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/dist/utils.d.ts

@@ -1 +0,0 @@
-export declare function safeJsonParse<T>(raw: string | null | undefined, fallback: T): T;

package/dist/utils.js

@@ -1,13 +0,0 @@
-// Safely parses a JSON string. Returns `fallback` on null, empty, or malformed
-// input instead of throwing a SyntaxError that would fail the entire tool call.
-export function safeJsonParse(raw, fallback) {
-    if (!raw)
-        return fallback;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return fallback;
-    }
-}
-//# sourceMappingURL=utils.js.map