@jsonstudio/llms 0.4.2

package/dist/sse/types/utility-types.d.ts

@@ -0,0 +1,230 @@
+/**
+ * 工具类型定义
+ * 提供JSON↔SSE双向转换中常用的工具类型和辅助函数
+ */
+export type ProtocolType = 'chat' | 'responses';
+export type ConversionDirection = 'json_to_sse' | 'sse_to_json';
+export interface EventTypeMap {
+    chat: {
+        SSE_EVENT: 'chat_chunk' | 'chat.done' | 'error' | 'ping';
+        JSON_TYPE: 'ChatCompletionChunk' | 'ChatCompletionResponse';
+    };
+    responses: {
+        SSE_EVENT: 'response.created' | 'response.in_progress' | 'response.completed' | 'response.required_action' | 'response.done' | 'response.output_item.added' | 'response.output_item.done' | 'response.content_part.added' | 'response.content_part.done' | 'response.output_text.delta' | 'response.output_text.done' | 'response.reasoning_text.delta' | 'response.reasoning_text.done' | 'response.function_call_arguments.delta' | 'response.function_call_arguments.done';
+        JSON_TYPE: 'ResponsesResponse' | 'ResponsesRequest';
+    };
+}
+export interface GenericConverter<TProtocol extends ProtocolType, TDirection extends ConversionDirection> {
+    protocol: TProtocol;
+    direction: TDirection;
+    convert(input: any, options: any): Promise<any>;
+    validate?(input: any): boolean;
+    getStats?(): any;
+}
+export interface UnifiedConversionOptions {
+    requestId: string;
+    model: string;
+    protocol: ProtocolType;
+    direction: ConversionDirection;
+    timeoutMs?: number;
+    enableHeartbeat?: boolean;
+    heartbeatIntervalMs?: number;
+    validationMode?: 'none' | 'basic' | 'strict';
+    debugMode?: boolean;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+}
+export interface UnifiedEventStream extends AsyncIterable<any> {
+    protocol: ProtocolType;
+    direction: ConversionDirection;
+    requestId: string;
+    getStats(): any;
+    getConfig(): any;
+    pause?(): void;
+    resume?(): void;
+    complete(): void;
+    abort(error?: Error): void;
+    on?(event: 'error', handler: (error: Error) => void): this;
+    on?(event: 'complete', handler: () => void): this;
+    on?(event: 'timeout', handler: () => void): this;
+    on?(event: 'stats', handler: (stats: any) => void): this;
+}
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type JsonType<TProtocol extends ProtocolType> = TProtocol extends 'chat' ? ChatJsonType : TProtocol extends 'responses' ? ResponsesJsonType : never;
+export type SseEventType<TProtocol extends ProtocolType> = TProtocol extends 'chat' ? ChatSseEventType : TProtocol extends 'responses' ? ResponsesSseEventType : never;
+export interface ChatJsonType {
+    id: string;
+    object: 'chat.completion' | 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: any[];
+    usage?: any;
+}
+export type ChatSseEventType = 'chat_chunk' | 'chat.done' | 'error' | 'ping';
+export interface ResponsesJsonType {
+    id: string;
+    object: 'response';
+    created_at: number;
+    model: string;
+    status: string;
+    output: any[];
+    usage?: any;
+}
+export type ResponsesSseEventType = 'response.created' | 'response.in_progress' | 'response.completed' | 'response.required_action' | 'response.done' | 'response.output_item.added' | 'response.output_item.done' | 'response.content_part.added' | 'response.content_part.done' | 'response.output_text.delta' | 'response.output_text.done' | 'response.reasoning_text.delta' | 'response.reasoning_text.done' | 'response.function_call_arguments.delta' | 'response.function_call_arguments.done';
+export interface ConversionResult<TSuccess = any, TError = Error> {
+    success: boolean;
+    data?: TSuccess;
+    error?: TError;
+    metadata?: {
+        duration: number;
+        eventsProcessed: number;
+        bytesProcessed: number;
+        protocol: ProtocolType;
+        direction: ConversionDirection;
+    };
+}
+export type AsyncConversionResult<TSuccess = any, TError = Error> = Promise<ConversionResult<TSuccess, TError>>;
+export interface ConverterFactory {
+    createJsonToSseConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'json_to_sse'>;
+    createSseToJsonConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'sse_to_json'>;
+}
+export interface ConverterRegistry {
+    register<TProtocol extends ProtocolType, TDirection extends ConversionDirection>(protocol: TProtocol, direction: TDirection, converter: GenericConverter<TProtocol, TDirection>): void;
+    get<TProtocol extends ProtocolType, TDirection extends ConversionDirection>(protocol: TProtocol, direction: TDirection): GenericConverter<TProtocol, TDirection> | undefined;
+    list(): Array<{
+        protocol: ProtocolType;
+        direction: ConversionDirection;
+        converter: GenericConverter<any, any>;
+    }>;
+}
+export interface Validator<T> {
+    validate(input: T): ValidationResult;
+    isValid(input: T): boolean;
+    getErrors(input: T): string[];
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ValidationError {
+    code: string;
+    message: string;
+    path: string;
+    value?: any;
+}
+export interface ValidationWarning {
+    code: string;
+    message: string;
+    path: string;
+    value?: any;
+}
+export interface Serializer<T> {
+    serialize(input: T): string;
+    deserialize(input: string): T;
+    isValid(input: string): boolean;
+}
+export interface Cache<K, V> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    size: number;
+}
+export interface MetricsCollector {
+    incrementCounter(name: string, tags?: Record<string, string>): void;
+    recordHistogram(name: string, value: number, tags?: Record<string, string>): void;
+    setGauge(name: string, value: number, tags?: Record<string, string>): void;
+    recordTimer(name: string, duration: number, tags?: Record<string, string>): void;
+    getMetrics(): Record<string, any>;
+}
+export interface Logger {
+    debug(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, error?: Error, meta?: any): void;
+    child(meta: any): Logger;
+}
+export interface RetryConfig {
+    maxAttempts: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+    jitter: boolean;
+    retryableErrors: string[];
+}
+export interface CircuitBreakerConfig {
+    failureThreshold: number;
+    recoveryTimeoutMs: number;
+    monitoringPeriodMs: number;
+    expectedRecoveryTimeMs: number;
+}
+export interface RateLimitConfig {
+    windowMs: number;
+    maxRequests: number;
+    burstSize?: number;
+    strategy: 'sliding_window' | 'fixed_window' | 'token_bucket';
+}
+export interface HealthCheck {
+    isHealthy(): Promise<boolean>;
+    getStatus(): HealthStatus;
+    onHealthChange(callback: (status: HealthStatus) => void): void;
+}
+export interface HealthStatus {
+    healthy: boolean;
+    timestamp: number;
+    details?: Record<string, any>;
+}
+export interface LifecycleHooks {
+    beforeConversion?: (context: any) => Promise<void>;
+    afterConversion?: (context: any, result: any) => Promise<void>;
+    onError?: (context: any, error: Error) => Promise<void>;
+    onTimeout?: (context: any) => Promise<void>;
+    onRetry?: (context: any, attempt: number) => Promise<void>;
+}
+export interface Middleware {
+    name: string;
+    priority: number;
+    beforeConversion?: (context: any) => Promise<void>;
+    afterConversion?: (context: any, result: any) => Promise<void>;
+    onError?: (context: any, error: Error) => Promise<void>;
+}
+export interface Plugin {
+    name: string;
+    version: string;
+    initialize(context: any): Promise<void>;
+    destroy(): Promise<void>;
+    getMiddlewares(): Middleware[];
+    getHooks(): LifecycleHooks;
+}
+export interface ConfigMerger {
+    merge<T>(base: T, override: Partial<T>): T;
+    validate<T>(config: T): ValidationResult;
+    normalize<T>(config: T): T;
+}
+export interface EnvironmentParser {
+    getString(key: string, defaultValue?: string): string;
+    getNumber(key: string, defaultValue?: number): number;
+    getBoolean(key: string, defaultValue?: boolean): boolean;
+    getArray(key: string, delimiter?: string): string[];
+    getObject(key: string): any;
+}
+export declare const TypeGuards: {
+    isString: (value: any) => value is string;
+    isNumber: (value: any) => value is number;
+    isBoolean: (value: any) => value is boolean;
+    isObject: (value: any) => value is object;
+    isArray: (value: any) => value is any[];
+    isFunction: (value: any) => value is Function;
+    isDate: (value: any) => value is Date;
+    isNull: (value: any) => value is null;
+    isUndefined: (value: any) => value is undefined;
+    isNullOrUndefined: (value: any) => value is null | undefined;
+};
+export declare const AsyncUtils: {
+    delay: (ms: number) => Promise<void>;
+    timeout: <T>(promise: Promise<T>, ms: number) => Promise<T>;
+    retry: <T>(fn: () => Promise<T>, config: RetryConfig) => Promise<T>;
+};

