llms-ink 0.6.0 → 0.7.0

package/README.md

@@ -301,3 +301,32 @@ Requests are limited to 128 KiB after JSON encoding and responses to 16 KiB. The
 For JSON, serialize it yourself and pass the resulting string to `inspect()`. The SDK sends `format: "text"`, so its digest covers those exact bytes; it does not promise cross-language JSON canonicalization. See [pilot limits and privacy](https://llms.ink/inspect/).
 
 JavaScript uses a 65-second total request deadline; pass `{ signal }` to cancel earlier.
+
+## Claude conversation guard (experimental, Node / POSIX)
+
+`llms-ink/guard/claude` binds one Claude Agent SDK conversation to one authenticated local Guard session. Install the optional peer separately:
+
+```sh
+npm install llms-ink@0.7.0 @anthropic-ai/claude-agent-sdk@0.3.319
+```
+
+First [start the Python 0.10.0 local service](https://llms.ink/guard/service/) with a reviewed gateway configuration and existing Claude authentication. Then try the bundled terminal host:
+
+```sh
+node node_modules/llms-ink/examples/guard-claude.mjs \
+  --owner-file /private/guard/owner.json \
+  --python /absolute/path/to/.venv/bin/python \
+  --cwd /absolute/path/to/workspace
+```
+
+It requires an interactive terminal and displays the complete review for each permitted action. Type `approve` to send that call once; Enter declines. `/exit`, terminal close and handled termination revoke the session. The example escapes terminal control characters rather than interpreting them. `--model` and `--claude-executable` are optional.
+
+For application hosts, import `createGuardedClaude` and pass absolute `ownerFile`, `python` and `cwd` paths plus `review: async ({message, signal}) => boolean`. Render `message` completely as plain text; abort the UI on `signal`. Only a fresh literal `true` accepts. The returned object exposes the non-secret `sessionId`, sequential `run(prompt, onMessage?)` and `close()`. Always await close in a finally block. Create a new instance for each independent conversation; there is no resume/fork interface. The owner file never enters the SDK's MCP configuration.
+
+The default fixed session TTL is 900 seconds (`ttl`, maximum 86400), with no renewal. Each turn has a 120000 ms deadline (`turnTimeoutMs`, maximum 600000). Reviews stop after 55 seconds. The adapter configures no native tools, other MCP connections, plugins or local hooks. SDK `maxTurns` defaults to 12 and `maxBudgetUsd` to 1; SDK cost estimates are not a hard billing limit. Optional `model` and `claudeExecutable` select the host model/binary.
+
+`GuardHostError` reports incomplete cleanup with `sessionId` and `credentialDirectory`. If revocation cannot be confirmed, the private credential file remains for recovery; retry `close()` or revoke through the owner CLI. A host process killed without cleanup can leave authority until the service's TTL. The owner process, SDK and approval UI are trusted; private files do not isolate malicious same-user code. This is not a process sandbox, exposure ledger or automatic desktop plugin. Compaction does not establish clean context.
+
+Allowed results go to Claude using the host's authentication, after local inspection. The adapter does not call hosted Inspect. Other SDK entry points do not import the optional Claude dependency. [Guide](https://llms.ink/guard/claude/) · [Runnable example](examples/guard-claude.mjs).
+
+Lifecycle tests use real service sockets and subprocess effects with a simulated SDK loop. Run them with `LLMS_INK_GUARD_TEST_PYTHON=/absolute/python npm run test:guard` after installing Python `llms-ink==0.10.0`. The separately opted-in `test:guard:live` requires `LLMS_INK_CLAUDE_LIVE=1`, existing Claude authentication and the optional local model when `LLMS_INK_HOST_REAL_MODEL=1`. Scripted fixture approvals are interoperability evidence, not independent human review or proof of attack prevention.

package/dist/guard-claude.d.ts

@@ -0,0 +1,44 @@
+import { type SDKMessage, type SDKResultMessage } from '@anthropic-ai/claude-agent-sdk';
+export interface GuardReview {
+    /** Complete guard-authored review, including command, arguments and policy/definition hashes. Render as plain text. */
+    message: string;
+    /** Stop displaying the form when this signal aborts. Never reuse a decision. */
+    signal: AbortSignal;
+}
+export interface GuardedClaudeOptions {
+    /** Private owner credential. This path is used by the control process, never sent to Claude. */
+    ownerFile: string;
+    /** Absolute Python interpreter with llms-ink[guard] 0.10.0 installed. */
+    python: string;
+    /** Called for each fresh approval. Only literal true accepts. Errors, cancellation and timeout decline. */
+    review: (request: GuardReview) => Promise<boolean>;
+    cwd: string;
+    model?: string;
+    /** Optional absolute path to a supported Claude Code executable. */
+    claudeExecutable?: string;
+    /** Fixed lifetime, 1–86400 seconds. Default 900. No automatic renewal. */
+    ttl?: number;
+    /** Per-turn deadline, including reviews. Default 120000, maximum 600000. */
+    turnTimeoutMs?: number;
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+}
+export interface GuardedClaudeConversation {
+    /** Non-secret guard session ID, distinct from Claude's conversation UUID. */
+    readonly sessionId: string;
+    /** Run one turn. Calls must be sequential; callbacks receive host output, never owner credentials. */
+    run(prompt: string, onMessage?: (message: SDKMessage) => void | Promise<void>): Promise<SDKResultMessage>;
+    /** Revoke authority and close the host. Idempotent after confirmed cleanup; retry on cleanup errors. */
+    close(): Promise<void>;
+}
+export declare class GuardHostError extends Error {
+    readonly sessionId: string | undefined;
+    readonly credentialDirectory: string | undefined;
+    constructor(message: string, sessionId?: string, credentialDirectory?: string);
+}
+/**
+ * Create one non-resumable, tool-scoped conversation. New conversations require new instances.
+ * The owner process, SDK and review callback are trusted. This is not an OS sandbox.
+ * A process crash leaves authority bounded by the fixed TTL; there is no crash-proof lease or exposure ledger.
+ */
+export declare function createGuardedClaude(options: GuardedClaudeOptions): Promise<GuardedClaudeConversation>;

package/dist/guard-claude.js

@@ -0,0 +1,280 @@
+/** Node/POSIX host integration for explicitly scoped Claude Agent SDK conversations. */
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, chmod, lstat, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+export class GuardHostError extends Error {
+    sessionId;
+    credentialDirectory;
+    constructor(message, sessionId, credentialDirectory) {
+        super(message);
+        this.name = 'GuardHostError';
+        this.sessionId = sessionId;
+        this.credentialDirectory = credentialDirectory;
+    }
+}
+const idPattern = /^[a-f0-9]{32}$/;
+const reviewSchema = { type: 'object', properties: { approve: { type: 'boolean', title: 'Approve this call once', default: false } }, required: ['approve'] };
+function sameShape(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object' || Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const ak = Object.keys(a), bk = Object.keys(b);
+    return ak.length === bk.length && ak.every(k => Object.hasOwn(b, k) && sameShape(a[k], b[k]));
+}
+function control(python, args) {
+    return new Promise((resolve, reject) => execFile(python, ['-m', 'llms_ink.guard', ...args], { timeout: 30000, maxBuffer: 16384, encoding: 'utf8' }, (error, stdout) => {
+        if (error) {
+            reject(new GuardHostError('Guard control did not complete.'));
+            return;
+        }
+        try {
+            const value = JSON.parse(stdout);
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                throw new Error();
+            resolve(value);
+        }
+        catch {
+            reject(new GuardHostError('Guard control returned an invalid response.'));
+        }
+    }));
+}
+class Input {
+    pending;
+    wake;
+    ended = false;
+    send(prompt, session) {
+        if (this.ended || this.pending)
+            throw new GuardHostError('Conversation input is unavailable.');
+        this.pending = { type: 'user', session_id: session, message: { role: 'user', content: prompt }, parent_tool_use_id: null };
+        this.wake?.();
+    }
+    close() { this.ended = true; this.wake?.(); }
+    async *[Symbol.asyncIterator]() {
+        while (!this.ended) {
+            if (!this.pending)
+                await new Promise(resolve => { this.wake = resolve; });
+            this.wake = undefined;
+            if (this.ended)
+                return;
+            const next = this.pending;
+            this.pending = undefined;
+            if (next)
+                yield next;
+        }
+    }
+}
+/**
+ * Create one non-resumable, tool-scoped conversation. New conversations require new instances.
+ * The owner process, SDK and review callback are trusted. This is not an OS sandbox.
+ * A process crash leaves authority bounded by the fixed TTL; there is no crash-proof lease or exposure ledger.
+ */
+export async function createGuardedClaude(options) {
+    options = { ...options };
+    if (process.platform === 'win32')
+        throw new GuardHostError('Guard sessions require macOS or Linux.');
+    const { python, ownerFile, review, cwd, claudeExecutable } = options;
+    const ttl = options.ttl ?? 900, timeout = options.turnTimeoutMs ?? 120000;
+    if (!isAbsolute(python) || !isAbsolute(ownerFile) || !isAbsolute(cwd) || (claudeExecutable && !isAbsolute(claudeExecutable)) || typeof review !== 'function'
+        || !Number.isInteger(ttl) || ttl < 1 || ttl > 86400 || !Number.isInteger(timeout) || timeout < 1 || timeout > 600000
+        || (options.maxTurns !== undefined && (!Number.isInteger(options.maxTurns) || options.maxTurns < 1 || options.maxTurns > 100))
+        || (options.maxBudgetUsd !== undefined && (!Number.isFinite(options.maxBudgetUsd) || options.maxBudgetUsd <= 0)))
+        throw new GuardHostError('Absolute paths, a review callback and bounded lifetimes are required.');
+    const directory = await mkdtemp(join(tmpdir(), 'ink-host-'));
+    await chmod(directory, 0o700);
+    const file = join(directory, 'session.json');
+    let sessionId;
+    async function revoke() {
+        if (!sessionId)
+            return;
+        try {
+            const result = await control(python, ['session-revoke', '--owner-file', ownerFile, '--session-id', sessionId]);
+            if (result.ok !== true)
+                throw new Error();
+        }
+        catch {
+            try {
+                const state = await control(python, ['service-status', '--owner-file', ownerFile]);
+                if (state.ok !== true || !Array.isArray(state.sessions) || state.sessions.some(s => !s || typeof s !== 'object' || typeof s.sessionId !== 'string' || (s.sessionId === sessionId && s.active !== false)))
+                    throw new Error();
+            }
+            catch {
+                throw new GuardHostError('Session revocation could not be confirmed. Keep the credential directory and retry close or revoke it with the owner CLI.', sessionId, directory);
+            }
+        }
+    }
+    try {
+        const result = await control(python, ['session-create', '--owner-file', ownerFile, '--output', file, '--ttl', String(ttl)]);
+        if (typeof result.sessionId !== 'string' || !idPattern.test(result.sessionId))
+            throw new Error();
+        sessionId = result.sessionId;
+        const info = await lstat(file);
+        if (!info.isFile() || info.isSymbolicLink() || (info.mode & 0o077) !== 0 || info.uid !== process.getuid?.())
+            throw new Error();
+    }
+    catch {
+        // A terminated CLI may have written a capability before printing its ID.
+        if (!sessionId) {
+            try {
+                const saved = JSON.parse(await readFile(file, 'utf8'));
+                if (typeof saved.sessionId === 'string' && idPattern.test(saved.sessionId))
+                    sessionId = saved.sessionId;
+            }
+            catch { /* no recoverable credential */ }
+        }
+        await revoke();
+        await rm(directory, { recursive: true, force: true });
+        throw new GuardHostError('Could not create a guarded conversation.');
+    }
+    const guardId = sessionId;
+    const hostId = randomUUID(), input = new Input(), abort = new AbortController();
+    let closing = false, closed = false, busy = false, initialized = false, closeWork;
+    let host;
+    let expiresTimer;
+    async function whileOpen(work) {
+        if (abort.signal.aborted)
+            throw new GuardHostError('Conversation closed.');
+        let cancel;
+        try {
+            return await Promise.race([work, new Promise((_, reject) => {
+                    cancel = () => reject(new GuardHostError('Conversation closed.'));
+                    abort.signal.addEventListener('abort', cancel, { once: true });
+                })]);
+        }
+        finally {
+            if (cancel)
+                abort.signal.removeEventListener('abort', cancel);
+        }
+    }
+    async function close() {
+        if (closed)
+            return;
+        if (closeWork)
+            return closeWork;
+        closing = true;
+        input.close();
+        abort.abort();
+        clearTimeout(expiresTimer);
+        closeWork = (async () => {
+            let failure;
+            try {
+                await revoke();
+            }
+            catch (error) {
+                failure = error;
+            }
+            try {
+                host?.close();
+            }
+            catch {
+                failure ??= new GuardHostError('Claude host cleanup did not complete. Retry close.', guardId, directory);
+            }
+            if (failure)
+                throw failure;
+            await rm(directory, { recursive: true, force: true });
+            closed = true;
+        })();
+        try {
+            await closeWork;
+        }
+        finally {
+            closeWork = undefined;
+        }
+    }
+    async function elicit(request, context) {
+        if (closing || !busy || context.signal.aborted || request.serverName !== 'guarded' || (request.mode ?? 'form') !== 'form'
+            || typeof request.message !== 'string' || Buffer.byteLength(request.message) > 8192 || !sameShape(request.requestedSchema, reviewSchema))
+            return { action: 'decline' };
+        const lifetime = new AbortController();
+        const cancel = () => lifetime.abort();
+        abort.signal.addEventListener('abort', cancel, { once: true });
+        context.signal.addEventListener('abort', cancel, { once: true });
+        const timer = setTimeout(cancel, 55000);
+        try {
+            const answer = await Promise.race([
+                Promise.resolve().then(() => review(Object.freeze({ message: request.message, signal: lifetime.signal }))),
+                new Promise(resolve => lifetime.signal.addEventListener('abort', () => resolve(false), { once: true })),
+            ]);
+            return answer === true && !lifetime.signal.aborted && !closing ? { action: 'accept', content: { approve: true } } : { action: 'decline' };
+        }
+        catch {
+            return { action: 'decline' };
+        }
+        finally {
+            clearTimeout(timer);
+            cancel();
+            abort.signal.removeEventListener('abort', cancel);
+            context.signal.removeEventListener('abort', cancel);
+        }
+    }
+    try {
+        const sdkOptions = {
+            abortController: abort, sessionId: hostId, persistSession: false, settingSources: [], plugins: [], tools: [],
+            strictMcpConfig: true, mcpServers: { guarded: { command: python, args: ['-m', 'llms_ink.guard', 'connect', '--session-file', file] } },
+            canUseTool: async (name) => name.startsWith('mcp__guarded__') && initialized && busy && !closing
+                ? { behavior: 'allow' } : { behavior: 'deny', message: 'Only guarded tools are available.' },
+            settings: { disableAllHooks: true, disableClaudeAiConnectors: true, disabledMcpServers: ['claude-in-chrome'] },
+            extraArgs: { 'disable-slash-commands': null, 'no-chrome': null },
+            cwd, model: options.model, pathToClaudeCodeExecutable: claudeExecutable,
+            maxTurns: options.maxTurns ?? 12, maxBudgetUsd: options.maxBudgetUsd ?? 1, onElicitation: elicit,
+        };
+        host = query({ prompt: input, options: sdkOptions });
+        // Revocation on idle expiry does not wait for another prompt. Failures remain
+        // observable through close(); the service independently enforces its TTL.
+        expiresTimer = setTimeout(() => { void close().catch(() => { }); }, ttl * 1000);
+        expiresTimer.unref();
+    }
+    catch {
+        await close();
+        throw new GuardHostError('Claude host startup failed.');
+    }
+    return Object.freeze({ sessionId: guardId,
+        async run(prompt, onMessage) {
+            if (closing || busy)
+                throw new GuardHostError('The conversation is closed or another turn is running.');
+            if (typeof prompt !== 'string' || !prompt.trim() || prompt.trimStart().startsWith('/') || Buffer.byteLength(prompt) > 131072)
+                throw new GuardHostError('Provide a text prompt up to 128 KiB; host commands require a new conversation.');
+            busy = true;
+            const timer = setTimeout(() => { void close().catch(() => { }); }, timeout);
+            try {
+                const state = await control(python, ['service-status', '--owner-file', ownerFile]);
+                if (closing || state.ok !== true || !Array.isArray(state.sessions) || !state.sessions.some(s => s?.sessionId === guardId && s.active === true))
+                    throw new Error();
+                input.send(prompt, hostId);
+                while (true) {
+                    const next = await whileOpen(host.next());
+                    if (next.done || closing)
+                        throw new Error();
+                    const message = next.value;
+                    if ('session_id' in message && message.session_id !== hostId)
+                        throw new Error();
+                    if (message.type === 'system' && message.subtype === 'init') {
+                        if (message.mcp_servers.length !== 1 || message.mcp_servers[0].name !== 'guarded' || message.mcp_servers[0].status !== 'connected'
+                            || !message.tools.length || message.tools.some(t => !t.startsWith('mcp__guarded__')))
+                            throw new Error();
+                        initialized = true;
+                    }
+                    if (!initialized && message.type !== 'system')
+                        throw new Error();
+                    if (onMessage)
+                        await whileOpen(Promise.resolve().then(() => onMessage(message)));
+                    if (message.type === 'result') {
+                        if (message.is_error)
+                            throw new Error();
+                        return message;
+                    }
+                }
+            }
+            catch {
+                await close();
+                throw new GuardHostError('Guarded turn did not complete; the conversation was closed.');
+            }
+            finally {
+                clearTimeout(timer);
+                busy = false;
+            }
+        }, close, });
+}

package/dist/index.d.ts

@@ -15,7 +15,7 @@
  */
 import { type InspectionReceipt } from './inspect.ts';
 export type { InspectionReceipt } from './inspect.ts';
-export declare const VERSION = "0.6.0";
+export declare const VERSION = "0.7.0";
 export declare const DEFAULT_BASE_URL = "https://llms.ink";
 /** `llms` for the index (llms.txt), `full` for llms-full.txt. */
 export type Mode = 'llms' | 'full';

package/dist/index.js

@@ -15,7 +15,7 @@
  */
 import { prepareInspection, inspectionJson, inspectionReceipt } from "./inspect.js";
 import { env } from "./env.js";
-export const VERSION = '0.6.0';
+export const VERSION = '0.7.0';
 export const DEFAULT_BASE_URL = 'https://llms.ink';
 /**
  * An API error, or llms.ink couldn't be reached (then `status` and `code` are undefined).

package/examples/guard-claude.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// Run from an installed llms-ink package with the optional Claude SDK peer installed.
+import {parseArgs} from 'node:util';
+import {createInterface} from 'node:readline/promises';
+import {createGuardedClaude} from '../dist/guard-claude.js';
+const {values}=parseArgs({options:{'owner-file':{type:'string'},python:{type:'string'},cwd:{type:'string'},model:{type:'string'},'claude-executable':{type:'string'}}});
+if(!process.stdin.isTTY || !process.stdout.isTTY) throw Error('This example requires an interactive terminal for each approval.');
+if(!values['owner-file'] || !values.python || !values.cwd) throw Error('Pass --owner-file, --python and --cwd with absolute paths.');
+const terminal=createInterface({input:process.stdin,output:process.stdout});
+// Preserve complete text while making terminal controls and bidi controls visible.
+const plain=text=>text.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g,c=>'\\u'+c.charCodeAt(0).toString(16).padStart(4,'0'));
+let conversation,stopping=false;
+const stop=()=>{stopping=true;terminal.close();void conversation?.close().catch(()=>{});};
+terminal.on('SIGINT',stop);terminal.on('close',()=>{stopping=true;void conversation?.close().catch(()=>{});});process.on('SIGTERM',stop);
+try{
+ conversation=await createGuardedClaude({ownerFile:values['owner-file'],python:values.python,cwd:values.cwd,model:values.model,claudeExecutable:values['claude-executable'],
+  review:async({message,signal})=>{
+   process.stdout.write('\n'+plain(message)+'\n\n');
+   try{return(await terminal.question('Type approve to send this call once; Enter declines: ',{signal}))==='approve';}catch{return false;}
+  }});
+ console.log('Guarded conversation. /exit closes and revokes this session.');
+ while(!stopping){
+  const prompt=await terminal.question('\nYou: ');
+  if(prompt.trim()==='/exit')break;
+  if(!prompt.trim())continue;
+  await conversation.run(prompt,message=>{
+   if(message.type==='assistant')for(const part of message.message.content)if(part.type==='text')process.stdout.write(plain(part.text)+'\n');
+  });
+ }
+}catch(error){if(!stopping){console.error(error.message);process.exitCode=1;}}
+finally{
+ terminal.close();process.removeListener('SIGTERM',stop);
+ try{await conversation?.close();}catch(error){console.error(error.message);if(error.sessionId)console.error('Session ID:',error.sessionId);if(error.credentialDirectory)console.error('Credential directory:',error.credentialDirectory);process.exitCode=1;}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llms-ink",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Turn any link — site, docs section, page, GitHub repo, PDF or video — into llms.txt and llms-full.txt. Typed client for llms.ink, plus a Vite plugin, an Astro integration and middleware that serve the files from your site, and Vercel AI SDK tools. No dependencies.",
   "type": "module",
   "exports": {
@@ -23,24 +23,55 @@
     "./ai": {
       "types": "./dist/ai.d.ts",
       "default": "./dist/ai.js"
+    },
+    "./guard/claude": {
+      "types": "./dist/guard-claude.d.ts",
+      "default": "./dist/guard-claude.js"
     }
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist",
+    "examples/guard-claude.mjs"
+  ],
   "sideEffects": false,
-  "repository": { "type": "git", "url": "git+https://github.com/lukax/llms-ink-js.git" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lukax/llms-ink-js.git"
+  },
   "bugs": "https://github.com/lukax/llms-ink-js/issues",
-  "engines": { "node": ">=18" },
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
     "prepublishOnly": "npm run build && npm test",
     "test": "npm run build && tsc -p test/tsconfig.json && node --test test/client.test.mjs test/plugins.test.mjs test/middleware.test.mjs test/traffic.test.mjs test/inspect.test.mjs test/ai.test.mjs",
     "test:live": "npm run build && node --test test/live.test.mjs",
     "test:bun": "npm run build && bun test ./test/client.test.mjs ./test/plugins.test.mjs ./test/middleware.test.mjs ./test/traffic.test.mjs ./test/inspect.test.mjs ./test/ai.test.mjs",
-    "test:bun:live": "npm run build && bun test --timeout 300000 ./test/live.test.mjs"
+    "test:bun:live": "npm run build && bun test --timeout 300000 ./test/live.test.mjs",
+    "test:guard": "node --experimental-test-module-mocks --test test/guard-claude.test.mjs",
+    "test:guard:live": "node --test test/guard-claude-live.test.mjs"
   },
-  "keywords": ["llms.txt", "llms-full.txt", "llm", "ai", "markdown", "docs", "context", "rag", "sdk", "llms-ink", "vite-plugin", "astro-integration", "middleware", "ai-sdk", "vercel-ai-sdk", "tools"],
+  "keywords": [
+    "llms.txt",
+    "llms-full.txt",
+    "llm",
+    "ai",
+    "markdown",
+    "docs",
+    "context",
+    "rag",
+    "sdk",
+    "llms-ink",
+    "vite-plugin",
+    "astro-integration",
+    "middleware",
+    "ai-sdk",
+    "vercel-ai-sdk",
+    "tools"
+  ],
   "homepage": "https://llms.ink/docs/",
   "author": "Lucas Espindola (https://lucasespindola.com)",
   "license": "MIT",
@@ -48,15 +79,28 @@
     "ai": ">=5",
     "astro": ">=4",
     "vite": ">=5",
-    "zod": "^3.25.76 || ^4.1.8"
+    "zod": "^3.25.76 || ^4.1.8",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.319"
   },
   "peerDependenciesMeta": {
-    "ai": { "optional": true },
-    "astro": { "optional": true },
-    "vite": { "optional": true },
-    "zod": { "optional": true }
+    "ai": {
+      "optional": true
+    },
+    "astro": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    },
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.319",
     "@types/node": "^22.20.5",
     "ai": "^7.0.164",
     "astro": "^7.4.7",