overai 1.4.0

package/dist/ai/tool-approval.js

@@ -0,0 +1,407 @@
+"use strict";
+/**
+ * Tool Approval - Human-in-the-Loop Tool Execution
+ *
+ * Provides utilities for requiring human approval before tool execution.
+ * Compatible with AI SDK v6's needsApproval pattern.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DANGEROUS_PATTERNS = exports.ToolApprovalTimeoutError = exports.ToolApprovalDeniedError = exports.ApprovalManager = void 0;
+exports.getApprovalManager = getApprovalManager;
+exports.setApprovalManager = setApprovalManager;
+exports.withApproval = withApproval;
+exports.createCLIApprovalPrompt = createCLIApprovalPrompt;
+exports.isDangerous = isDangerous;
+exports.createDangerousPatternChecker = createDangerousPatternChecker;
+const events_1 = require("events");
+// ============================================================================
+// Approval Manager
+// ============================================================================
+/**
+ * Manages tool approval requests and responses.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const manager = new ApprovalManager();
+ *
+ * // Register a handler
+ * manager.onApprovalRequest(async (request) => {
+ *   console.log(`Tool ${request.toolName} wants to run with:`, request.input);
+ *   return await askUser(`Approve ${request.toolName}?`);
+ * });
+ *
+ * // Request approval
+ * const approved = await manager.requestApproval({
+ *   toolName: 'deleteFile',
+ *   input: { path: '/important/file.txt' }
+ * });
+ * ```
+ */
+class ApprovalManager extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.pendingRequests = new Map();
+        this.handlers = [];
+        this.autoApprovePatterns = [];
+        this.autoDenyPatterns = [];
+        this.defaultTimeout = options?.defaultTimeout ?? 5 * 60 * 1000; // 5 minutes
+    }
+    /**
+     * Register an approval handler.
+     */
+    onApprovalRequest(handler) {
+        this.handlers.push(handler);
+    }
+    /**
+     * Add auto-approve pattern.
+     */
+    addAutoApprove(toolName, inputPattern) {
+        this.autoApprovePatterns.push({ toolName, inputPattern });
+    }
+    /**
+     * Add auto-deny pattern.
+     */
+    addAutoDeny(toolName, inputPattern) {
+        this.autoDenyPatterns.push({ toolName, inputPattern });
+    }
+    /**
+     * Check if a tool call should be auto-approved.
+     */
+    checkAutoApprove(toolName, input) {
+        for (const pattern of this.autoApprovePatterns) {
+            const nameMatches = typeof pattern.toolName === 'string'
+                ? pattern.toolName === toolName
+                : pattern.toolName.test(toolName);
+            if (!nameMatches)
+                continue;
+            if (!pattern.inputPattern)
+                return true;
+            if (typeof pattern.inputPattern === 'function') {
+                if (pattern.inputPattern(input))
+                    return true;
+            }
+            else {
+                const inputStr = JSON.stringify(input);
+                if (pattern.inputPattern.test(inputStr))
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a tool call should be auto-denied.
+     */
+    checkAutoDeny(toolName, input) {
+        for (const pattern of this.autoDenyPatterns) {
+            const nameMatches = typeof pattern.toolName === 'string'
+                ? pattern.toolName === toolName
+                : pattern.toolName.test(toolName);
+            if (!nameMatches)
+                continue;
+            if (!pattern.inputPattern)
+                return true;
+            if (typeof pattern.inputPattern === 'function') {
+                if (pattern.inputPattern(input))
+                    return true;
+            }
+            else {
+                const inputStr = JSON.stringify(input);
+                if (pattern.inputPattern.test(inputStr))
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Request approval for a tool call.
+     */
+    async requestApproval(options) {
+        const requestId = crypto.randomUUID();
+        const toolInvocationId = options.toolInvocationId || crypto.randomUUID();
+        // Check auto-deny first (safety)
+        if (this.checkAutoDeny(options.toolName, options.input)) {
+            this.emit('auto-denied', { toolName: options.toolName, input: options.input });
+            return false;
+        }
+        // Check auto-approve
+        if (this.checkAutoApprove(options.toolName, options.input)) {
+            this.emit('auto-approved', { toolName: options.toolName, input: options.input });
+            return true;
+        }
+        const request = {
+            requestId,
+            toolInvocationId,
+            toolName: options.toolName,
+            input: options.input,
+            timestamp: Date.now(),
+            reason: options.reason,
+        };
+        // If we have handlers, use them
+        if (this.handlers.length > 0) {
+            for (const handler of this.handlers) {
+                try {
+                    const approved = await handler(request);
+                    if (approved)
+                        return true;
+                }
+                catch (error) {
+                    // Handler failed, continue to next
+                }
+            }
+            return false;
+        }
+        // Otherwise, emit event and wait for response
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                this.emit('timeout', request);
+                resolve(false); // Default to deny on timeout
+            }, options.timeout ?? this.defaultTimeout);
+            this.pendingRequests.set(requestId, {
+                request,
+                resolve,
+                reject,
+                timeout,
+            });
+            this.emit('approval-request', request);
+        });
+    }
+    /**
+     * Respond to an approval request.
+     */
+    respond(response) {
+        const pending = this.pendingRequests.get(response.requestId);
+        if (!pending) {
+            throw new Error(`No pending request with ID: ${response.requestId}`);
+        }
+        if (pending.timeout) {
+            clearTimeout(pending.timeout);
+        }
+        this.pendingRequests.delete(response.requestId);
+        this.emit('approval-response', response);
+        pending.resolve(response.approved);
+    }
+    /**
+     * Get all pending approval requests.
+     */
+    getPendingRequests() {
+        return Array.from(this.pendingRequests.values()).map(p => p.request);
+    }
+    /**
+     * Cancel a pending request.
+     */
+    cancel(requestId) {
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+            if (pending.timeout) {
+                clearTimeout(pending.timeout);
+            }
+            this.pendingRequests.delete(requestId);
+            pending.resolve(false);
+        }
+    }
+    /**
+     * Cancel all pending requests.
+     */
+    cancelAll() {
+        for (const [requestId] of this.pendingRequests) {
+            this.cancel(requestId);
+        }
+    }
+}
+exports.ApprovalManager = ApprovalManager;
+// ============================================================================
+// Global Instance
+// ============================================================================
+let globalApprovalManager = null;
+/**
+ * Get the global approval manager.
+ */
+function getApprovalManager() {
+    if (!globalApprovalManager) {
+        globalApprovalManager = new ApprovalManager();
+    }
+    return globalApprovalManager;
+}
+/**
+ * Set a custom global approval manager.
+ */
+function setApprovalManager(manager) {
+    globalApprovalManager = manager;
+}
+// ============================================================================
+// Tool Wrapper
+// ============================================================================
+/**
+ * Wrap a tool with approval requirement.
+ *
+ * @example
+ * ```typescript
+ * const deleteFile = withApproval({
+ *   name: 'deleteFile',
+ *   needsApproval: true,
+ *   execute: async (args) => {
+ *     await fs.unlink(args.path);
+ *     return { success: true };
+ *   }
+ * });
+ * ```
+ */
+function withApproval(options) {
+    const manager = options.approvalManager || getApprovalManager();
+    return async (input) => {
+        // Check if approval is needed
+        let needsApproval = false;
+        if (typeof options.needsApproval === 'function') {
+            needsApproval = await options.needsApproval(input);
+        }
+        else {
+            needsApproval = options.needsApproval ?? false;
+        }
+        if (needsApproval) {
+            const approved = await manager.requestApproval({
+                toolName: options.name,
+                input,
+                reason: options.description,
+            });
+            if (!approved) {
+                if (options.onDenied) {
+                    return options.onDenied(input);
+                }
+                throw new ToolApprovalDeniedError(options.name, input);
+            }
+        }
+        return options.execute(input);
+    };
+}
+// ============================================================================
+// Errors
+// ============================================================================
+/**
+ * Error thrown when tool approval is denied.
+ */
+class ToolApprovalDeniedError extends Error {
+    constructor(toolName, input) {
+        super(`Tool approval denied for: ${toolName}`);
+        this.name = 'ToolApprovalDeniedError';
+        this.toolName = toolName;
+        this.input = input;
+    }
+}
+exports.ToolApprovalDeniedError = ToolApprovalDeniedError;
+/**
+ * Error thrown when tool approval times out.
+ */
+class ToolApprovalTimeoutError extends Error {
+    constructor(toolName, input) {
+        super(`Tool approval timed out for: ${toolName}`);
+        this.name = 'ToolApprovalTimeoutError';
+        this.toolName = toolName;
+        this.input = input;
+    }
+}
+exports.ToolApprovalTimeoutError = ToolApprovalTimeoutError;
+// ============================================================================
+// CLI Approval Prompt
+// ============================================================================
+/**
+ * Create a CLI-based approval prompt.
+ *
+ * @example
+ * ```typescript
+ * const manager = getApprovalManager();
+ * manager.onApprovalRequest(createCLIApprovalPrompt());
+ * ```
+ */
+function createCLIApprovalPrompt(options) {
+    return async (request) => {
+        const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+        const rl = readline.createInterface({
+            input: options?.input || process.stdin,
+            output: options?.output || process.stdout,
+        });
+        const message = options?.promptMessage
+            ? options.promptMessage(request)
+            : `\n🔐 Tool "${request.toolName}" requires approval.\n` +
+                `   Input: ${JSON.stringify(request.input, null, 2)}\n` +
+                (request.reason ? `   Reason: ${request.reason}\n` : '') +
+                `\nApprove? (y/n): `;
+        return new Promise((resolve) => {
+            rl.question(message, (answer) => {
+                rl.close();
+                const approved = answer.toLowerCase().startsWith('y');
+                console.log(approved ? '✅ Approved' : '❌ Denied');
+                resolve(approved);
+            });
+        });
+    };
+}
+// ============================================================================
+// Dangerous Tool Patterns
+// ============================================================================
+/**
+ * Common dangerous patterns that should require approval.
+ */
+exports.DANGEROUS_PATTERNS = {
+    /** File deletion patterns */
+    fileDelete: /\b(rm|delete|remove|unlink)\b.*\b(file|dir|folder|path)\b/i,
+    /** Database destructive patterns */
+    dbDestructive: /\b(DROP|DELETE|TRUNCATE|ALTER)\b/i,
+    /** Shell command patterns */
+    shellDangerous: /\b(rm\s+-rf|sudo|chmod|chown|mkfs|dd\s+if=)\b/i,
+    /** Network patterns */
+    networkSensitive: /\b(curl|wget|fetch)\b.*\b(password|token|secret|key)\b/i,
+};
+/**
+ * Check if input matches any dangerous pattern.
+ */
+function isDangerous(input) {
+    const str = typeof input === 'string' ? input : JSON.stringify(input);
+    return Object.values(exports.DANGEROUS_PATTERNS).some(pattern => pattern.test(str));
+}
+/**
+ * Create a needsApproval function that checks for dangerous patterns.
+ */
+function createDangerousPatternChecker(additionalPatterns) {
+    const patterns = [
+        ...Object.values(exports.DANGEROUS_PATTERNS),
+        ...(additionalPatterns || []),
+    ];
+    return (input) => {
+        const str = typeof input === 'string' ? input : JSON.stringify(input);
+        return patterns.some(pattern => pattern.test(str));
+    };
+}