package/dist/sse/types/utility-types.js

@@ -0,0 +1,49 @@
+/**
+ * 工具类型定义
+ * 提供JSON↔SSE双向转换中常用的工具类型和辅助函数
+ */
+// 类型守卫工具函数
+export const TypeGuards = {
+    isString: (value) => typeof value === 'string',
+    isNumber: (value) => typeof value === 'number' && !isNaN(value),
+    isBoolean: (value) => typeof value === 'boolean',
+    isObject: (value) => value !== null && typeof value === 'object',
+    isArray: (value) => Array.isArray(value),
+    isFunction: (value) => typeof value === 'function',
+    isDate: (value) => value instanceof Date,
+    isNull: (value) => value === null,
+    isUndefined: (value) => value === undefined,
+    isNullOrUndefined: (value) => value == null
+};
+// 异步工具函数
+export const AsyncUtils = {
+    delay: (ms) => new Promise(resolve => setTimeout(resolve, ms)),
+    timeout: (promise, ms) => {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms))
+        ]);
+    },
+    retry: async (fn, config) => {
+        let lastError;
+        for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                if (!config.retryableErrors.includes(error.name) || attempt === config.maxAttempts) {
+                    throw error;
+                }
+                const delay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt - 1), config.maxDelayMs);
+                if (config.jitter) {
+                    await AsyncUtils.delay(delay + Math.random() * delay * 0.1);
+                }
+                else {
+                    await AsyncUtils.delay(delay);
+                }
+            }
+        }
+        throw lastError;
+    }
+};

