anyclaude-sdk 0.1.0

package/dist/mcp/index.d.ts

@@ -0,0 +1,24 @@
+import type { Tool } from '../tools/types.js';
+import type { McpServers, McpServerStatus } from './types.js';
+export * from './types.js';
+export { McpClient } from './client.js';
+export { applyProxy, type McpProxy } from './proxy.js';
+export { tool, createSdkMcpServer } from './sdkServer.js';
+import type { McpProxy } from './proxy.js';
+/** Options for loadMcpServers. */
+export interface LoadMcpOptions {
+    signal?: AbortSignal;
+    /** Route remote (http/sse) MCP requests through a proxy (browser CORS). */
+    proxy?: McpProxy;
+}
+/** Tool name namespacing: mcp__<server>__<tool>, matching the official SDK. */
+export declare function mcpToolName(server: string, toolName: string): string;
+/**
+ * Load every configured MCP server and return their tools (wrapped as native
+ * Tools) plus per-server connection status. Never throws — a server that fails
+ * to connect contributes a 'failed' status and no tools.
+ */
+export declare function loadMcpServers(servers: McpServers, opts?: AbortSignal | LoadMcpOptions): Promise<{
+    tools: Tool[];
+    statuses: McpServerStatus[];
+}>;

package/dist/mcp/index.js

@@ -0,0 +1,157 @@
+// MCP integration: load tools from external (HTTP/SSE) and in-process (SDK)
+// MCP servers, wrapped as native browser-claude-sdk `Tool`s so they drop
+// straight into the agent's tool list.
+import { McpClient } from './client.js';
+export * from './types.js';
+export { McpClient } from './client.js';
+export { applyProxy } from './proxy.js';
+export { tool, createSdkMcpServer } from './sdkServer.js';
+/** Tool name namespacing: mcp__<server>__<tool>, matching the official SDK. */
+export function mcpToolName(server, toolName) {
+    return `mcp__${server}__${toolName}`;
+}
+/** Coerce an MCP inputSchema into our OpenAI-shape parameters object. */
+function toToolParameters(schema) {
+    const s = schema ?? {};
+    return {
+        type: 'object',
+        properties: s.properties ?? {},
+        ...(Array.isArray(s.required) ? { required: s.required } : {}),
+    };
+}
+/** Map an MCP tool result's content blocks to our ContentBlockParam[]. */
+function mapMcpContent(result) {
+    const blocks = [];
+    for (const c of result.content ?? []) {
+        const block = c;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            blocks.push({ type: 'text', text: block.text });
+        }
+        else if (block.type === 'image' || block.type === 'audio') {
+            const b = block;
+            if (typeof b.data === 'string') {
+                // Audio isn't a first-class block for us; surface images natively and
+                // note audio as text so nothing is silently dropped.
+                if (block.type === 'image') {
+                    blocks.push({
+                        type: 'image',
+                        source: { type: 'base64', media_type: b.mimeType ?? 'image/png', data: b.data },
+                    });
+                }
+                else {
+                    blocks.push({ type: 'text', text: `[audio: ${b.mimeType ?? 'audio'} omitted]` });
+                }
+            }
+        }
+        else if (block.type === 'resource') {
+            const r = block.resource;
+            if (r?.text)
+                blocks.push({ type: 'text', text: r.text });
+            else if (r?.uri)
+                blocks.push({ type: 'text', text: `[resource: ${r.uri}]` });
+        }
+        else {
+            // Unknown block kind — stringify so it isn't lost.
+            try {
+                blocks.push({ type: 'text', text: JSON.stringify(block) });
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    if (!blocks.length)
+        blocks.push({ type: 'text', text: '(no content)' });
+    return { content: blocks, isError: result.isError || undefined };
+}
+function wrapSdkTool(serverName, t) {
+    return {
+        def: {
+            type: 'function',
+            function: {
+                name: mcpToolName(serverName, t.name),
+                description: t.description,
+                parameters: toToolParameters(t.inputSchema),
+            },
+        },
+        async run(input) {
+            try {
+                const res = await t.handler(input);
+                return mapMcpContent(res);
+            }
+            catch (err) {
+                return {
+                    content: `MCP error: ${err instanceof Error ? err.message : String(err)}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}
+function wrapRemoteTool(serverName, client, info) {
+    return {
+        def: {
+            type: 'function',
+            function: {
+                name: mcpToolName(serverName, info.name),
+                description: info.description ?? `MCP tool ${info.name}`,
+                parameters: toToolParameters(info.inputSchema),
+            },
+        },
+        async run(input, ctx) {
+            try {
+                const res = await client.callTool(info.name, input, ctx.signal);
+                return mapMcpContent(res);
+            }
+            catch (err) {
+                return {
+                    content: `MCP error: ${err instanceof Error ? err.message : String(err)}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}
+/**
+ * Load every configured MCP server and return their tools (wrapped as native
+ * Tools) plus per-server connection status. Never throws — a server that fails
+ * to connect contributes a 'failed' status and no tools.
+ */
+export async function loadMcpServers(servers, opts = {}) {
+    // Back-compat: accept a bare AbortSignal as the second arg.
+    const options = opts && typeof opts.aborted === 'boolean'
+        ? { signal: opts }
+        : opts;
+    const signal = options.signal;
+    const proxy = options.proxy;
+    const tools = [];
+    const statuses = [];
+    for (const [name, config] of Object.entries(servers)) {
+        if (config.type === 'sdk') {
+            const wrapped = config.server.tools.map((t) => wrapSdkTool(name, t));
+            tools.push(...wrapped);
+            statuses.push({
+                name,
+                status: 'connected',
+                tools: config.server.tools.map((t) => t.name),
+            });
+            continue;
+        }
+        // Remote (http / sse).
+        try {
+            const client = new McpClient(config, name, proxy);
+            await client.connect(signal);
+            const infos = await client.listTools(signal);
+            tools.push(...infos.map((info) => wrapRemoteTool(name, client, info)));
+            statuses.push({ name, status: 'connected', tools: infos.map((i) => i.name) });
+        }
+        catch (err) {
+            statuses.push({
+                name,
+                status: 'failed',
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return { tools, statuses };
+}

package/dist/mcp/proxy.d.ts

@@ -0,0 +1,3 @@
+export type McpProxy = string | ((targetUrl: string) => string);
+/** Resolve the actual request URL for a target MCP endpoint given a proxy. */
+export declare function applyProxy(targetUrl: string, proxy?: McpProxy): string;

package/dist/mcp/proxy.js

@@ -0,0 +1,25 @@
+// MCP request proxying. Browsers block direct cross-origin fetches to most MCP
+// servers (no permissive CORS), so the SDK lets callers route MCP requests
+// through a proxy of their choosing.
+//
+// Forms accepted:
+//   - function: (targetUrl) => requestUrl                  full control
+//   - string with `{url}`:   'https://cors.example/?u={url}'   (URL-encoded)
+//   - string with `{rawUrl}':'https://cors.example/{rawUrl}'   (raw)
+//   - bare prefix:           'https://cors.example/'           (raw URL appended)
+//
+// The proxy must forward the request (method, body, headers — including
+// `Mcp-Session-Id` and `Content-Type`) to the target and echo permissive CORS
+// headers and the `Mcp-Session-Id` response header back.
+/** Resolve the actual request URL for a target MCP endpoint given a proxy. */
+export function applyProxy(targetUrl, proxy) {
+    if (!proxy)
+        return targetUrl;
+    if (typeof proxy === 'function')
+        return proxy(targetUrl);
+    if (proxy.includes('{url}'))
+        return proxy.replace('{url}', encodeURIComponent(targetUrl));
+    if (proxy.includes('{rawUrl}'))
+        return proxy.replace('{rawUrl}', targetUrl);
+    return proxy + targetUrl;
+}

package/dist/mcp/sdkServer.d.ts

@@ -0,0 +1,21 @@
+import type { McpSdkServerConfig, McpToolResult, SdkMcpTool } from './types.js';
+/**
+ * Ergonomic builder for an in-process MCP tool.
+ *
+ * @example
+ * tool('add', 'Add two numbers',
+ *   { type: 'object', properties: { a: { type: 'number' }, b: { type: 'number' } }, required: ['a','b'] },
+ *   async ({ a, b }) => ({ content: [{ type: 'text', text: String((a as number) + (b as number)) }] })
+ * )
+ */
+export declare function tool(name: string, description: string, inputSchema: SdkMcpTool['inputSchema'], handler: (args: Record<string, unknown>) => Promise<McpToolResult> | McpToolResult): SdkMcpTool;
+/**
+ * Create an in-process MCP server config that can be passed to query() via
+ * `mcpServers`. Its tools run locally and appear to the model as
+ * `mcp__<name>__<toolName>`.
+ */
+export declare function createSdkMcpServer(opts: {
+    name: string;
+    version?: string;
+    tools: SdkMcpTool[];
+}): McpSdkServerConfig;

package/dist/mcp/sdkServer.js

@@ -0,0 +1,28 @@
+// In-process ("SDK") MCP servers. Define tools in plain JS that run in the same
+// process as the agent — no network, no transport. Mirrors the official SDK's
+// createSdkMcpServer / tool() helpers.
+/**
+ * Ergonomic builder for an in-process MCP tool.
+ *
+ * @example
+ * tool('add', 'Add two numbers',
+ *   { type: 'object', properties: { a: { type: 'number' }, b: { type: 'number' } }, required: ['a','b'] },
+ *   async ({ a, b }) => ({ content: [{ type: 'text', text: String((a as number) + (b as number)) }] })
+ * )
+ */
+export function tool(name, description, inputSchema, handler) {
+    return { name, description, inputSchema, handler };
+}
+/**
+ * Create an in-process MCP server config that can be passed to query() via
+ * `mcpServers`. Its tools run locally and appear to the model as
+ * `mcp__<name>__<toolName>`.
+ */
+export function createSdkMcpServer(opts) {
+    const server = {
+        name: opts.name,
+        version: opts.version,
+        tools: opts.tools,
+    };
+    return { type: 'sdk', name: opts.name, server };
+}

package/dist/mcp/types.d.ts

@@ -0,0 +1,92 @@
+export interface McpHttpServerConfig {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface McpSSEServerConfig {
+    type: 'sse';
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface McpSdkServerConfig {
+    type: 'sdk';
+    name: string;
+    server: SdkMcpServer;
+}
+export type McpServerConfig = McpHttpServerConfig | McpSSEServerConfig | McpSdkServerConfig;
+/** Map of server name → configuration. The key is the server's name. */
+export type McpServers = Record<string, McpServerConfig>;
+export interface SdkMcpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+    handler(args: Record<string, unknown>): Promise<McpToolResult> | McpToolResult;
+}
+export interface SdkMcpServer {
+    name: string;
+    version?: string;
+    tools: SdkMcpTool[];
+}
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: number | string;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface McpToolInfo {
+    name: string;
+    description?: string;
+    inputSchema: {
+        type?: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [k: string]: unknown;
+    };
+}
+export type McpContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'audio';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'resource';
+    resource: {
+        uri?: string;
+        text?: string;
+        mimeType?: string;
+        blob?: string;
+    };
+} | {
+    type: string;
+    [k: string]: unknown;
+};
+export interface McpToolResult {
+    content: McpContentBlock[];
+    isError?: boolean;
+}
+export interface McpServerStatus {
+    name: string;
+    status: 'connected' | 'failed' | 'pending';
+    error?: string;
+    tools?: string[];
+}

package/dist/mcp/types.js

@@ -0,0 +1,5 @@
+// Model Context Protocol (MCP) types for browser-claude-sdk.
+//
+// Covers server configuration (remote HTTP/SSE + in-process "SDK" servers),
+// the JSON-RPC 2.0 envelope, and the MCP tool/result shapes we consume.
+export {};

package/dist/memory/index.d.ts

@@ -0,0 +1,4 @@
+export { MemoryStore } from './store.js';
+export { renderMemories } from './render.js';
+export type { MemoryEntry, MemoryType, MemoryStoreOptions } from './types.js';
+export { MEMORY_TOOLS, memoryWrite, memoryList, memoryDelete, } from './tools.js';

package/dist/memory/index.js

@@ -0,0 +1,5 @@
+// Persistent memory system: durable user/feedback/project/reference memories
+// (IndexedDB-backed) that load into the system prompt across sessions.
+export { MemoryStore } from './store.js';
+export { renderMemories } from './render.js';
+export { MEMORY_TOOLS, memoryWrite, memoryList, memoryDelete, } from './tools.js';

package/dist/memory/render.d.ts

@@ -0,0 +1,7 @@
+import type { MemoryEntry } from './types.js';
+/**
+ * Render memory entries into a compact Markdown section for the system prompt.
+ * Returns '' for empty input. Caps total length at ~6000 chars, appending a
+ * truncation note when entries are dropped.
+ */
+export declare function renderMemories(entries: MemoryEntry[]): string;

package/dist/memory/render.js

@@ -0,0 +1,46 @@
+// Pure rendering of memory entries into a system-prompt section.
+const MAX_CHARS = 6000;
+const TYPE_ORDER = ['user', 'feedback', 'project', 'reference'];
+/**
+ * Render memory entries into a compact Markdown section for the system prompt.
+ * Returns '' for empty input. Caps total length at ~6000 chars, appending a
+ * truncation note when entries are dropped.
+ */
+export function renderMemories(entries) {
+    if (!entries.length)
+        return '';
+    // Group by type, preserving a stable type ordering.
+    const byType = new Map();
+    for (const e of entries) {
+        const arr = byType.get(e.type) ?? [];
+        arr.push(e);
+        byType.set(e.type, arr);
+    }
+    const header = '# Memory\n' +
+        'The following are persistent memories from prior sessions. Treat them as ' +
+        'background context (true when written) — verify against the current code ' +
+        'before relying on specifics.\n';
+    const blocks = [];
+    let used = header.length;
+    let dropped = 0;
+    for (const type of TYPE_ORDER) {
+        const list = byType.get(type);
+        if (!list?.length)
+            continue;
+        for (const e of list) {
+            const block = `\n## ${e.type} — ${e.name}\n${e.description}\n${e.body}\n`;
+            if (used + block.length > MAX_CHARS) {
+                dropped++;
+                continue;
+            }
+            blocks.push(block);
+            used += block.length;
+        }
+    }
+    if (!blocks.length)
+        return '';
+    let out = header + blocks.join('');
+    if (dropped > 0)
+        out += `\n_(+${dropped} more memories omitted to save context)_\n`;
+    return out;
+}

package/dist/memory/store.d.ts

@@ -0,0 +1,20 @@
+import type { MemoryEntry, MemoryStoreOptions, MemoryType } from './types.js';
+export declare class MemoryStore {
+    private readonly dbName;
+    private db;
+    private opening;
+    constructor(options?: MemoryStoreOptions);
+    private open;
+    /** Upsert a memory entry by name. */
+    save(entry: MemoryEntry): Promise<void>;
+    /** Get a memory by name, or null. */
+    get(name: string): Promise<MemoryEntry | null>;
+    /** List memories (optionally filtered by type), newest updatedAt first. */
+    list(type?: MemoryType): Promise<MemoryEntry[]>;
+    /** Delete a memory by name. */
+    remove(name: string): Promise<void>;
+    /** Wipe all memories. */
+    clear(): Promise<void>;
+    /** Render all memories into a system-prompt section ('' if none). */
+    render(): Promise<string>;
+}

package/dist/memory/store.js

@@ -0,0 +1,79 @@
+// MemoryStore — durable, queryable memory backed by IndexedDB via Dexie.
+// Loads persistent memories into the system prompt across sessions.
+//
+// `dexie` is an OPTIONAL peer dependency — imported dynamically so this module
+// loads even when Dexie isn't installed (the error surfaces only on first use).
+import { renderMemories } from './render.js';
+export class MemoryStore {
+    constructor(options = {}) {
+        this.db = null;
+        this.opening = null;
+        this.dbName = options.dbName ?? 'bcs-memory';
+    }
+    async open() {
+        if (this.db)
+            return this.db;
+        if (this.opening)
+            return this.opening;
+        this.opening = (async () => {
+            // @ts-ignore optional peer dependency, resolved at runtime
+            const mod = await import('dexie');
+            const Dexie = mod.default ?? mod;
+            const db = new Dexie(this.dbName);
+            db.version(1).stores({
+                memories: 'name, type, updatedAt',
+            });
+            this.db = db;
+            return db;
+        })();
+        return this.opening;
+    }
+    /** Upsert a memory entry by name. */
+    async save(entry) {
+        const db = await this.open();
+        const now = Date.now();
+        const existing = await db.memories.get(entry.name);
+        await db.memories.put({
+            ...entry,
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        });
+    }
+    /** Get a memory by name, or null. */
+    async get(name) {
+        try {
+            const db = await this.open();
+            return (await db.memories.get(name)) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** List memories (optionally filtered by type), newest updatedAt first. */
+    async list(type) {
+        try {
+            const db = await this.open();
+            const rows = await db.memories.toArray();
+            return rows
+                .filter((r) => !type || r.type === type)
+                .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Delete a memory by name. */
+    async remove(name) {
+        const db = await this.open();
+        await db.memories.delete(name);
+    }
+    /** Wipe all memories. */
+    async clear() {
+        const db = await this.open();
+        await db.memories.clear();
+    }
+    /** Render all memories into a system-prompt section ('' if none). */
+    async render() {
+        return renderMemories(await this.list());
+    }
+}

package/dist/memory/tools.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from '../tools/types.js';
+export declare const memoryWrite: Tool;
+export declare const memoryList: Tool;
+export declare const memoryDelete: Tool;
+export declare const MEMORY_TOOLS: Tool[];

package/dist/memory/tools.js

@@ -0,0 +1,95 @@
+// Memory management tools. They read `ctx.memory` (a MemoryStore the agent loop
+// injects); accessed via a cast so this file compiles standalone.
+const TYPES = ['user', 'feedback', 'project', 'reference'];
+function getStore(ctx) {
+    return ctx.memory;
+}
+export const memoryWrite = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'memory_write',
+            description: 'Persist a memory across sessions. Use for durable facts worth remembering: who the user is (user), how to work / corrections (feedback), ongoing project goals/constraints (project), or external references (reference). Re-writing an existing name updates it.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'Short unique kebab-case slug.' },
+                    type: { type: 'string', enum: TYPES, description: 'Memory category.' },
+                    description: { type: 'string', description: 'One-line summary used for recall.' },
+                    body: { type: 'string', description: 'The full memory content.' },
+                },
+                required: ['name', 'type', 'description', 'body'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const store = getStore(ctx);
+        if (!store)
+            return { content: 'Memory is not enabled.', isError: true };
+        const name = String(input.name ?? '').trim();
+        const type = String(input.type ?? '');
+        const description = String(input.description ?? '').trim();
+        const body = String(input.body ?? '').trim();
+        if (!name || !description || !body || !TYPES.includes(type)) {
+            return { content: 'Error: name, type (user|feedback|project|reference), description, and body are required.', isError: true };
+        }
+        await store.save({ name, type, description, body });
+        return { content: `Saved memory "${name}" (${type}).` };
+    },
+};
+export const memoryList = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'memory_list',
+            description: 'List persisted memories (optionally filtered by type).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', enum: TYPES, description: 'Optional filter.' },
+                },
+                required: [],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const store = getStore(ctx);
+        if (!store)
+            return { content: 'Memory is not enabled.', isError: true };
+        const type = input.type ? String(input.type) : undefined;
+        const entries = await store.list(type);
+        if (!entries.length)
+            return { content: type ? `No ${type} memories.` : 'No memories stored.' };
+        return {
+            content: `Memories (${entries.length}):\n` +
+                entries.map((e) => `  ${e.name} [${e.type}] — ${e.description}`).join('\n'),
+        };
+    },
+};
+export const memoryDelete = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'memory_delete',
+            description: 'Delete a persisted memory by name.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'The memory name to delete.' },
+                },
+                required: ['name'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const store = getStore(ctx);
+        if (!store)
+            return { content: 'Memory is not enabled.', isError: true };
+        const name = String(input.name ?? '').trim();
+        if (!name)
+            return { content: 'Error: `name` is required.', isError: true };
+        await store.remove(name);
+        return { content: `Deleted memory "${name}".` };
+    },
+};
+export const MEMORY_TOOLS = [memoryWrite, memoryList, memoryDelete];

package/dist/memory/types.d.ts

@@ -0,0 +1,15 @@
+export type MemoryType = 'user' | 'feedback' | 'project' | 'reference';
+export type MemoryEntry = {
+    /** Stable, unique slug (used as the primary key). */
+    name: string;
+    type: MemoryType;
+    /** One-line summary used for recall/relevance. */
+    description: string;
+    /** The full memory content. */
+    body: string;
+    createdAt?: number;
+    updatedAt?: number;
+};
+export type MemoryStoreOptions = {
+    dbName?: string;
+};

package/dist/memory/types.js

@@ -0,0 +1,4 @@
+// Types for the persistent memory system (ports Claude Code's CLAUDE.md /
+// MEMORY.md memory model: user/feedback/project/reference entries that load
+// into the system prompt across sessions).
+export {};

package/dist/permissions/dangerous.d.ts

@@ -0,0 +1,4 @@
+export declare function isDangerousBash(command: string): {
+    dangerous: boolean;
+    reason?: string;
+};