confused-ai-core 0.1.0

package/src/tools/wikipedia-tool.ts

@@ -0,0 +1,177 @@
+/**
+ * Wikipedia tool implementation - TypeScript  WikipediaTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * Wikipedia API response types
+ */
+interface WikipediaSummaryResponse {
+    title?: string;
+    extract?: string;
+    content_urls?: {
+        desktop?: {
+            page?: string;
+        };
+    };
+}
+
+interface WikipediaSearchResult {
+    title: string;
+    snippet: string;
+}
+
+interface WikipediaSearchResponse {
+    query?: {
+        search?: WikipediaSearchResult[];
+    };
+}
+
+/**
+ * Wikipedia search result
+ */
+interface WikipediaResult {
+    title: string;
+    content: string;
+    url: string;
+    error?: string;
+}
+
+/**
+ * Parameters for Wikipedia search
+ */
+const WikipediaSearchParameters = z.object({
+    query: z.string().describe('The topic or query to search for on Wikipedia'),
+});
+
+/**
+ * Wikipedia search tool
+ */
+export class WikipediaSearchTool extends BaseTool<typeof WikipediaSearchParameters, WikipediaResult> {
+    constructor(config?: Partial<Omit<BaseToolConfig<typeof WikipediaSearchParameters>, 'parameters'>>) {
+        super({
+            name: config?.name ?? 'wikipedia.search',
+            description: config?.description ?? 'Search Wikipedia for a topic and get a summary',
+            parameters: WikipediaSearchParameters,
+            category: config?.category ?? ToolCategory.WEB,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof WikipediaSearchParameters>,
+        _context: ToolContext
+    ): Promise<WikipediaResult> {
+        try {
+            // Use Wikipedia's REST API
+            const searchUrl = `https://en.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(params.query.replace(/\s+/g, '_'))}`;
+
+            const response = await fetch(searchUrl, {
+                headers: {
+                    'User-Agent': 'AgentFramework/1.0 (https://github.com/agent-framework)',
+                },
+            });
+
+            if (!response.ok) {
+                // Try searching for the page first
+                return this.searchAndGetSummary(params.query);
+            }
+
+            const data = (await response.json()) as WikipediaSummaryResponse;
+
+            return {
+                title: data.title || params.query,
+                content: data.extract || 'No summary available',
+                url: data.content_urls?.desktop?.page || `https://en.wikipedia.org/wiki/${encodeURIComponent(params.query.replace(/\s+/g, '_'))}`,
+            };
+        } catch (error) {
+            return {
+                title: params.query,
+                content: '',
+                url: '',
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+
+    private async searchAndGetSummary(query: string): Promise<WikipediaResult> {
+        try {
+            // Search for the page
+            const searchUrl = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json&origin=*`;
+
+            const searchResponse = await fetch(searchUrl, {
+                headers: {
+                    'User-Agent': 'AgentFramework/1.0 (https://github.com/agent-framework)',
+                },
+            });
+
+            if (!searchResponse.ok) {
+                throw new Error(`Wikipedia search failed: ${searchResponse.status}`);
+            }
+
+            const searchData = (await searchResponse.json()) as WikipediaSearchResponse;
+            const searchResults = searchData.query?.search || [];
+
+            if (searchResults.length === 0) {
+                return {
+                    title: query,
+                    content: 'No results found on Wikipedia',
+                    url: '',
+                };
+            }
+
+            // Get the first result's title and fetch its summary
+            const firstResult = searchResults[0];
+            const pageTitle = firstResult.title;
+
+            const summaryUrl = `https://en.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(pageTitle.replace(/\s+/g, '_'))}`;
+
+            const summaryResponse = await fetch(summaryUrl, {
+                headers: {
+                    'User-Agent': 'AgentFramework/1.0 (https://github.com/agent-framework)',
+                },
+            });
+
+            if (!summaryResponse.ok) {
+                // Return the search snippet if summary fails
+                return {
+                    title: pageTitle,
+                    content: firstResult.snippet.replace(/<[^>]*>/g, ''),
+                    url: `https://en.wikipedia.org/wiki/${encodeURIComponent(pageTitle.replace(/\s+/g, '_'))}`,
+                };
+            }
+
+            const summaryData = (await summaryResponse.json()) as WikipediaSummaryResponse;
+
+            return {
+                title: summaryData.title || pageTitle,
+                content: summaryData.extract || firstResult.snippet.replace(/<[^>]*>/g, ''),
+                url: summaryData.content_urls?.desktop?.page || `https://en.wikipedia.org/wiki/${encodeURIComponent(pageTitle.replace(/\s+/g, '_'))}`,
+            };
+        } catch (error) {
+            return {
+                title: query,
+                content: '',
+                url: '',
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Wikipedia toolkit
+ */
+export class WikipediaToolkit {
+    static create(): Array<WikipediaSearchTool> {
+        return [new WikipediaSearchTool()];
+    }
+}

package/src/tools/yfinance-tool.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import yahooFinance from 'yahoo-finance2';
+import { BaseTool } from './base-tool.js';
+import { ToolCategory, ToolContext } from './types.js';
+
+const YFinanceParameters = z.object({
+    symbol: z.string().describe('The stock symbol (e.g., AAPL)'),
+});
+
+type YFinanceParameters = z.infer<typeof YFinanceParameters>;
+
+export class YFinanceTool extends BaseTool<typeof YFinanceParameters, unknown> {
+    constructor() {
+        super({
+            name: 'yfinance_stock',
+            description: 'Fetch real-time stock quote data using Yahoo Finance',
+            parameters: YFinanceParameters,
+            category: ToolCategory.WEB,
+            permissions: {
+                allowNetwork: true,
+                allowFileSystem: false,
+                maxExecutionTimeMs: 30000,
+            },
+        });
+    }
+
+    protected async performExecute(
+        params: YFinanceParameters,
+        _context: ToolContext
+    ): Promise<unknown> {
+        return await yahooFinance.quote(params.symbol);
+    }
+}

package/src/voice/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Voice Module Exports
+ */
+
+export {
+    OpenAIVoiceProvider,
+    ElevenLabsVoiceProvider,
+    createVoiceProvider,
+} from './voice-provider.js';
+
+export type {
+    VoiceConfig,
+    VoiceProvider,
+    TTSResult,
+    STTResult,
+    OpenAIVoice,
+} from './voice-provider.js';

package/src/voice/voice-provider.ts

@@ -0,0 +1,228 @@
+/**
+ * Voice Provider - VoltAgent-Style TTS/STT Support
+ *
+ * Text-to-speech and speech-to-text capabilities:
+ * - OpenAI voice support
+ * - ElevenLabs integration
+ * - Custom voice provider interface
+ */
+
+/** Voice configuration */
+export interface VoiceConfig {
+    /** Voice provider type */
+    readonly provider: 'openai' | 'elevenlabs' | 'custom';
+    /** Voice ID */
+    readonly voiceId?: string;
+    /** Model for TTS */
+    readonly model?: string;
+    /** Speed (0.25 to 4.0) */
+    readonly speed?: number;
+    /** API key (if not in env) */
+    readonly apiKey?: string;
+}
+
+/** TTS result */
+export interface TTSResult {
+    /** Audio data as ArrayBuffer */
+    readonly audio: ArrayBuffer;
+    /** Audio format */
+    readonly format: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+    /** Duration in seconds */
+    readonly durationSeconds?: number;
+    /** Character count */
+    readonly characterCount: number;
+}
+
+/** STT result */
+export interface STTResult {
+    /** Transcribed text */
+    readonly text: string;
+    /** Language detected */
+    readonly language?: string;
+    /** Confidence score (0-1) */
+    readonly confidence?: number;
+    /** Duration of audio in seconds */
+    readonly durationSeconds?: number;
+}
+
+/** Voice provider interface */
+export interface VoiceProvider {
+    /** Text-to-speech */
+    textToSpeech(text: string, options?: Partial<VoiceConfig>): Promise<TTSResult>;
+
+    /** Speech-to-text */
+    speechToText?(audio: ArrayBuffer | Blob, options?: { language?: string }): Promise<STTResult>;
+
+    /** List available voices */
+    listVoices?(): Promise<Array<{ id: string; name: string; preview_url?: string }>>;
+}
+
+/** OpenAI voice IDs */
+export type OpenAIVoice = 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+
+/**
+ * OpenAI Voice Provider
+ *
+ * @example
+ * const voice = new OpenAIVoiceProvider();
+ * const audio = await voice.textToSpeech('Hello, world!', { voiceId: 'nova' });
+ */
+export class OpenAIVoiceProvider implements VoiceProvider {
+    private readonly apiKey: string;
+    private readonly baseUrl: string;
+
+    constructor(config?: { apiKey?: string; baseUrl?: string }) {
+        this.apiKey = config?.apiKey ?? process.env.OPENAI_API_KEY ?? '';
+        this.baseUrl = config?.baseUrl ?? 'https://api.openai.com/v1';
+
+        if (!this.apiKey) {
+            throw new Error('OpenAI API key required for voice provider');
+        }
+    }
+
+    async textToSpeech(text: string, options?: Partial<VoiceConfig>): Promise<TTSResult> {
+        const voice = (options?.voiceId ?? 'alloy') as OpenAIVoice;
+        const model = options?.model ?? 'tts-1';
+        const speed = options?.speed ?? 1.0;
+
+        const response = await fetch(`${this.baseUrl}/audio/speech`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                input: text,
+                voice,
+                speed,
+                response_format: 'mp3',
+            }),
+        });
+
+        if (!response.ok) {
+            throw new Error(`OpenAI TTS failed: ${response.status} ${await response.text()}`);
+        }
+
+        const audio = await response.arrayBuffer();
+
+        return {
+            audio,
+            format: 'mp3',
+            characterCount: text.length,
+        };
+    }
+
+    async speechToText(audio: ArrayBuffer | Blob, options?: { language?: string }): Promise<STTResult> {
+        const formData = new FormData();
+
+        const blob = audio instanceof Blob ? audio : new Blob([audio], { type: 'audio/wav' });
+        formData.append('file', blob, 'audio.wav');
+        formData.append('model', 'whisper-1');
+
+        if (options?.language) {
+            formData.append('language', options.language);
+        }
+
+        const response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+            body: formData,
+        });
+
+        if (!response.ok) {
+            throw new Error(`OpenAI STT failed: ${response.status} ${await response.text()}`);
+        }
+
+        const result = await response.json() as { text: string; language?: string };
+
+        return {
+            text: result.text,
+            language: result.language,
+        };
+    }
+
+    async listVoices(): Promise<Array<{ id: string; name: string }>> {
+        return [
+            { id: 'alloy', name: 'Alloy' },
+            { id: 'echo', name: 'Echo' },
+            { id: 'fable', name: 'Fable' },
+            { id: 'onyx', name: 'Onyx' },
+            { id: 'nova', name: 'Nova' },
+            { id: 'shimmer', name: 'Shimmer' },
+        ];
+    }
+}
+
+/**
+ * ElevenLabs Voice Provider (stub - requires implementation)
+ */
+export class ElevenLabsVoiceProvider implements VoiceProvider {
+    private readonly apiKey: string;
+    private readonly baseUrl = 'https://api.elevenlabs.io/v1';
+
+    constructor(config?: { apiKey?: string }) {
+        this.apiKey = config?.apiKey ?? process.env.ELEVENLABS_API_KEY ?? '';
+    }
+
+    async textToSpeech(text: string, options?: Partial<VoiceConfig>): Promise<TTSResult> {
+        const voiceId = options?.voiceId ?? '21m00Tcm4TlvDq8ikWAM'; // Rachel
+
+        const response = await fetch(`${this.baseUrl}/text-to-speech/${voiceId}`, {
+            method: 'POST',
+            headers: {
+                'xi-api-key': this.apiKey,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                text,
+                model_id: options?.model ?? 'eleven_monolingual_v1',
+            }),
+        });
+
+        if (!response.ok) {
+            throw new Error(`ElevenLabs TTS failed: ${response.status}`);
+        }
+
+        const audio = await response.arrayBuffer();
+
+        return {
+            audio,
+            format: 'mp3',
+            characterCount: text.length,
+        };
+    }
+
+    async listVoices(): Promise<Array<{ id: string; name: string; preview_url?: string }>> {
+        const response = await fetch(`${this.baseUrl}/voices`, {
+            headers: { 'xi-api-key': this.apiKey },
+        });
+
+        if (!response.ok) {
+            throw new Error(`ElevenLabs list voices failed: ${response.status}`);
+        }
+
+        const data = await response.json() as { voices: Array<{ voice_id: string; name: string; preview_url?: string }> };
+        return data.voices.map((v) => ({
+            id: v.voice_id,
+            name: v.name,
+            preview_url: v.preview_url,
+        }));
+    }
+}
+
+/**
+ * Create a voice provider based on configuration
+ */
+export function createVoiceProvider(config: VoiceConfig): VoiceProvider {
+    switch (config.provider) {
+        case 'openai':
+            return new OpenAIVoiceProvider({ apiKey: config.apiKey });
+        case 'elevenlabs':
+            return new ElevenLabsVoiceProvider({ apiKey: config.apiKey });
+        default:
+            throw new Error(`Unknown voice provider: ${config.provider}`);
+    }
+}

package/tests/artifact.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Artifact System Unit Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+    InMemoryArtifactStorage,
+    createTextArtifact,
+    createMarkdownArtifact,
+    createDataArtifact,
+    createReasoningArtifact,
+    createPlanArtifact,
+} from '../src/artifacts/artifact.js';
+import type { ArtifactStorage } from '../src/artifacts/artifact.js';
+
+describe('InMemoryArtifactStorage', () => {
+    let storage: ArtifactStorage;
+
+    beforeEach(() => {
+        storage = new InMemoryArtifactStorage();
+    });
+
+    describe('save', () => {
+        it('should save an artifact and return with generated ID', async () => {
+            const artifact = createTextArtifact('test.txt', 'Hello, World!');
+            const saved = await storage.save(artifact);
+
+            expect(saved.id).toBeDefined();
+            expect(saved.id).toMatch(/^art_/);
+            expect(saved.name).toBe('test.txt');
+            expect(saved.content).toBe('Hello, World!');
+            expect(saved.version).toBe(1);
+            expect(saved.createdAt).toBeInstanceOf(Date);
+        });
+    });
+
+    describe('get', () => {
+        it('should retrieve a saved artifact', async () => {
+            const artifact = createTextArtifact('test.txt', 'content');
+            const saved = await storage.save(artifact);
+
+            const retrieved = await storage.get(saved.id);
+
+            expect(retrieved).not.toBeNull();
+            expect(retrieved?.id).toBe(saved.id);
+            expect(retrieved?.content).toBe('content');
+        });
+
+        it('should return null for non-existent artifact', async () => {
+            const retrieved = await storage.get('non-existent');
+            expect(retrieved).toBeNull();
+        });
+    });
+
+    describe('update', () => {
+        it('should update an artifact with new version', async () => {
+            const artifact = createTextArtifact('test.txt', 'v1');
+            const saved = await storage.save(artifact);
+
+            const updated = await storage.update(saved.id, { content: 'v2' });
+
+            expect(updated.version).toBe(2);
+            expect(updated.content).toBe('v2');
+        });
+
+        it('should throw for non-existent artifact', async () => {
+            await expect(
+                storage.update('non-existent', { content: 'test' })
+            ).rejects.toThrow('Artifact not found');
+        });
+    });
+
+    describe('versioning', () => {
+        it('should list all versions of an artifact', async () => {
+            const artifact = createTextArtifact('test.txt', 'v1');
+            const saved = await storage.save(artifact);
+            await storage.update(saved.id, { content: 'v2' });
+            await storage.update(saved.id, { content: 'v3' });
+
+            const versions = await storage.listVersions(saved.id);
+
+            expect(versions).toHaveLength(3);
+            expect(versions[0].version).toBe(1);
+            expect(versions[2].version).toBe(3);
+        });
+
+        it('should get a specific version', async () => {
+            const artifact = createTextArtifact('test.txt', 'v1');
+            const saved = await storage.save(artifact);
+            await storage.update(saved.id, { content: 'v2' });
+
+            const v1 = await storage.getVersion(saved.id, 1);
+            const v2 = await storage.getVersion(saved.id, 2);
+
+            expect(v1?.content).toBe('v1');
+            expect(v2?.content).toBe('v2');
+        });
+    });
+
+    describe('delete', () => {
+        it('should delete an artifact', async () => {
+            const artifact = createTextArtifact('test.txt', 'content');
+            const saved = await storage.save(artifact);
+
+            const deleted = await storage.delete(saved.id);
+            const retrieved = await storage.get(saved.id);
+
+            expect(deleted).toBe(true);
+            expect(retrieved).toBeNull();
+        });
+
+        it('should return false for non-existent artifact', async () => {
+            const deleted = await storage.delete('non-existent');
+            expect(deleted).toBe(false);
+        });
+    });
+
+    describe('list', () => {
+        it('should list all artifacts', async () => {
+            await storage.save(createTextArtifact('a.txt', 'a'));
+            await storage.save(createTextArtifact('b.txt', 'b'));
+
+            const list = await storage.list();
+
+            expect(list).toHaveLength(2);
+        });
+
+        it('should filter by type', async () => {
+            await storage.save(createTextArtifact('file.txt', 'text'));
+            await storage.save(createMarkdownArtifact('doc.md', '# Heading'));
+
+            const markdownOnly = await storage.list({ type: 'markdown' });
+
+            expect(markdownOnly).toHaveLength(1);
+            expect(markdownOnly[0].type).toBe('markdown');
+        });
+
+        it('should filter by tags', async () => {
+            await storage.save(createTextArtifact('a.txt', 'a', { tags: ['project-a'] }));
+            await storage.save(createTextArtifact('b.txt', 'b', { tags: ['project-b'] }));
+
+            const projectA = await storage.list({ tags: ['project-a'] });
+
+            expect(projectA).toHaveLength(1);
+            expect(projectA[0].name).toBe('a.txt');
+        });
+
+        it('should support pagination', async () => {
+            await storage.save(createTextArtifact('1.txt', '1'));
+            await storage.save(createTextArtifact('2.txt', '2'));
+            await storage.save(createTextArtifact('3.txt', '3'));
+
+            const page1 = await storage.list({ limit: 2, offset: 0 });
+            const page2 = await storage.list({ limit: 2, offset: 2 });
+
+            expect(page1).toHaveLength(2);
+            expect(page2).toHaveLength(1);
+        });
+    });
+
+    describe('search', () => {
+        it('should search artifacts by name', async () => {
+            await storage.save(createTextArtifact('report-2024.txt', 'content'));
+            await storage.save(createTextArtifact('notes.txt', 'content'));
+
+            const results = await storage.search('report');
+
+            expect(results).toHaveLength(1);
+            expect(results[0].name).toBe('report-2024.txt');
+        });
+    });
+});
+
+describe('Artifact Helpers', () => {
+    describe('createTextArtifact', () => {
+        it('should create a text artifact', () => {
+            const artifact = createTextArtifact('file.txt', 'content');
+
+            expect(artifact.name).toBe('file.txt');
+            expect(artifact.type).toBe('file');
+            expect(artifact.content).toBe('content');
+            expect(artifact.mimeType).toBe('text/plain');
+        });
+    });
+
+    describe('createMarkdownArtifact', () => {
+        it('should create a markdown artifact', () => {
+            const artifact = createMarkdownArtifact('doc.md', '# Title');
+
+            expect(artifact.type).toBe('markdown');
+            expect(artifact.mimeType).toBe('text/markdown');
+        });
+    });
+
+    describe('createDataArtifact', () => {
+        it('should create a JSON data artifact', () => {
+            const data = { key: 'value', count: 42 };
+            const artifact = createDataArtifact('data.json', data);
+
+            expect(artifact.type).toBe('data');
+            expect(artifact.content).toEqual(data);
+            expect(artifact.mimeType).toBe('application/json');
+        });
+    });
+
+    describe('createReasoningArtifact', () => {
+        it('should create a reasoning artifact', () => {
+            const artifact = createReasoningArtifact(
+                'analysis',
+                ['First thought', 'Second thought'],
+                'Final conclusion',
+                0.85
+            );
+
+            expect(artifact.type).toBe('reasoning');
+            expect(artifact.content.thoughts).toHaveLength(2);
+            expect(artifact.content.conclusion).toBe('Final conclusion');
+            expect(artifact.content.confidence).toBe(0.85);
+        });
+    });
+
+    describe('createPlanArtifact', () => {
+        it('should create a plan artifact with steps', () => {
+            const artifact = createPlanArtifact(
+                'project-plan',
+                'Build a feature',
+                [
+                    { description: 'Research requirements' },
+                    { description: 'Implement solution' },
+                    { description: 'Test and deploy' },
+                ]
+            );
+
+            expect(artifact.type).toBe('plan');
+            expect(artifact.content.goal).toBe('Build a feature');
+            expect(artifact.content.steps).toHaveLength(3);
+            expect(artifact.content.steps[0].status).toBe('pending');
+            expect(artifact.content.status).toBe('draft');
+        });
+    });
+});