package/dist/tools/proxy/anthropic-tool-proxy.d.ts

@@ -0,0 +1,19 @@
+import type { ProxyPlan } from './types.js';
+export declare class AnthropicToolProxy {
+    constructor();
+    /**
+     * Inspect an Anthropic message (round-1) content blocks, execute supported
+     * tool_use blocks server-side, and return a plan of tool_result blocks.
+     */
+    buildProxyPlan(firstRoundAnthropicMessage: any): Promise<ProxyPlan>;
+    /**
+     * Build a second Anthropic Messages request payload by appending:
+     *  - assistant (original tool_use blocks)
+     *  - user (tool_result[] built from proxy plan)
+     */
+    buildSecondRoundPayload(originalAnthropicRequest: any, plan: ProxyPlan): any;
+}
+declare const _default: {
+    AnthropicToolProxy: typeof AnthropicToolProxy;
+};
+export default _default;

package/dist/tools/proxy/anthropic-tool-proxy.js

@@ -0,0 +1,57 @@
+import { GlobalToolRegistry } from './registry.js';
+import { WebFetchExecutor } from './executors/web-fetch.js';
+function registerDefaults() {
+    try {
+        GlobalToolRegistry.register(new WebFetchExecutor());
+    }
+    catch { }
+}
+export class AnthropicToolProxy {
+    constructor() { registerDefaults(); }
+    /**
+     * Inspect an Anthropic message (round-1) content blocks, execute supported
+     * tool_use blocks server-side, and return a plan of tool_result blocks.
+     */
+    async buildProxyPlan(firstRoundAnthropicMessage) {
+        const assistantBlocks = (firstRoundAnthropicMessage && typeof firstRoundAnthropicMessage === 'object' && Array.isArray(firstRoundAnthropicMessage.content))
+            ? firstRoundAnthropicMessage.content : [];
+        const out = [];
+        for (const b of assistantBlocks) {
+            try {
+                const t = String(b?.type || '').toLowerCase();
+                if (t !== 'tool_use')
+                    continue;
+                const name = String(b?.name || '');
+                const ex = GlobalToolRegistry.resolve(name);
+                if (!ex)
+                    continue;
+                const input = (b && typeof b === 'object') ? (b.input ?? {}) : {};
+                const result = await ex.execute(input);
+                const id = String(b?.id || '');
+                if (id)
+                    out.push({ tool_use_id: id, content: result.content });
+            }
+            catch { }
+        }
+        return { assistantBlocks, results: out };
+    }
+    /**
+     * Build a second Anthropic Messages request payload by appending:
+     *  - assistant (original tool_use blocks)
+     *  - user (tool_result[] built from proxy plan)
+     */
+    buildSecondRoundPayload(originalAnthropicRequest, plan) {
+        const messagesOrig = Array.isArray(originalAnthropicRequest?.messages) ? originalAnthropicRequest.messages : [];
+        const assistantMsg = { role: 'assistant', content: plan.assistantBlocks };
+        const userMsg = { role: 'user', content: plan.results.map(r => ({ type: 'tool_result', tool_use_id: r.tool_use_id, content: r.content })) };
+        return {
+            model: String(originalAnthropicRequest?.model || 'unknown'),
+            system: originalAnthropicRequest?.system,
+            tools: Array.isArray(originalAnthropicRequest?.tools) ? originalAnthropicRequest.tools : undefined,
+            messages: [...messagesOrig, assistantMsg, userMsg],
+            stream: true,
+            metadata: { ...(originalAnthropicRequest?.metadata || {}), entryEndpoint: '/v1/messages', stream: true }
+        };
+    }
+}
+export default { AnthropicToolProxy };

package/dist/tools/proxy/executors/web-fetch.d.ts

@@ -0,0 +1,6 @@
+import type { ToolExecutor, ToolExecutionResult } from '../types.js';
+export declare class WebFetchExecutor implements ToolExecutor {
+    readonly id = "web-fetch-executor";
+    readonly names: string[];
+    execute(input: unknown): Promise<ToolExecutionResult>;
+}

package/dist/tools/proxy/executors/web-fetch.js

@@ -0,0 +1,39 @@
+import { fetchRawHtml } from '../../web-fetch-html.js';
+import { htmlToMarkdown } from '../../../html-to-markdown.js';
+export class WebFetchExecutor {
+    id = 'web-fetch-executor';
+    // 仅接受唯一名称
+    names = ['web_fetch'];
+    async execute(input) {
+        try {
+            const obj = (input && typeof input === 'object') ? input : {};
+            const url = String(obj.url || obj.href || '');
+            // 输出格式：默认 html；当 format==='markdown' 或 clean===true 时输出 markdown
+            const fmt = String(obj.format || '').toLowerCase();
+            const wantsMarkdown = fmt === 'markdown' || obj.clean === true;
+            if (!url) {
+                return { ok: false, content: 'invalid_url', error: 'invalid_url' };
+            }
+            const r = await fetchRawHtml(url, {});
+            const ok = !!r && r.ok === true;
+            const html = ok ? (r.html || '') : (r.error || 'fetch_failed');
+            let content;
+            if (wantsMarkdown && ok) {
+                try {
+                    content = htmlToMarkdown(String(html));
+                }
+                catch {
+                    content = String(html);
+                }
+            }
+            else {
+                content = String(html);
+            }
+            const limited = content.slice(0, 200000);
+            return { ok, content: limited };
+        }
+        catch (e) {
+            return { ok: false, content: String(e?.message || 'error'), error: String(e?.message || 'error') };
+        }
+    }
+}

package/dist/tools/proxy/registry.d.ts

@@ -0,0 +1,8 @@
+import type { ToolExecutor } from './types.js';
+export declare class ToolRegistry {
+    private executors;
+    register(executor: ToolExecutor): void;
+    resolve(name: string): ToolExecutor | null;
+    has(name: string): boolean;
+}
+export declare const GlobalToolRegistry: ToolRegistry;

package/dist/tools/proxy/registry.js