package/dist/ai/tools.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Tools - AI SDK Wrapper
+ *
+ * Provides tool definition utilities compatible with AI SDK.
+ */
+export interface ToolDefinition<TInput = unknown, TOutput = unknown> {
+    /** Tool description */
+    description: string;
+    /** Input parameters schema (Zod or JSON schema) */
+    parameters: any;
+    /** Execute function */
+    execute: ToolExecuteFunction<TInput, TOutput>;
+}
+export type ToolExecuteFunction<TInput = unknown, TOutput = unknown> = (args: TInput, options?: ToolExecutionOptions) => Promise<TOutput> | TOutput;
+export interface ToolExecutionOptions {
+    /** Tool call ID */
+    toolCallId?: string;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+    /** Messages context */
+    messages?: any[];
+}
+export type ToolInput<T extends ToolDefinition> = T extends ToolDefinition<infer I, any> ? I : never;
+export type ToolOutput<T extends ToolDefinition> = T extends ToolDefinition<any, infer O> ? O : never;
+/**
+ * Define a tool for use with AI SDK.
+ *
+ * @example With Zod schema
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const weatherTool = defineTool({
+ *   description: 'Get weather for a city',
+ *   parameters: z.object({
+ *     city: z.string().describe('City name'),
+ *     unit: z.enum(['celsius', 'fahrenheit']).optional()
+ *   }),
+ *   execute: async ({ city, unit }) => {
+ *     return { temperature: 20, unit: unit || 'celsius', city };
+ *   }
+ * });
+ * ```
+ *
+ * @example With JSON schema
+ * ```typescript
+ * const searchTool = defineTool({
+ *   description: 'Search the web',
+ *   parameters: {
+ *     type: 'object',
+ *     properties: {
+ *       query: { type: 'string', description: 'Search query' }
+ *     },
+ *     required: ['query']
+ *   },
+ *   execute: async ({ query }) => {
+ *     return { results: [`Result for: ${query}`] };
+ *   }
+ * });
+ * ```
+ */
+export declare function defineTool<TInput = unknown, TOutput = unknown>(definition: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+/**
+ * Create a tool set from multiple tool definitions.
+ *
+ * @example
+ * ```typescript
+ * const tools = createToolSet({
+ *   weather: weatherTool,
+ *   search: searchTool
+ * });
+ *
+ * const result = await generateText({
+ *   model: 'gpt-4o',
+ *   prompt: 'What is the weather in Paris?',
+ *   tools
+ * });
+ * ```
+ */
+export declare function createToolSet<T extends Record<string, ToolDefinition>>(tools: T): T;
+/**
+ * Convert a simple function to a tool definition.
+ *
+ * @example
+ * ```typescript
+ * const addTool = functionToTool(
+ *   'add',
+ *   'Add two numbers',
+ *   z.object({ a: z.number(), b: z.number() }),
+ *   ({ a, b }) => a + b
+ * );
+ * ```
+ */
+export declare function functionToTool<TInput = unknown, TOutput = unknown>(name: string, description: string, parameters: any, execute: ToolExecuteFunction<TInput, TOutput>): ToolDefinition<TInput, TOutput>;

package/dist/ai/tools.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Tools - AI SDK Wrapper
+ *
+ * Provides tool definition utilities compatible with AI SDK.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTool = defineTool;
+exports.createToolSet = createToolSet;
+exports.functionToTool = functionToTool;
+/**
+ * Define a tool for use with AI SDK.
+ *
+ * @example With Zod schema
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const weatherTool = defineTool({
+ *   description: 'Get weather for a city',
+ *   parameters: z.object({
+ *     city: z.string().describe('City name'),
+ *     unit: z.enum(['celsius', 'fahrenheit']).optional()
+ *   }),
+ *   execute: async ({ city, unit }) => {
+ *     return { temperature: 20, unit: unit || 'celsius', city };
+ *   }
+ * });
+ * ```
+ *
+ * @example With JSON schema
+ * ```typescript
+ * const searchTool = defineTool({
+ *   description: 'Search the web',
+ *   parameters: {
+ *     type: 'object',
+ *     properties: {
+ *       query: { type: 'string', description: 'Search query' }
+ *     },
+ *     required: ['query']
+ *   },
+ *   execute: async ({ query }) => {
+ *     return { results: [`Result for: ${query}`] };
+ *   }
+ * });
+ * ```
+ */
+function defineTool(definition) {
+    return definition;
+}
+/**
+ * Create a tool set from multiple tool definitions.
+ *
+ * @example
+ * ```typescript
+ * const tools = createToolSet({
+ *   weather: weatherTool,
+ *   search: searchTool
+ * });
+ *
+ * const result = await generateText({
+ *   model: 'gpt-4o',
+ *   prompt: 'What is the weather in Paris?',
+ *   tools
+ * });
+ * ```
+ */
+function createToolSet(tools) {
+    return tools;
+}
+/**
+ * Convert a simple function to a tool definition.
+ *
+ * @example
+ * ```typescript
+ * const addTool = functionToTool(
+ *   'add',
+ *   'Add two numbers',
+ *   z.object({ a: z.number(), b: z.number() }),
+ *   ({ a, b }) => a + b
+ * );
+ * ```
+ */
+function functionToTool(name, description, parameters, execute) {
+    return {
+        description,
+        parameters,
+        execute,
+    };
+}

package/dist/ai/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared Types for AI Module
+ */
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | ContentPart[];
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCallPart[];
+}
+export type ContentPart = TextPart | ImagePart | FilePart | ToolCallPart | ToolResultPart;
+export interface TextPart {
+    type: 'text';
+    text: string;
+}
+export interface ImagePart {
+    type: 'image';
+    image: string | Uint8Array | URL;
+    mimeType?: string;
+}
+export interface FilePart {
+    type: 'file';
+    data: string | Uint8Array | URL;
+    mimeType: string;
+    name?: string;
+}
+export interface ToolCallPart {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+export interface ToolResultPart {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface ProviderMetadata {
+    [key: string]: unknown;
+}

package/dist/ai/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Shared Types for AI Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });