digital-workers 2.1.3 → 2.4.0

package/src/do.js

@@ -1,227 +0,0 @@
-/**
- * Task execution functionality for digital workers
- */
-import { define } from 'ai-functions';
-/**
- * Execute a task
- *
- * Routes tasks to appropriate workers (AI or human) based on complexity
- * and requirements. Handles retries, timeouts, and background execution.
- *
- * @param task - Description of the task to execute
- * @param options - Execution options (retries, timeout, background, etc.)
- * @returns Promise resolving to task result
- *
- * @example
- * ```ts
- * // Execute a simple task
- * const result = await do('Generate monthly sales report', {
- *   timeout: 60000, // 1 minute
- *   context: {
- *     month: 'January',
- *     year: 2024,
- *   },
- * })
- *
- * if (result.success) {
- *   console.log('Report:', result.result)
- * }
- * ```
- *
- * @example
- * ```ts
- * // Execute with retries
- * const result = await do('Sync data to backup server', {
- *   maxRetries: 3,
- *   timeout: 30000,
- *   context: {
- *     source: 'primary-db',
- *     destination: 'backup-db',
- *   },
- * })
- * ```
- *
- * @example
- * ```ts
- * // Execute in background
- * const result = await do('Process large dataset', {
- *   background: true,
- *   context: {
- *     dataset: 'customer_transactions.csv',
- *     outputFormat: 'parquet',
- *   },
- * })
- * ```
- */
-export async function doTask(task, options = {}) {
-    const { maxRetries = 0, timeout, background = false, context, } = options;
-    const startTime = Date.now();
-    const steps = [];
-    // Use agentic function for complex tasks
-    const taskFn = define.agentic({
-        name: 'executeTask',
-        description: 'Execute a task using available tools and capabilities',
-        args: {
-            task: 'Description of the task to execute',
-            contextInfo: 'Additional context and parameters for the task',
-        },
-        returnType: {
-            result: 'The result of executing the task',
-            steps: ['List of steps taken to complete the task'],
-        },
-        instructions: `Execute the following task:
-
-${task}
-
-${context ? `Context: ${JSON.stringify(context, null, 2)}` : ''}
-
-Work step-by-step to complete the task. Use available tools as needed.
-Document each step you take for transparency.`,
-        maxIterations: 10,
-        tools: [], // Tools would be provided by the execution environment
-    });
-    let retries = 0;
-    let lastError;
-    while (retries <= maxRetries) {
-        try {
-            const response = await Promise.race([
-                taskFn.call({ task, contextInfo: context ? JSON.stringify(context) : '' }),
-                timeout
-                    ? new Promise((_, reject) => setTimeout(() => reject(new Error('Task timeout')), timeout))
-                    : new Promise(() => { }), // Never resolves if no timeout
-            ]);
-            const typedResponse = response;
-            // Track steps if provided
-            if (typedResponse.steps) {
-                steps.push(...typedResponse.steps.map((step) => ({
-                    ...step,
-                    timestamp: new Date(),
-                })));
-            }
-            const duration = Date.now() - startTime;
-            return {
-                result: typedResponse.result,
-                success: true,
-                duration,
-                steps,
-            };
-        }
-        catch (error) {
-            lastError = error;
-            retries++;
-            if (retries <= maxRetries) {
-                steps.push({
-                    action: `Retry attempt ${retries}`,
-                    result: { error: lastError.message },
-                    timestamp: new Date(),
-                });
-                // Exponential backoff
-                await new Promise((resolve) => setTimeout(resolve, Math.pow(2, retries) * 1000));
-            }
-        }
-    }
-    const duration = Date.now() - startTime;
-    return {
-        result: undefined,
-        success: false,
-        error: lastError?.message || 'Task failed',
-        duration,
-        steps,
-    };
-}
-// Export as 'do' with proper typing
-export { doTask as do };
-/**
- * Execute multiple tasks in parallel
- *
- * @param tasks - Array of tasks to execute
- * @param options - Execution options
- * @returns Promise resolving to array of task results
- *
- * @example
- * ```ts
- * const results = await do.parallel([
- *   'Generate sales report',
- *   'Generate marketing report',
- *   'Generate finance report',
- * ], {
- *   timeout: 60000,
- * })
- *
- * const successful = results.filter(r => r.success)
- * console.log(`Completed ${successful.length} of ${results.length} tasks`)
- * ```
- */
-doTask.parallel = async (tasks, options = {}) => {
-    return Promise.all(tasks.map((task) => doTask(task, options)));
-};
-/**
- * Execute tasks in sequence
- *
- * @param tasks - Array of tasks to execute sequentially
- * @param options - Execution options
- * @returns Promise resolving to array of task results
- *
- * @example
- * ```ts
- * const results = await do.sequence([
- *   'Backup database',
- *   'Run migrations',
- *   'Restart application',
- * ], {
- *   maxRetries: 1,
- * })
- * ```
- */
-doTask.sequence = async (tasks, options = {}) => {
-    const results = [];
-    for (const task of tasks) {
-        const result = await doTask(task, options);
-        results.push(result);
-        // Stop if a task fails (unless we're continuing on error)
-        if (!result.success && !options.context?.continueOnError) {
-            break;
-        }
-    }
-    return results;
-};
-/**
- * Execute a task with specific dependencies
- *
- * @param task - The task to execute
- * @param dependencies - Tasks that must complete first
- * @param options - Execution options
- * @returns Promise resolving to task result
- *
- * @example
- * ```ts
- * const result = await do.withDependencies(
- *   'Deploy application',
- *   ['Run tests', 'Build artifacts', 'Get approval'],
- *   { maxRetries: 1 }
- * )
- * ```
- */
-doTask.withDependencies = async (task, dependencies, options = {}) => {
-    // Execute dependencies in sequence
-    const depResults = await doTask.sequence(dependencies, options);
-    // Check if all dependencies succeeded
-    const allSuccessful = depResults.every((r) => r.success);
-    if (!allSuccessful) {
-        const failed = depResults.filter((r) => !r.success);
-        return {
-            result: undefined,
-            success: false,
-            error: `Dependencies failed: ${failed.map((r) => r.error).join(', ')}`,
-            duration: 0,
-        };
-    }
-    // Execute main task with dependency results as context
-    return doTask(task, {
-        ...options,
-        context: {
-            ...options.context,
-            dependencies: depResults.map((r) => r.result),
-        },
-    });
-};