@@ -0,0 +1,14 @@
+export class ToolRegistry {
+    executors = new Map();
+    register(executor) {
+        for (const n of executor.names) {
+            this.executors.set(n, executor);
+        }
+    }
+    resolve(name) {
+        const ex = this.executors.get(name);
+        return ex || null;
+    }
+    has(name) { return this.executors.has(name); }
+}
+export const GlobalToolRegistry = new ToolRegistry();

package/dist/tools/proxy/types.d.ts

@@ -0,0 +1,29 @@
+export type ToolUseBlock = {
+    type: string;
+    id?: string;
+    name?: string;
+    input?: unknown;
+};
+export type ToolResultBlock = {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+};
+export interface ToolExecutionResult {
+    ok: boolean;
+    content: string;
+    error?: string;
+    meta?: Record<string, unknown>;
+}
+export interface ToolExecutor {
+    readonly id: string;
+    readonly names: string[];
+    execute(input: unknown): Promise<ToolExecutionResult>;
+}
+export interface ProxyPlan {
+    assistantBlocks: any[];
+    results: Array<{
+        tool_use_id: string;
+        content: string;
+    }>;
+}

package/dist/tools/proxy/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/tool-registry.d.ts

@@ -0,0 +1,8 @@
+export interface ToolValidationResult {
+    ok: boolean;
+    reason?: string;
+    warnings?: Array<Record<string, unknown>>;
+    normalizedArgs?: string;
+}
+export declare function getAllowedToolNames(): string[];
+export declare function validateToolCall(name: string, argsString: string): ToolValidationResult;

package/dist/tools/tool-registry.js

