llms-ink 0.5.0 → 0.7.0

package/README.md

@@ -3,7 +3,7 @@
 Turn any link — site, docs section, page, GitHub repo, PDF or video — into llms.txt and llms-full.txt. A typed
 client for the [llms.ink](https://llms.ink) API with no dependencies. Runs on Node 18+, Bun, Deno, Cloudflare
 Workers and browsers. Also a [Vite plugin, an Astro integration and middleware](#serve-llmstxt-from-your-site) that
-serve llms.txt from your own site.
+serve llms.txt from your own site, and [tools for the Vercel AI SDK](#vercel-ai-sdk-llms-inkai).
 
 ```sh
 npm install llms-ink        # or: bun add llms-ink
@@ -84,6 +84,13 @@ fetched) resolves relative links. Up to 5 MB; nothing is stored.
 const md = await ink.markdown(await readFile('dist/pricing/index.html', 'utf8'), { url: 'https://example.com/pricing/' });
 ```
 
+### `ink.report(url, { signal? })` → `Promise<ReportResult>`
+
+How AI crawlers and agents see a page (`GET /api/v0/report`): robots.txt per AI bot, firewall blocks, text without
+JavaScript, what survives Markdown conversion, hidden instructions and agent files. `{ url, site, checkedAt,
+summary: { pass, warn, fail, info }, sections: [{ id, title, checks: [{ id, status, title, detail, evidence?, fix? }] }] }`;
+a `fix` has `kind`, `summary` and, when possible, a `patch: { file, content }`.
+
 ### `ink.stream(url, { mode?, fresh?, signal? })` → `AsyncGenerator<StreamEvent>`
 
 The same build as `llms()`, as it happens:
@@ -178,6 +185,65 @@ sent are lost when the process stops: call `await llms.flush()` on shutdown. Rea
 `classifyAgent(userAgent)` and `trafficCounter({ key, site })` (`record(request, ctx?)`, `flush()`) are exported for
 other servers.
 
+## Vercel AI SDK: `llms-ink/ai`
+
+```sh
+npm install llms-ink ai zod
+```
+
+```ts
+import { generateText, stepCountIs } from 'ai';
+import { llmsInkTools } from 'llms-ink/ai';
+
+const { text } = await generateText({
+  model: 'openai/gpt-5',
+  tools: llmsInkTools(),
+  stopWhen: stepCountIs(5),
+  prompt: 'How do I paginate with the Stripe API? Read docs.stripe.com first.',
+});
+```
+
+`llmsInkTools({ client?, maxChars?, include? })` returns AI SDK tools (`tool()` with zod `inputSchema`, AI SDK 5 and
+later; tested with 7) for `generateText`, `streamText` and agents:
+
+| Tool | Input | Returns |
+|---|---|---|
+| `llmsTxt` | `url`, `fresh?` | `{ url, title, kind, source, tokens, pages, cached, text, truncated }`: the llms.txt index |
+| `llmsFullTxt` | `url`, `fresh?` | The same with llms-full.txt: up to 20 pages inlined, or a video's transcript |
+| `checkLlmsTxt` | `url`, or `text` with `base?`, `links?` | `{ url, site, found, summary, text, truncated }`: each issue with its line |
+| `agentView` | `url` | `{ url, site, summary, text, truncated }`: every check of `ink.report()` with its fix |
+
+- `client`: an `LlmsInk`, or its options (`{ key, baseUrl, fetch }`; `key` defaults to `LLMS_INK_KEY`).
+- `maxChars`: longest `text` a tool returns (default 40000). Longer text is cut at a line break and ends with
+  `[Truncated: showing N of M characters. …]`, with `truncated: true`.
+- `include`: only these tools, e.g. `llmsInkTools({ include: ['llmsTxt', 'checkLlmsTxt'] })`. The return type
+  narrows to them.
+
+API errors don't throw: the tool returns `{ error, code?, retryAfter? }` for the model to read, e.g.
+`{ error: 'llms.ink rate limit: wait 42 seconds, then try again.', code: 'rate_limited', retryAfter: 42 }`.
+An invalid API key (`InvalidKeyError`) and aborts (`abortSignal`) throw.
+
+### Or connect the MCP server
+
+The AI SDK also takes tools from an MCP client. https://llms.ink/mcp gives the same tools plus `video_frame`,
+`create_clip_link` and `generate_draft`, with snake_case names (`llms_txt`, `llms_full_txt`…) and text results:
+
+```ts
+import { createMCPClient } from '@ai-sdk/mcp'; // AI SDK 5: @ai-sdk/mcp@ai-v5, as experimental_createMCPClient
+
+const mcp = await createMCPClient({
+  transport: { type: 'http', url: 'https://llms.ink/mcp', headers: { authorization: `Bearer ${process.env.LLMS_INK_KEY}` } },
+});
+try {
+  const { text } = await generateText({ model: 'openai/gpt-5', tools: await mcp.tools(), stopWhen: stepCountIs(5), prompt });
+} finally {
+  await mcp.close();
+}
+```
+
+Leave out `headers` to use it anonymously. `llms-ink/ai` needs no extra package or connection and returns
+structured results cut to `maxChars`.
+
 ## Errors
 
 Every failure is an `LlmsInkError` with `status`, `code`, `title`, `detail`, `errors` (per-parameter issues of
@@ -235,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/ai.d.ts

@@ -0,0 +1,111 @@
+/**
+ * llms.ink as Vercel AI SDK tools (`ai` 5 and later, with `zod`):
+ *
+ * ```ts
+ * import { generateText, stepCountIs } from 'ai';
+ * import { llmsInkTools } from 'llms-ink/ai';
+ *
+ * const { text } = await generateText({
+ *   model: 'openai/gpt-5',
+ *   tools: llmsInkTools(),
+ *   stopWhen: stepCountIs(5),
+ *   prompt: 'How do I paginate with the Stripe API? Read docs.stripe.com first.',
+ * });
+ * ```
+ *
+ * Results are cut to `maxChars` with a note saying so. API errors come back as `{ error, code, retryAfter? }`
+ * for the model to read; an invalid API key throws.
+ *
+ * @module
+ */
+import { type Tool } from 'ai';
+import { LlmsInk, type Kind, type LlmsInkOptions, type Source } from './index.ts';
+/** The tools {@link llmsInkTools} can return, by name. */
+export type LlmsInkToolName = 'llmsTxt' | 'llmsFullTxt' | 'checkLlmsTxt' | 'agentView';
+/** Options for {@link llmsInkTools}. */
+export interface LlmsInkToolsOptions<K extends LlmsInkToolName = LlmsInkToolName> {
+    /** A client, or options for a new one (`key` defaults to `LLMS_INK_KEY`). */
+    client?: LlmsInk | LlmsInkOptions;
+    /** Longest text a tool returns, in characters; longer text is cut and says so. Default 40000. */
+    maxChars?: number;
+    /** Only these tools. Default: all four. */
+    include?: readonly K[];
+}
+/** Input of `llmsTxt` and `llmsFullTxt`. */
+export interface LinkInput {
+    url: string;
+    fresh?: boolean;
+}
+/** Input of `checkLlmsTxt`: `url`, or `text` with optional `base` and `links`. */
+export interface CheckInput {
+    url?: string;
+    text?: string;
+    base?: string;
+    links?: boolean;
+}
+/** Input of `agentView`. */
+export interface AgentViewInput {
+    url: string;
+}
+/** What a tool returns instead of throwing when llms.ink answers with an error or can't be reached. */
+export interface LlmsInkToolError {
+    /** A sentence for the model, e.g. "llms.ink rate limit: wait 42 seconds, then try again." */
+    error: string;
+    /** The API's error code (`rate_limited`, `invalid_url`…); absent when llms.ink couldn't be reached. */
+    code?: string;
+    /** Seconds to wait before trying again, when llms.ink said so. */
+    retryAfter?: number;
+}
+/** `llmsTxt` / `llmsFullTxt` result. */
+export interface LlmsTextOutput {
+    url: string;
+    title: string;
+    kind: Kind;
+    source: Source;
+    /** Approximate tokens of the whole file, before any cut. */
+    tokens: number;
+    /** Links in llms.txt, or pages inlined in llms-full.txt. */
+    pages: number;
+    cached: boolean;
+    text: string;
+    /** `text` was cut to `maxChars`; it ends with a note saying so. */
+    truncated: boolean;
+}
+/** `checkLlmsTxt` result: `text` is a short report with each issue and its line. */
+export interface CheckOutput {
+    url: string | null;
+    site: string | null;
+    found: boolean;
+    summary: {
+        errors: number;
+        warnings: number;
+    };
+    text: string;
+    truncated: boolean;
+}
+/** `agentView` result: `text` lists every check with its status, evidence and fix. */
+export interface AgentViewOutput {
+    url: string;
+    site: string;
+    summary: {
+        pass: number;
+        warn: number;
+        fail: number;
+        info: number;
+    };
+    text: string;
+    truncated: boolean;
+}
+/** Every tool, by name. */
+export interface LlmsInkTools {
+    llmsTxt: Tool<LinkInput, LlmsTextOutput | LlmsInkToolError>;
+    llmsFullTxt: Tool<LinkInput, LlmsTextOutput | LlmsInkToolError>;
+    checkLlmsTxt: Tool<CheckInput, CheckOutput | LlmsInkToolError>;
+    agentView: Tool<AgentViewInput, AgentViewOutput | LlmsInkToolError>;
+}
+export declare const DEFAULT_MAX_CHARS = 40000;
+/**
+ * llms.ink tools for `generateText` / `streamText` / agents of the Vercel AI SDK: `llmsTxt`, `llmsFullTxt`,
+ * `checkLlmsTxt` and `agentView`, or the ones in `include`.
+ */
+export declare function llmsInkTools<K extends LlmsInkToolName = LlmsInkToolName>(options?: LlmsInkToolsOptions<K>): Pick<LlmsInkTools, K>;

package/dist/ai.js

@@ -0,0 +1,170 @@
+/**
+ * llms.ink as Vercel AI SDK tools (`ai` 5 and later, with `zod`):
+ *
+ * ```ts
+ * import { generateText, stepCountIs } from 'ai';
+ * import { llmsInkTools } from 'llms-ink/ai';
+ *
+ * const { text } = await generateText({
+ *   model: 'openai/gpt-5',
+ *   tools: llmsInkTools(),
+ *   stopWhen: stepCountIs(5),
+ *   prompt: 'How do I paginate with the Stripe API? Read docs.stripe.com first.',
+ * });
+ * ```
+ *
+ * Results are cut to `maxChars` with a note saying so. API errors come back as `{ error, code, retryAfter? }`
+ * for the model to read; an invalid API key throws.
+ *
+ * @module
+ */
+import { tool } from 'ai';
+import { z } from 'zod';
+import { InvalidKeyError, LlmsInk, LlmsInkError, QuotaExceededError, RateLimitedError, } from "./index.js";
+export const DEFAULT_MAX_CHARS = 40_000;
+const NAMES = ['llmsTxt', 'llmsFullTxt', 'checkLlmsTxt', 'agentView'];
+/**
+ * llms.ink tools for `generateText` / `streamText` / agents of the Vercel AI SDK: `llmsTxt`, `llmsFullTxt`,
+ * `checkLlmsTxt` and `agentView`, or the ones in `include`.
+ */
+export function llmsInkTools(options = {}) {
+    const max = options.maxChars ?? DEFAULT_MAX_CHARS;
+    if (!Number.isInteger(max) || max < 1)
+        throw new TypeError(`maxChars must be a positive integer, not ${max}`);
+    const include = options.include ?? NAMES;
+    for (const name of include) {
+        if (!NAMES.includes(name))
+            throw new TypeError(`Unknown llms.ink tool ${JSON.stringify(name)}: use ${NAMES.join(', ')}.`);
+    }
+    const given = options.client;
+    const ink = given && typeof given.llms === 'function' ? given : new LlmsInk(given);
+    const llmsTool = (mode, description, hint) => tool({
+        description,
+        inputSchema: z.object({
+            url: z.string().describe('Any public http(s) link, e.g. "docs.stripe.com/payments", "github.com/honojs/hono", a PDF or a video URL. The scheme is optional.'),
+            fresh: z.boolean().optional().describe('Ignore the 24h cache and rebuild. Default false.'),
+        }),
+        execute: (input, { abortSignal }) => attempt(async () => {
+            const r = await ink.llms(input.url, { mode, fresh: input.fresh, signal: abortSignal });
+            return { url: r.url, title: r.title, kind: r.kind, source: r.source, tokens: r.tokens, pages: r.pages, cached: r.cached, ...cut(r.text, max, hint) };
+        }),
+    });
+    const all = {
+        llmsTxt: llmsTool('llms', 'Get an llms.txt index for any link (site, docs section, page, GitHub repo, PDF or video): title, one-line summary, and sections of the most useful links with short descriptions. ' +
+            'Returns the site’s own llms.txt when it has one. Cached 24h.', 'Open only the linked pages you need.'),
+        llmsFullTxt: llmsTool('full', 'Get llms-full.txt for any link: the llms.txt index followed by the full Markdown of up to 20 pages it links to ' +
+            '(or the page/document itself; for a video, its description and timestamped transcript). Can be large — prefer llmsTxt when you only need to find pages. Cached 24h.', 'Call llmsTxt for the index, then llmsFullTxt on the one page or section you need.'),
+        checkLlmsTxt: tool({
+            description: 'Check an llms.txt against the format (H1 title, blockquote summary, H2 sections of `- [name](url): notes` links) and size. ' +
+                'Pass `url` to check the file a site publishes, including whether its first 25 links answer; or pass `text` to check a file you have (a draft, a local copy), ' +
+                'with `base` for where it lives and `links` to also test its links. Returns a short report with each issue and its line, and the sections with their link counts.',
+            inputSchema: z.object({
+                url: z.string().optional().describe('A site, a docs section, or the llms.txt itself, e.g. "llmstxt.org" or "docs.astro.build/llms.txt". Use url or text.'),
+                text: z.string().optional().describe('The llms.txt itself (up to 2 MB), instead of url.'),
+                base: z.string().optional().describe('With text: the site or llms.txt link it belongs to, e.g. "example.com". Resolves relative links.'),
+                links: z.boolean().optional().describe('With text: also check that its first 25 links answer (and llms-full.txt next to base). Default false.'),
+            }),
+            execute: (input, { abortSignal }) => attempt(async () => {
+                if ((input.text === undefined) === !input.url) {
+                    return { error: 'Pass url (a published llms.txt) or text (the file itself), not both.', code: 'invalid_request' };
+                }
+                const r = input.text === undefined
+                    ? await ink.check(input.url, { signal: abortSignal })
+                    : await ink.checkText(input.text, { base: input.base, links: input.links, signal: abortSignal });
+                return { url: r.url, site: r.site, found: r.found, summary: r.summary, ...cut(checkReport(r), max, 'Fix the issues shown, then check again.') };
+            }),
+        }),
+        agentView: tool({
+            description: 'Report how AI crawlers and agents see a page: robots.txt per AI bot (search, user fetches, training) and Content-Signal, firewall blocks found by fetching with bot User-Agents, text present without JavaScript, what survives Markdown conversion, ' +
+                'title/first paragraph/facts/noindex/canonical/sitemap, hidden instructions, and llms.txt, .md URLs, Accept: text/markdown, Link headers, ard.json. Each check is pass/warn/fail/info with a fix. ' +
+                'Use it to tell a site owner why assistants can’t read or cite a page and what to change.',
+            inputSchema: z.object({
+                url: z.string().describe('A site or any page on it, e.g. "example.com" or "docs.example.com/guide". The scheme is optional.'),
+            }),
+            execute: (input, { abortSignal }) => attempt(async () => {
+                const r = await ink.report(input.url, { signal: abortSignal });
+                return { url: r.url, site: r.site, summary: r.summary, ...cut(reportText(r), max, 'Fix the failures shown first.') };
+            }),
+        }),
+    };
+    const picked = {};
+    for (const name of include)
+        Object.assign(picked, { [name]: all[name] });
+    return picked;
+}
+/** `text` cut to `max` characters (at a line break when one is near), with a note saying what was left out. */
+function cut(text, max, hint) {
+    if (text.length <= max)
+        return { text, truncated: false };
+    let end = max;
+    const last = text.charCodeAt(end - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        end--; // don't split a surrogate pair
+    const newline = text.lastIndexOf('\n', end);
+    if (newline > end * 0.9)
+        end = newline;
+    return {
+        text: `${text.slice(0, end)}\n\n[Truncated: showing ${end} of ${text.length} characters. ${hint}]`,
+        truncated: true,
+    };
+}
+/** Runs a tool body; llms.ink errors become a {@link LlmsInkToolError}, an invalid key and anything else throw. */
+async function attempt(run) {
+    try {
+        return await run();
+    }
+    catch (err) {
+        if (!(err instanceof LlmsInkError) || err instanceof InvalidKeyError)
+            throw err;
+        const wait = err.retryAfter;
+        const out = { error: errorText(err, wait) };
+        if (err.code)
+            out.code = err.code;
+        if (wait !== undefined)
+            out.retryAfter = wait;
+        return out;
+    }
+}
+function errorText(err, wait) {
+    if (err instanceof RateLimitedError)
+        return `llms.ink rate limit: wait ${wait ?? 60} seconds, then try again.`;
+    if (err instanceof QuotaExceededError) {
+        return `llms.ink daily quota of new links is used up${wait === undefined ? '' : `; it resets in ${wait} seconds (midnight UTC)`}. Cached links still work.`;
+    }
+    return `llms.ink: ${err.detail}`;
+}
+const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`;
+/** The check as a short report (the same as the MCP tool's). */
+function checkReport(r) {
+    const lines = r.issues.map((i) => `- ${i.level}${i.line ? ` (line ${i.line})` : ''}: ${i.message}`);
+    if (!r.found)
+        return [`No llms.txt found for ${r.site ?? 'this text'}.`, '', ...lines].join('\n');
+    const facts = [
+        `${plural(r.summary.errors, 'error')}, ${plural(r.summary.warnings, 'warning')}`,
+        plural(r.sections, 'section'),
+        `${plural(r.links.total, 'link')} (${r.links.checked || !r.links.total ? `${r.links.checked} checked, ${r.links.broken.length} broken` : 'not checked'})`,
+        `~${r.tokens} tokens`,
+        ...(r.llmsFull === null ? [] : [`llms-full.txt ${r.llmsFull ? 'found' : 'not found'}`]),
+    ];
+    const outline = r.parsed?.sections.length
+        ? ['', `Sections: ${r.parsed.sections.map((s) => `${s.name} (${plural(s.links.length, 'link')})`).join(', ')}`]
+        : [];
+    const broken = r.links.broken.map((b) => `- broken link (${b.status || 'no answer'}): ${b.url}`);
+    return [`${r.url ?? 'llms.txt'}: ${facts.join(' · ')}`, ...outline, '', ...lines, ...broken].join('\n');
+}
+/** The agent's-eye report as text (the same as the MCP tool's). */
+function reportText(r) {
+    const mark = { pass: '✓', warn: '!', fail: '✕', info: '·' };
+    const lines = [`${r.url}: ${r.summary.fail} fail, ${r.summary.warn} warn, ${r.summary.pass} pass, ${r.summary.info} info`];
+    for (const s of r.sections) {
+        lines.push('', `## ${s.title}`);
+        for (const c of s.checks) {
+            lines.push(`${mark[c.status]} ${c.status} · ${c.title}: ${c.detail}`);
+            if (c.evidence && c.status !== 'pass')
+                lines.push(...c.evidence.split('\n').slice(0, 8).map((l) => `    ${l}`));
+            if (c.fix && c.status !== 'pass')
+                lines.push(`  fix (${c.fix.kind}): ${c.fix.summary}${c.fix.patch ? ` [patch for ${c.fix.patch.file}]` : ''}`);
+        }
+    }
+    return lines.join('\n');
+}

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.5.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';
@@ -138,6 +138,53 @@ export interface CheckResult {
     /** ISO 8601 date-time. */
     checkedAt: string;
 }
+/** `pass` is fine; `warn` is worth fixing; `fail` keeps agents out or empties the page for them; `info` is a fact. */
+export type ReportStatus = 'pass' | 'warn' | 'fail' | 'info';
+/** How to fix a check that didn't pass. */
+export interface ReportFix {
+    /** Where the change goes. */
+    kind: 'robots' | 'markdown' | 'llms-txt' | 'indexnow' | 'content' | 'html' | 'headers' | 'other';
+    /** What to change, in a sentence. */
+    summary: string;
+    /** A concrete change, when one is possible: `file` from the site root and its new content or lines to add. */
+    patch?: {
+        file: string;
+        content: string;
+    };
+}
+/** One check of the agent's-eye report. */
+export interface ReportCheck {
+    /** Stable name of the check, e.g. `bots-search`, `raw-text`. */
+    id: string;
+    status: ReportStatus;
+    title: string;
+    /** What was found, for people. */
+    detail: string;
+    /** What it's based on: lines, headers, snippets, sizes. */
+    evidence?: string;
+    fix?: ReportFix;
+}
+/** `GET /api/v0/report`: how AI crawlers and agents see a page, each problem with its fix. */
+export interface ReportResult {
+    /** The page reported on, after normalization and redirects. */
+    url: string;
+    /** Its origin. */
+    site: string;
+    /** ISO 8601 date-time. */
+    checkedAt: string;
+    summary: {
+        pass: number;
+        warn: number;
+        fail: number;
+        info: number;
+    };
+    /** In order: access, rendering, extraction, retrieval, hidden instructions, agent files. */
+    sections: Array<{
+        id: string;
+        title: string;
+        checks: ReportCheck[];
+    }>;
+}
 /** Every error code the API answers with (https://llms.ink/docs/#errors). */
 export type ErrorCode = 'inspection_not_enabled' | 'inspection_quota' | 'inspection_unavailable' | 'invalid_request' | 'invalid_url' | 'invalid_key' | 'key_required' | 'site_claimed' | 'not_found' | 'unknown_version' | 'method_not_allowed' | 'payload_too_large' | 'too_large' | 'unsupported_media_type' | 'unprocessable' | 'rate_limited' | 'quota_exceeded' | 'internal' | 'upstream_error' | 'unavailable' | 'timeout' | 'loop_detected';
 /** `invalid_request` only: one invalid parameter. */
@@ -238,6 +285,10 @@ export interface LlmsOptions {
 export interface CheckOptions {
     signal?: AbortSignal;
 }
+/** Options for {@link LlmsInk.report}. */
+export interface ReportOptions {
+    signal?: AbortSignal;
+}
 /** Options for {@link LlmsInk.checkText}. */
 export interface CheckTextOptions {
     /** Public URL the text lives at: resolves relative links and is reported as `url` / `site`. */
@@ -281,6 +332,11 @@ export declare class LlmsInk {
     }): Promise<InspectionReceipt>;
     /** Checks a site's published llms.txt against the llmstxt.org format and that its links answer. */
     check(url: string, options?: CheckOptions): Promise<CheckResult>;
+    /**
+     * How AI crawlers and agents see a page (`GET /api/v0/report`): robots.txt per AI bot, firewall blocks, text
+     * without JavaScript, Markdown conversion, hidden instructions and agent files, each problem with its fix.
+     */
+    report(url: string, options?: ReportOptions): Promise<ReportResult>;
     /** Parses and checks llms.txt text you already have (`POST /api/v0/check`); nothing is published. */
     checkText(text: string, options?: CheckTextOptions): Promise<CheckResult>;
     /**

package/dist/index.js

@@ -15,7 +15,7 @@
  */
 import { prepareInspection, inspectionJson, inspectionReceipt } from "./inspect.js";
 import { env } from "./env.js";
-export const VERSION = '0.5.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).
@@ -148,6 +148,14 @@ export class LlmsInk {
         const res = await this.#request('/api/v0/check', { url }, 'application/json', options.signal);
         return (await this.#json(res));
     }
+    /**
+     * How AI crawlers and agents see a page (`GET /api/v0/report`): robots.txt per AI bot, firewall blocks, text
+     * without JavaScript, Markdown conversion, hidden instructions and agent files, each problem with its fix.
+     */
+    async report(url, options = {}) {
+        const res = await this.#request('/api/v0/report', { url }, 'application/json', options.signal);
+        return (await this.#json(res));
+    }
     /** Parses and checks llms.txt text you already have (`POST /api/v0/check`); nothing is published. */
     async checkText(text, options = {}) {
         const params = {};

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,7 +1,7 @@
 {
   "name": "llms-ink",
-  "version": "0.5.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. No dependencies.",
+  "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": {
     ".": {
@@ -19,39 +19,93 @@
     "./middleware": {
       "types": "./dist/middleware.d.ts",
       "default": "./dist/middleware.js"
+    },
+    "./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 && node --test test/client.test.mjs test/plugins.test.mjs test/middleware.test.mjs test/traffic.test.mjs test/inspect.test.mjs",
+    "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:bun:live": "npm run build && bun test --timeout 300000 ./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: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"],
+  "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",
   "peerDependencies": {
+    "ai": ">=5",
     "astro": ">=4",
-    "vite": ">=5"
+    "vite": ">=5",
+    "zod": "^3.25.76 || ^4.1.8",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.319"
   },
   "peerDependenciesMeta": {
-    "astro": { "optional": true },
-    "vite": { "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",
     "typescript": "^5.9.3",
-    "vite": "^8.3.8"
+    "vite": "^8.3.8",
+    "zod": "^4.6.7"
   }
 }