confused-ai-core 0.1.0

package/src/tools/notion-tool.ts

@@ -0,0 +1,322 @@
+/**
+ * Notion tool implementation - TypeScript NotionTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * Notion API types
+ */
+interface NotionPage {
+    id: string;
+    url: string;
+    properties: Record<string, unknown>;
+}
+
+interface NotionSearchResult {
+    results: NotionPage[];
+}
+
+interface NotionResult {
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Base Notion tool with common authentication
+ */
+abstract class BaseNotionTool<TParams extends z.ZodObject<Record<string, z.ZodType>>> extends BaseTool<TParams, NotionResult> {
+    protected token: string;
+    protected databaseId?: string;
+    protected baseUrl = 'https://api.notion.com/v1';
+
+    constructor(
+        config: Partial<Omit<BaseToolConfig<TParams>, 'parameters'>> & {
+            token?: string;
+            databaseId?: string;
+        },
+        params: TParams
+    ) {
+        super({
+            name: config.name || 'notion.tool',
+            description: config.description || 'Notion tool',
+            parameters: params,
+            category: config.category || ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config.permissions,
+            },
+            ...config,
+        });
+
+        this.token = config.token || process.env.NOTION_API_TOKEN || '';
+        this.databaseId = config.databaseId || process.env.NOTION_DATABASE_ID;
+
+        if (!this.token) {
+            throw new Error('Notion API token is required. Set NOTION_API_TOKEN environment variable or pass token in config.');
+        }
+    }
+
+    protected async notionRequest(endpoint: string, options: RequestInit = {}): Promise<Response> {
+        return fetch(`${this.baseUrl}${endpoint}`, {
+            ...options,
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                'Notion-Version': '2022-06-28',
+                'Content-Type': 'application/json',
+                ...(options.headers || {}),
+            },
+        });
+    }
+}
+
+/**
+ * Create page tool
+ */
+const NotionCreatePageParameters = z.object({
+    parent_database_id: z.string().optional().describe('Database ID to create page in (overrides default)'),
+    title: z.string().describe('The page title'),
+    content: z.string().describe('The page content'),
+    properties: z.record(z.string(), z.unknown()).optional().describe('Additional properties for the page'),
+});
+
+export class NotionCreatePageTool extends BaseNotionTool<typeof NotionCreatePageParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof NotionCreatePageParameters>, 'parameters'>> & {
+            token?: string;
+            databaseId?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'notion.create_page',
+                description: config?.description ?? 'Create a new page in Notion',
+                ...config,
+            },
+            NotionCreatePageParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof NotionCreatePageParameters>,
+        _context: ToolContext
+    ): Promise<NotionResult> {
+        const databaseId = params.parent_database_id || this.databaseId;
+
+        if (!databaseId) {
+            return {
+                error: 'Database ID is required. Set NOTION_DATABASE_ID environment variable, pass databaseId in config, or provide parent_database_id in parameters.',
+            };
+        }
+
+        try {
+            const body: Record<string, unknown> = {
+                parent: { database_id: databaseId },
+                properties: {
+                    Name: {
+                        title: [{ text: { content: params.title } }],
+                    },
+                    ...params.properties,
+                },
+                children: [
+                    {
+                        object: 'block',
+                        type: 'paragraph',
+                        paragraph: {
+                            rich_text: [{ type: 'text', text: { content: params.content } }],
+                        },
+                    },
+                ],
+            };
+
+            const response = await this.notionRequest('/pages', {
+                method: 'POST',
+                body: JSON.stringify(body),
+            });
+
+            if (!response.ok) {
+                const errorData = (await response.json()) as { message?: string };
+                throw new Error(errorData.message || `Notion API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as NotionPage;
+
+            return {
+                data: {
+                    id: data.id,
+                    url: data.url,
+                    title: params.title,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Search pages tool
+ */
+const NotionSearchParameters = z.object({
+    query: z.string().describe('Search query string'),
+    filter: z.enum(['page', 'database']).optional().describe('Filter by type'),
+});
+
+export class NotionSearchTool extends BaseNotionTool<typeof NotionSearchParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof NotionSearchParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'notion.search',
+                description: config?.description ?? 'Search for pages and databases in Notion',
+                ...config,
+            },
+            NotionSearchParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof NotionSearchParameters>,
+        _context: ToolContext
+    ): Promise<NotionResult> {
+        try {
+            const body: Record<string, unknown> = {
+                query: params.query,
+            };
+
+            if (params.filter) {
+                body.filter = {
+                    value: params.filter,
+                    property: 'object',
+                };
+            }
+
+            const response = await this.notionRequest('/search', {
+                method: 'POST',
+                body: JSON.stringify(body),
+            });
+
+            if (!response.ok) {
+                const errorData = (await response.json()) as { message?: string };
+                throw new Error(errorData.message || `Notion API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as NotionSearchResult;
+
+            const results = data.results.map((page) => ({
+                id: page.id,
+                url: page.url,
+                object: page.properties,
+            }));
+
+            return {
+                data: {
+                    count: results.length,
+                    results,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Update page tool
+ */
+const NotionUpdatePageParameters = z.object({
+    page_id: z.string().describe('The page ID to update'),
+    content: z.string().describe('Content to append to the page'),
+});
+
+export class NotionUpdatePageTool extends BaseNotionTool<typeof NotionUpdatePageParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof NotionUpdatePageParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'notion.update_page',
+                description: config?.description ?? 'Add content to an existing Notion page',
+                ...config,
+            },
+            NotionUpdatePageParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof NotionUpdatePageParameters>,
+        _context: ToolContext
+    ): Promise<NotionResult> {
+        try {
+            const response = await this.notionRequest(`/blocks/${params.page_id}/children`, {
+                method: 'PATCH',
+                body: JSON.stringify({
+                    children: [
+                        {
+                            object: 'block',
+                            type: 'paragraph',
+                            paragraph: {
+                                rich_text: [{ type: 'text', text: { content: params.content } }],
+                            },
+                        },
+                    ],
+                }),
+            });
+
+            if (!response.ok) {
+                const errorData = (await response.json()) as { message?: string };
+                throw new Error(errorData.message || `Notion API error: ${response.status}`);
+            }
+
+            return {
+                data: {
+                    pageId: params.page_id,
+                    message: 'Content added successfully',
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Notion toolkit
+ */
+export class NotionToolkit {
+    static create(options?: {
+        token?: string;
+        databaseId?: string;
+        enableCreatePage?: boolean;
+        enableSearch?: boolean;
+        enableUpdatePage?: boolean;
+    }): Array<NotionCreatePageTool | NotionSearchTool | NotionUpdatePageTool> {
+        const tools: Array<NotionCreatePageTool | NotionSearchTool | NotionUpdatePageTool> = [];
+
+        if (options?.enableCreatePage !== false) {
+            tools.push(new NotionCreatePageTool({ token: options?.token, databaseId: options?.databaseId }));
+        }
+        if (options?.enableSearch !== false) {
+            tools.push(new NotionSearchTool({ token: options?.token }));
+        }
+        if (options?.enableUpdatePage !== false) {
+            tools.push(new NotionUpdatePageTool({ token: options?.token }));
+        }
+
+        return tools;
+    }
+}

package/src/tools/openai-tool.ts

@@ -0,0 +1,236 @@
+/**
+ * OpenAI tool implementation - TypeScript OpenAITools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * OpenAI API types
+ */
+interface OpenAIImageResponse {
+    data: Array<{
+        url?: string;
+        b64_json?: string;
+    }>;
+}
+
+interface OpenAITranscriptionResponse {
+    text: string;
+}
+
+interface OpenAIResult {
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Base OpenAI tool with common authentication
+ */
+abstract class BaseOpenAITool<TParams extends z.ZodObject<Record<string, z.ZodType>>> extends BaseTool<TParams, OpenAIResult> {
+    protected apiKey: string;
+    protected baseUrl = 'https://api.openai.com/v1';
+
+    constructor(
+        config: Partial<Omit<BaseToolConfig<TParams>, 'parameters'>> & {
+            apiKey?: string;
+        },
+        params: TParams
+    ) {
+        super({
+            name: config.name || 'openai.tool',
+            description: config.description || 'OpenAI tool',
+            parameters: params,
+            category: config.category || ToolCategory.AI,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 60000,
+                ...config.permissions,
+            },
+            ...config,
+        });
+
+        this.apiKey = config.apiKey || process.env.OPENAI_API_KEY || '';
+
+        if (!this.apiKey) {
+            throw new Error('OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.');
+        }
+    }
+
+    protected async openAIRequest(endpoint: string, options: RequestInit = {}): Promise<Response> {
+        return fetch(`${this.baseUrl}${endpoint}`, {
+            ...options,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                ...(options.headers || {}),
+            },
+        });
+    }
+}
+
+/**
+ * Generate image tool
+ */
+const OpenAIGenerateImageParameters = z.object({
+    prompt: z.string().describe('Text description of the image to generate'),
+    size: z.enum(['256x256', '512x512', '1024x1024', '1792x1024', '1024x1792']).optional().default('1024x1024'),
+    quality: z.enum(['standard', 'hd']).optional().default('standard'),
+    style: z.enum(['vivid', 'natural']).optional().default('vivid'),
+    model: z.enum(['dall-e-2', 'dall-e-3', 'gpt-image-1']).optional().default('dall-e-3'),
+});
+
+export class OpenAIGenerateImageTool extends BaseOpenAITool<typeof OpenAIGenerateImageParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof OpenAIGenerateImageParameters>, 'parameters'>> & {
+            apiKey?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'openai.generate_image',
+                description: config?.description ?? 'Generate an image using OpenAI DALL-E',
+                ...config,
+            },
+            OpenAIGenerateImageParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof OpenAIGenerateImageParameters>,
+        _context: ToolContext
+    ): Promise<OpenAIResult> {
+        try {
+            const body: Record<string, unknown> = {
+                model: params.model,
+                prompt: params.prompt,
+                n: 1,
+                size: params.size,
+            };
+
+            if (params.model === 'dall-e-3') {
+                body.quality = params.quality;
+                body.style = params.style;
+            }
+
+            const response = await this.openAIRequest('/images/generations', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+
+            if (!response.ok) {
+                const errorData = (await response.json()) as { error?: { message?: string } };
+                throw new Error(errorData.error?.message || `OpenAI API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as OpenAIImageResponse;
+            const imageData = data.data[0];
+
+            return {
+                data: {
+                    url: imageData.url,
+                    b64_json: imageData.b64_json,
+                    prompt: params.prompt,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Transcribe audio tool
+ */
+const OpenAITranscribeAudioParameters = z.object({
+    audio_url: z.string().describe('URL or path to the audio file'),
+    model: z.enum(['whisper-1']).optional().default('whisper-1'),
+    language: z.string().optional().describe('Language code (e.g., en, es)'),
+});
+
+export class OpenAITranscribeAudioTool extends BaseOpenAITool<typeof OpenAITranscribeAudioParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof OpenAITranscribeAudioParameters>, 'parameters'>> & {
+            apiKey?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'openai.transcribe_audio',
+                description: config?.description ?? 'Transcribe audio using OpenAI Whisper',
+                ...config,
+            },
+            OpenAITranscribeAudioParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof OpenAITranscribeAudioParameters>,
+        _context: ToolContext
+    ): Promise<OpenAIResult> {
+        try {
+            // For URL-based audio, we need to fetch it first
+            const audioResponse = await fetch(params.audio_url);
+            if (!audioResponse.ok) {
+                throw new Error(`Failed to fetch audio: ${audioResponse.status}`);
+            }
+
+            const audioBlob = await audioResponse.blob();
+            const formData = new FormData();
+            formData.append('file', audioBlob, 'audio.mp3');
+            formData.append('model', params.model);
+            if (params.language) {
+                formData.append('language', params.language);
+            }
+
+            const response = await this.openAIRequest('/audio/transcriptions', {
+                method: 'POST',
+                body: formData,
+            });
+
+            if (!response.ok) {
+                const errorData = (await response.json()) as { error?: { message?: string } };
+                throw new Error(errorData.error?.message || `OpenAI API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as OpenAITranscriptionResponse;
+
+            return {
+                data: {
+                    text: data.text,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * OpenAI toolkit
+ */
+export class OpenAIToolkit {
+    static create(options?: {
+        apiKey?: string;
+        enableImageGeneration?: boolean;
+        enableTranscription?: boolean;
+    }): Array<OpenAIGenerateImageTool | OpenAITranscribeAudioTool> {
+        const tools: Array<OpenAIGenerateImageTool | OpenAITranscribeAudioTool> = [];
+
+        if (options?.enableImageGeneration !== false) {
+            tools.push(new OpenAIGenerateImageTool({ apiKey: options?.apiKey }));
+        }
+        if (options?.enableTranscription !== false) {
+            tools.push(new OpenAITranscribeAudioTool({ apiKey: options?.apiKey }));
+        }
+
+        return tools;
+    }
+}

package/src/tools/registry.ts

@@ -0,0 +1,131 @@
+/**
+ * Tool registry implementation and tool provider helpers.
+ */
+
+import { ToolRegistry, Tool, ToolCategory } from './types.js';
+import type { EntityId } from '../core/types.js';
+
+/** Pass an array or registry when configuring agents. */
+export type ToolProvider = Tool[] | ToolRegistry;
+
+/** Normalize tools to a ToolRegistry (extensible: plug any tools). */
+export function toToolRegistry(tools: ToolProvider): ToolRegistry {
+    if (Array.isArray(tools)) {
+        const reg = new ToolRegistryImpl();
+        for (const t of tools) reg.register(t);
+        return reg;
+    }
+    return tools;
+}
+
+/**
+ * Implementation of ToolRegistry
+ */
+export class ToolRegistryImpl implements ToolRegistry {
+    private tools: Map<EntityId, Tool> = new Map();
+    private nameIndex: Map<string, EntityId> = new Map();
+
+    /**
+     * Register a tool
+     */
+    register(tool: Tool): void {
+        if (this.tools.has(tool.id)) {
+            throw new Error(`Tool with ID ${tool.id} is already registered`);
+        }
+
+        if (this.nameIndex.has(tool.name)) {
+            throw new Error(`Tool with name ${tool.name} is already registered`);
+        }
+
+        this.tools.set(tool.id, tool);
+        this.nameIndex.set(tool.name, tool.id);
+    }
+
+    /**
+     * Unregister a tool by ID
+     */
+    unregister(toolId: EntityId): boolean {
+        const tool = this.tools.get(toolId);
+        if (!tool) {
+            return false;
+        }
+
+        this.tools.delete(toolId);
+        this.nameIndex.delete(tool.name);
+        return true;
+    }
+
+    /**
+     * Get a tool by ID
+     */
+    get(toolId: EntityId): Tool | undefined {
+        return this.tools.get(toolId);
+    }
+
+    /**
+     * Get a tool by name
+     */
+    getByName(name: string): Tool | undefined {
+        const id = this.nameIndex.get(name);
+        if (!id) {
+            return undefined;
+        }
+        return this.tools.get(id);
+    }
+
+    /**
+     * List all registered tools
+     */
+    list(): Tool[] {
+        return Array.from(this.tools.values());
+    }
+
+    /**
+     * List tools by category
+     */
+    listByCategory(category: ToolCategory): Tool[] {
+        return this.list().filter(tool => tool.category === category);
+    }
+
+    /**
+     * Search tools by name or description
+     */
+    search(query: string): Tool[] {
+        const lowerQuery = query.toLowerCase();
+        return this.list().filter(
+            tool =>
+                tool.name.toLowerCase().includes(lowerQuery) ||
+                tool.description.toLowerCase().includes(lowerQuery) ||
+                (tool.tags?.some(tag => tag.toLowerCase().includes(lowerQuery)) ?? false)
+        );
+    }
+
+    /**
+     * Check if a tool is registered
+     */
+    has(toolId: EntityId): boolean {
+        return this.tools.has(toolId);
+    }
+
+    /**
+     * Check if a tool name is registered
+     */
+    hasName(name: string): boolean {
+        return this.nameIndex.has(name);
+    }
+
+    /**
+     * Clear all registered tools
+     */
+    clear(): void {
+        this.tools.clear();
+        this.nameIndex.clear();
+    }
+
+    /**
+     * Get the number of registered tools
+     */
+    size(): number {
+        return this.tools.size;
+    }
+}