package/src/generate.js

@@ -1,298 +0,0 @@
-/**
- * Content generation functionality for digital workers
- */
-import { generateObject, generateText } from 'ai-functions';
-/**
- * Generate content
- *
- * Uses AI to generate various types of content including text,
- * code, structured data, images, video, and audio.
- *
- * @param prompt - What to generate
- * @param options - Generation options
- * @returns Promise resolving to generated content
- *
- * @example
- * ```ts
- * // Generate text content
- * const result = await generate('Write a product description for wireless earbuds', {
- *   type: 'text',
- *   instructions: 'Focus on sound quality and battery life. Keep it under 100 words.',
- * })
- * console.log(result.content)
- * ```
- *
- * @example
- * ```ts
- * // Generate structured data
- * const result = await generate('Create a user profile', {
- *   type: 'structured',
- *   schema: {
- *     name: 'User full name',
- *     email: 'Email address',
- *     role: 'admin | user | guest',
- *     preferences: {
- *       theme: 'light | dark',
- *       notifications: 'Whether to receive notifications (boolean)',
- *     },
- *   },
- * })
- * console.log(result.content) // { name: '...', email: '...', ... }
- * ```
- *
- * @example
- * ```ts
- * // Generate code
- * const result = await generate('Create a React component for a todo list', {
- *   type: 'code',
- *   instructions: 'Use TypeScript and hooks. Include prop types.',
- * })
- * console.log(result.content) // TypeScript React component code
- * ```
- */
-export async function generate(prompt, options = {}) {
-    const { type = 'text', schema, instructions, model = 'sonnet', } = options;
-    const startTime = Date.now();
-    switch (type) {
-        case 'text': {
-            const systemPrompt = instructions
-                ? `You are an expert content generator. ${instructions}`
-                : 'You are an expert content generator.';
-            const result = await generateText({
-                model,
-                prompt,
-                system: systemPrompt,
-            });
-            return {
-                content: result.text,
-                type: 'text',
-                metadata: {
-                    model,
-                    tokens: result.usage?.totalTokens,
-                    duration: Date.now() - startTime,
-                },
-            };
-        }
-        case 'structured': {
-            if (!schema) {
-                throw new Error('Schema is required for structured content generation');
-            }
-            const systemPrompt = instructions
-                ? `You are an expert at generating structured data. ${instructions}`
-                : 'You are an expert at generating structured data.';
-            const result = await generateObject({
-                model,
-                schema,
-                prompt,
-                system: systemPrompt,
-            });
-            return {
-                content: result.object,
-                type: 'structured',
-                metadata: {
-                    model,
-                    tokens: result.usage?.totalTokens,
-                    duration: Date.now() - startTime,
-                },
-            };
-        }
-        case 'code': {
-            const systemPrompt = instructions
-                ? `You are an expert programmer. Generate clean, well-documented code. ${instructions}`
-                : 'You are an expert programmer. Generate clean, well-documented code.';
-            const result = await generateObject({
-                model,
-                schema: {
-                    code: 'The generated code',
-                    language: 'Programming language used',
-                    explanation: 'Brief explanation of the code',
-                },
-                prompt,
-                system: systemPrompt,
-            });
-            const codeResult = result.object;
-            return {
-                content: codeResult.code,
-                type: 'code',
-                metadata: {
-                    model,
-                    tokens: result.usage?.totalTokens,
-                    duration: Date.now() - startTime,
-                    language: codeResult.language,
-                    explanation: codeResult.explanation,
-                },
-            };
-        }
-        case 'image': {
-            // Image generation would integrate with image generation APIs
-            // For now, return a placeholder
-            throw new Error('Image generation not yet implemented');
-        }
-        case 'video': {
-            // Video generation would integrate with video generation APIs
-            throw new Error('Video generation not yet implemented');
-        }
-        case 'audio': {
-            // Audio generation would integrate with audio generation APIs
-            throw new Error('Audio generation not yet implemented');
-        }
-        default:
-            throw new Error(`Unknown content type: ${type}`);
-    }
-}
-/**
- * Generate multiple variations of content
- *
- * @param prompt - What to generate
- * @param count - Number of variations to generate
- * @param options - Generation options
- * @returns Promise resolving to array of generated content
- *
- * @example
- * ```ts
- * const variations = await generate.variations(
- *   'Write a catchy headline for a coffee shop',
- *   5,
- *   { type: 'text' }
- * )
- *
- * variations.forEach((v, i) => {
- *   console.log(`${i + 1}. ${v.content}`)
- * })
- * ```
- */
-generate.variations = async (prompt, count, options = {}) => {
-    return Promise.all(Array.from({ length: count }, () => generate(prompt, options)));
-};
-/**
- * Generate content with a specific tone
- *
- * @param prompt - What to generate
- * @param tone - The desired tone
- * @param options - Generation options
- * @returns Promise resolving to generated content
- *
- * @example
- * ```ts
- * const professional = await generate.withTone(
- *   'Write an email declining a meeting',
- *   'professional',
- *   { type: 'text' }
- * )
- *
- * const friendly = await generate.withTone(
- *   'Write an email declining a meeting',
- *   'friendly',
- *   { type: 'text' }
- * )
- * ```
- */
-generate.withTone = async (prompt, tone, options = {}) => {
-    const toneInstructions = {
-        professional: 'Use a professional, business-appropriate tone.',
-        casual: 'Use a casual, conversational tone.',
-        friendly: 'Use a warm, friendly tone.',
-        formal: 'Use a formal, ceremonious tone.',
-        humorous: 'Use a light, humorous tone.',
-        empathetic: 'Use an empathetic, understanding tone.',
-    };
-    return generate(prompt, {
-        ...options,
-        instructions: `${toneInstructions[tone]} ${options.instructions || ''}`,
-    });
-};
-/**
- * Generate content for a specific audience
- *
- * @param prompt - What to generate
- * @param audience - Target audience
- * @param options - Generation options
- * @returns Promise resolving to generated content
- *
- * @example
- * ```ts
- * const technical = await generate.forAudience(
- *   'Explain how OAuth works',
- *   'software engineers',
- *   { type: 'text' }
- * )
- *
- * const nonTechnical = await generate.forAudience(
- *   'Explain how OAuth works',
- *   'non-technical business users',
- *   { type: 'text' }
- * )
- * ```
- */
-generate.forAudience = async (prompt, audience, options = {}) => {
-    return generate(prompt, {
-        ...options,
-        instructions: `Write for ${audience}. ${options.instructions || ''}`,
-    });
-};
-/**
- * Generate content with specific length
- *
- * @param prompt - What to generate
- * @param length - Desired length
- * @param options - Generation options
- * @returns Promise resolving to generated content
- *
- * @example
- * ```ts
- * const short = await generate.withLength(
- *   'Describe our company',
- *   'short',
- *   { type: 'text' }
- * )
- *
- * const detailed = await generate.withLength(
- *   'Describe our company',
- *   'detailed',
- *   { type: 'text' }
- * )
- * ```
- */
-generate.withLength = async (prompt, length, options = {}) => {
-    const lengthInstructions = {
-        brief: 'Keep it very brief - 1-2 sentences maximum.',
-        short: 'Keep it short - around 50-100 words.',
-        medium: 'Use a medium length - around 150-300 words.',
-        long: 'Write a longer piece - around 400-600 words.',
-        detailed: 'Write a detailed, comprehensive piece - 800+ words.',
-    };
-    return generate(prompt, {
-        ...options,
-        instructions: `${lengthInstructions[length]} ${options.instructions || ''}`,
-    });
-};
-/**
- * Generate content by iteratively refining it
- *
- * @param prompt - What to generate
- * @param refinements - Refinement prompts to apply
- * @param options - Generation options
- * @returns Promise resolving to refined content
- *
- * @example
- * ```ts
- * const refined = await generate.refine(
- *   'Write a product tagline',
- *   [
- *     'Make it more memorable',
- *     'Add a sense of urgency',
- *     'Emphasize the value proposition',
- *   ],
- *   { type: 'text' }
- * )
- * ```
- */
-generate.refine = async (prompt, refinements, options = {}) => {
-    // Generate initial content
-    let result = await generate(prompt, options);
-    // Apply refinements iteratively
-    for (const refinement of refinements) {
-        result = await generate(`Refine the following content: ${result.content}\n\nRefinement: ${refinement}`, options);
-    }
-    return result;
-};