@@ -0,0 +1,154 @@
+function tryParse(s) {
+    try {
+        const v = JSON.parse(s);
+        return (v && typeof v === 'object') ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+function isImagePath(p) {
+    try {
+        const s = String(p || '').toLowerCase();
+        return /\.(png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl)$/.test(s);
+    }
+    catch {
+        return false;
+    }
+}
+export function getAllowedToolNames() {
+    return [
+        'shell',
+        'apply_patch',
+        'update_plan',
+        'view_image',
+        'list_mcp_resources',
+        'read_mcp_resource',
+        'list_mcp_resource_templates',
+    ];
+}
+function detectForbiddenWrite(script) {
+    const s = script.toLowerCase();
+    if (!s)
+        return false;
+    // forbid common write patterns via shell
+    if (/>\s*[^\s<]/.test(s))
+        return true; // redirection
+    if (/<<</.test(s) || /<</.test(s))
+        return true; // heredoc
+    if (/\bsed\b[^\n]*\-i\b/.test(s))
+        return true;
+    if (/\bed\b[^\n]*\-s\b/.test(s))
+        return true;
+    if (/\btee\b\s+/.test(s))
+        return true;
+    return false;
+}
+export function validateToolCall(name, argsString) {
+    const nm = String(name || '').trim();
+    if (!nm)
+        return { ok: false, reason: 'empty_tool_name' };
+    const allowed = new Set(getAllowedToolNames());
+    if (!allowed.has(nm))
+        return { ok: false, reason: 'unknown_tool' };
+    // Parse args once
+    const rawObj = tryParse(typeof argsString === 'string' ? argsString : '{}');
+    const toJson = (v) => { try {
+        return JSON.stringify(v ?? {});
+    }
+    catch {
+        return '{}';
+    } };
+    switch (nm) {
+        case 'apply_patch': {
+            const patch = rawObj?.patch;
+            if (typeof patch !== 'string' || patch.trim().length === 0) {
+                return { ok: false, reason: 'missing_patch' };
+            }
+            return { ok: true, normalizedArgs: toJson({ patch }) };
+        }
+        case 'shell': {
+            let cmd = rawObj?.command;
+            // Accept string command and coerce to argv array
+            if (typeof cmd === 'string' && cmd.trim().length) {
+                cmd = [cmd];
+            }
+            if (!Array.isArray(cmd) || !cmd.every((x) => typeof x === 'string')) {
+                return { ok: false, reason: 'invalid_command' };
+            }
+            // 统一 bash -lc 处理：
+            // - 当命令包含管道/与或/分号等元字符时，若未显式使用 bash -lc，则折叠为 ['bash','-lc','<script>']
+            // - 对写入型重定向/heredoc/sed -i 等仍然严格拒绝（要求使用 apply_patch）
+            const joinScript = (arr) => arr.join(' ');
+            const looksBashLc = (arr) => arr.length >= 2 && arr[0] === 'bash' && arr[1] === '-lc';
+            const hasMeta = (s) => /[|;&]/.test(s) || s.includes('&&') || s.includes('||');
+            const scriptJoined = joinScript(cmd);
+            // 拒绝危险写入模式
+            if (detectForbiddenWrite(scriptJoined)) {
+                return { ok: false, reason: 'forbidden_write_redirection' };
+            }
+            let finalCmd = cmd.slice();
+            if (!looksBashLc(finalCmd) && hasMeta(scriptJoined)) {
+                finalCmd = ['bash', '-lc', scriptJoined];
+            }
+            const out = { command: finalCmd };
+            if (typeof rawObj?.workdir === 'string')
+                out.workdir = rawObj.workdir;
+            if (typeof rawObj?.timeout_ms === 'number')
+                out.timeout_ms = rawObj.timeout_ms;
+            if (typeof rawObj?.with_escalated_permissions === 'boolean')
+                out.with_escalated_permissions = rawObj.with_escalated_permissions;
+            if (typeof rawObj?.justification === 'string')
+                out.justification = rawObj.justification;
+            return { ok: true, normalizedArgs: toJson(out) };
+        }
+        case 'update_plan': {
+            const plan = rawObj?.plan;
+            if (!Array.isArray(plan))
+                return { ok: false, reason: 'missing_plan' };
+            // warn for >1 in_progress
+            let inProg = 0;
+            for (const it of plan) {
+                if (it && typeof it === 'object' && it.status === 'in_progress')
+                    inProg += 1;
+            }
+            const warnings = [];
+            if (inProg > 1)
+                warnings.push({ kind: 'multiple_in_progress', count: inProg });
+            return { ok: true, warnings: warnings.length ? warnings : undefined, normalizedArgs: toJson({ explanation: rawObj?.explanation, plan }) };
+        }
+        case 'view_image': {
+            const path = rawObj?.path;
+            if (typeof path !== 'string' || !isImagePath(path))
+                return { ok: false, reason: 'invalid_image_path' };
+            return { ok: true, normalizedArgs: toJson({ path }) };
+        }
+        case 'list_mcp_resources': {
+            // all optional; no heavy validation here
+            const out = {};
+            if (typeof rawObj?.server === 'string')
+                out.server = rawObj.server;
+            if (typeof rawObj?.filter === 'string')
+                out.filter = rawObj.filter;
+            if (typeof rawObj?.root === 'string')
+                out.root = rawObj.root;
+            return { ok: true, normalizedArgs: toJson(out) };
+        }
+        case 'read_mcp_resource': {
+            const server = rawObj?.server;
+            const uri = rawObj?.uri;
+            if (typeof server !== 'string' || typeof uri !== 'string')
+                return { ok: false, reason: 'missing_server_or_uri' };
+            return { ok: true, normalizedArgs: toJson({ server, uri }) };
+        }
+        case 'list_mcp_resource_templates': {
+            const out = {};
+            if (typeof rawObj?.server === 'string')
+                out.server = rawObj.server;
+            if (typeof rawObj?.cursor === 'string')
+                out.cursor = rawObj.cursor;
+            return { ok: true, normalizedArgs: toJson(out) };
+        }
+    }
+    return { ok: false, reason: 'unknown_tool' };
+}

package/dist/tools/web-fetch-html.d.ts

@@ -0,0 +1,15 @@
+export interface WebFetchHtmlOptions {
+    timeoutMs?: number;
+    followRedirects?: boolean;
+    maxBytes?: number;
+    headers?: Record<string, string>;
+}
+export interface WebFetchHtmlResult {
+    ok: boolean;
+    html?: string;
+    error?: string;
+    status?: number;
+    contentType?: string | null;
+    url?: string;
+}
+export declare function fetchRawHtml(url: string, opts?: WebFetchHtmlOptions): Promise<WebFetchHtmlResult>;