overai 1.4.0

package/dist/ai/ui-message.d.ts

@@ -0,0 +1,218 @@
+/**
+ * UIMessage - AI SDK v6 Compatible UI Message Types
+ *
+ * Provides types and utilities for working with UI messages in chat applications.
+ * Compatible with AI SDK v6's UIMessage format for seamless integration.
+ */
+/**
+ * UI Message - The main message type for chat UIs.
+ * Compatible with AI SDK v6's UIMessage format.
+ */
+export interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> {
+    /** Unique identifier for the message */
+    id: string;
+    /** Role of the message sender */
+    role: 'system' | 'user' | 'assistant';
+    /** Optional metadata */
+    metadata?: METADATA;
+    /** Message parts for rendering */
+    parts: Array<UIMessagePart<DATA_PARTS, TOOLS>>;
+}
+/** Data types that can be used in UI message data parts */
+export type UIDataTypes = Record<string, unknown>;
+/** UI Tool definition */
+export type UITool = {
+    input: unknown;
+    output: unknown | undefined;
+};
+/** UI Tools map */
+export type UITools = Record<string, UITool>;
+/** All possible UI message part types */
+export type UIMessagePart<DATA_TYPES extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = TextUIPart | ReasoningUIPart | ToolUIPart<TOOLS> | SourceUrlUIPart | SourceDocumentUIPart | FileUIPart | DataUIPart<DATA_TYPES> | StepStartUIPart;
+/** Text part of a message */
+export interface TextUIPart {
+    type: 'text';
+    text: string;
+    state?: 'streaming' | 'done';
+    providerMetadata?: Record<string, unknown>;
+}
+/** Reasoning part of a message */
+export interface ReasoningUIPart {
+    type: 'reasoning';
+    text: string;
+    state?: 'streaming' | 'done';
+    providerMetadata?: Record<string, unknown>;
+}
+/** Tool invocation part */
+export interface ToolUIPart<TOOLS extends UITools = UITools> {
+    type: 'tool';
+    toolInvocationId: string;
+    toolName: keyof TOOLS & string;
+    state: 'input-streaming' | 'input-available' | 'output-streaming' | 'output-available' | 'error';
+    input?: TOOLS[keyof TOOLS]['input'];
+    output?: TOOLS[keyof TOOLS]['output'];
+    error?: string;
+    /** Whether this tool needs approval before execution */
+    needsApproval?: boolean;
+    /** Approval status */
+    approvalStatus?: 'pending' | 'approved' | 'denied';
+}
+/** Source URL part */
+export interface SourceUrlUIPart {
+    type: 'source-url';
+    sourceId: string;
+    url: string;
+    title?: string;
+    providerMetadata?: Record<string, unknown>;
+}
+/** Source document part */
+export interface SourceDocumentUIPart {
+    type: 'source-document';
+    sourceId: string;
+    mediaType: string;
+    title?: string;
+    providerMetadata?: Record<string, unknown>;
+}
+/** File part */
+export interface FileUIPart {
+    type: 'file';
+    mediaType: string;
+    url?: string;
+    data?: string;
+    filename?: string;
+}
+/** Data part for custom data */
+export interface DataUIPart<DATA_TYPES extends UIDataTypes = UIDataTypes> {
+    type: 'data';
+    dataType: keyof DATA_TYPES & string;
+    data: DATA_TYPES[keyof DATA_TYPES];
+}
+/** Step start marker */
+export interface StepStartUIPart {
+    type: 'step-start';
+    stepNumber: number;
+}
+export interface ModelMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | ModelMessageContent[];
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+}
+export type ModelMessageContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    image: string | Uint8Array;
+    mimeType?: string;
+} | {
+    type: 'file';
+    data: string | Uint8Array;
+    mimeType: string;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+} | {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+};
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * Convert UI messages to model messages for AI SDK functions.
+ *
+ * @example
+ * ```typescript
+ * const modelMessages = await convertToModelMessages(uiMessages);
+ * const result = await generateText({ model, messages: modelMessages });
+ * ```
+ */
+export declare function convertToModelMessages(messages: Array<Omit<UIMessage, 'id'>>, options?: {
+    tools?: Record<string, unknown>;
+    ignoreIncompleteToolCalls?: boolean;
+}): Promise<ModelMessage[]>;
+/**
+ * Convert model messages to UI messages.
+ */
+export declare function convertToUIMessages(messages: ModelMessage[], generateId?: () => string): UIMessage[];
+/**
+ * Validate UI messages array.
+ */
+export declare function validateUIMessages(messages: unknown[]): messages is UIMessage[];
+/**
+ * Safe validation that returns result object.
+ */
+export declare function safeValidateUIMessages(messages: unknown[]): {
+    success: boolean;
+    value?: UIMessage[];
+    error?: string;
+};
+/**
+ * Create a text UI message.
+ */
+export declare function createTextMessage(role: 'user' | 'assistant', text: string, id?: string): UIMessage;
+/**
+ * Create a system message.
+ */
+export declare function createSystemMessage(text: string, id?: string): UIMessage;
+/**
+ * Check if a message has pending tool approvals.
+ */
+export declare function hasPendingApprovals(message: UIMessage): boolean;
+/**
+ * Get tool parts that need approval.
+ */
+export declare function getToolsNeedingApproval(message: UIMessage): ToolUIPart[];
+/**
+ * Create an approval response for a tool.
+ */
+export declare function createApprovalResponse(toolInvocationId: string, approved: boolean): {
+    toolInvocationId: string;
+    approved: boolean;
+};
+export interface UIMessageStreamOptions {
+    /** Called when a message is created */
+    onMessage?: (message: UIMessage) => void;
+    /** Called when a part is added */
+    onPart?: (part: UIMessagePart) => void;
+    /** Called on error */
+    onError?: (error: Error) => void;
+    /** Called when stream completes */
+    onFinish?: (messages: UIMessage[]) => void;
+}
+/**
+ * Create a UI message stream response for Next.js route handlers.
+ *
+ * @example
+ * ```typescript
+ * // In app/api/chat/route.ts
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   const result = await streamText({ model, messages });
+ *   return toUIMessageStreamResponse(result);
+ * }
+ * ```
+ */
+export declare function toUIMessageStreamResponse(stream: AsyncIterable<any>, options?: {
+    headers?: Record<string, string>;
+    status?: number;
+}): Response;
+/**
+ * Pipe UI message stream to a Node.js response.
+ */
+export declare function pipeUIMessageStreamToResponse(stream: AsyncIterable<any>, response: {
+    write: (chunk: string) => void;
+    end: () => void;
+}): void;

package/dist/ai/ui-message.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * UIMessage - AI SDK v6 Compatible UI Message Types
+ *
+ * Provides types and utilities for working with UI messages in chat applications.
+ * Compatible with AI SDK v6's UIMessage format for seamless integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToModelMessages = convertToModelMessages;
+exports.convertToUIMessages = convertToUIMessages;
+exports.validateUIMessages = validateUIMessages;
+exports.safeValidateUIMessages = safeValidateUIMessages;
+exports.createTextMessage = createTextMessage;
+exports.createSystemMessage = createSystemMessage;
+exports.hasPendingApprovals = hasPendingApprovals;
+exports.getToolsNeedingApproval = getToolsNeedingApproval;
+exports.createApprovalResponse = createApprovalResponse;
+exports.toUIMessageStreamResponse = toUIMessageStreamResponse;
+exports.pipeUIMessageStreamToResponse = pipeUIMessageStreamToResponse;
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+/**
+ * Convert UI messages to model messages for AI SDK functions.
+ *
+ * @example
+ * ```typescript
+ * const modelMessages = await convertToModelMessages(uiMessages);
+ * const result = await generateText({ model, messages: modelMessages });
+ * ```
+ */
+async function convertToModelMessages(messages, options) {
+    const modelMessages = [];
+    for (const message of messages) {
+        switch (message.role) {
+            case 'system': {
+                const textParts = message.parts.filter((part) => part.type === 'text');
+                if (textParts.length > 0) {
+                    modelMessages.push({
+                        role: 'system',
+                        content: textParts.map(p => p.text).join(''),
+                    });
+                }
+                break;
+            }
+            case 'user': {
+                const content = [];
+                for (const part of message.parts) {
+                    if (part.type === 'text') {
+                        content.push({ type: 'text', text: part.text });
+                    }
+                    else if (part.type === 'file') {
+                        content.push({
+                            type: 'file',
+                            data: part.data || '',
+                            mimeType: part.mediaType,
+                        });
+                    }
+                }
+                if (content.length > 0) {
+                    modelMessages.push({
+                        role: 'user',
+                        content: content.length === 1 && content[0].type === 'text'
+                            ? content[0].text
+                            : content,
+                    });
+                }
+                break;
+            }
+            case 'assistant': {
+                const content = [];
+                const toolCalls = [];
+                for (const part of message.parts) {
+                    if (part.type === 'text') {
+                        content.push({ type: 'text', text: part.text });
+                    }
+                    else if (part.type === 'tool') {
+                        // Skip incomplete tool calls if requested
+                        if (options?.ignoreIncompleteToolCalls &&
+                            (part.state === 'input-streaming' || part.state === 'input-available')) {
+                            continue;
+                        }
+                        toolCalls.push({
+                            id: part.toolInvocationId,
+                            type: 'function',
+                            function: {
+                                name: part.toolName,
+                                arguments: JSON.stringify(part.input || {}),
+                            },
+                        });
+                    }
+                }
+                if (content.length > 0 || toolCalls.length > 0) {
+                    modelMessages.push({
+                        role: 'assistant',
+                        content: content.length === 1 && content[0].type === 'text'
+                            ? content[0].text
+                            : content.length > 0 ? content : '',
+                        ...(toolCalls.length > 0 ? { toolCalls } : {}),
+                    });
+                }
+                // Add tool results as separate messages
+                for (const part of message.parts) {
+                    if (part.type === 'tool' && part.state === 'output-available' && part.output !== undefined) {
+                        modelMessages.push({
+                            role: 'tool',
+                            content: typeof part.output === 'string' ? part.output : JSON.stringify(part.output),
+                            toolCallId: part.toolInvocationId,
+                        });
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return modelMessages;
+}
+/**
+ * Convert model messages to UI messages.
+ */
+function convertToUIMessages(messages, generateId = () => crypto.randomUUID()) {
+    const uiMessages = [];
+    for (const message of messages) {
+        const parts = [];
+        if (typeof message.content === 'string') {
+            parts.push({ type: 'text', text: message.content, state: 'done' });
+        }
+        else if (Array.isArray(message.content)) {
+            for (const content of message.content) {
+                if (content.type === 'text') {
+                    parts.push({ type: 'text', text: content.text, state: 'done' });
+                }
+            }
+        }
+        if (message.toolCalls) {
+            for (const toolCall of message.toolCalls) {
+                parts.push({
+                    type: 'tool',
+                    toolInvocationId: toolCall.id,
+                    toolName: toolCall.function.name,
+                    state: 'input-available',
+                    input: JSON.parse(toolCall.function.arguments || '{}'),
+                });
+            }
+        }
+        if (message.role !== 'tool') {
+            uiMessages.push({
+                id: generateId(),
+                role: message.role,
+                parts,
+            });
+        }
+    }
+    return uiMessages;
+}
+// ============================================================================
+// Validation
+// ============================================================================
+/**
+ * Validate UI messages array.
+ */
+function validateUIMessages(messages) {
+    if (!Array.isArray(messages))
+        return false;
+    for (const msg of messages) {
+        if (!msg || typeof msg !== 'object')
+            return false;
+        const m = msg;
+        if (typeof m.id !== 'string')
+            return false;
+        if (!['system', 'user', 'assistant'].includes(m.role))
+            return false;
+        if (!Array.isArray(m.parts))
+            return false;
+    }
+    return true;
+}
+/**
+ * Safe validation that returns result object.
+ */
+function safeValidateUIMessages(messages) {
+    try {
+        if (validateUIMessages(messages)) {
+            return { success: true, value: messages };
+        }
+        return { success: false, error: 'Invalid UI messages format' };
+    }
+    catch (error) {
+        return { success: false, error: String(error) };
+    }
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Create a text UI message.
+ */
+function createTextMessage(role, text, id) {
+    return {
+        id: id || crypto.randomUUID(),
+        role,
+        parts: [{ type: 'text', text, state: 'done' }],
+    };
+}
+/**
+ * Create a system message.
+ */
+function createSystemMessage(text, id) {
+    return {
+        id: id || crypto.randomUUID(),
+        role: 'system',
+        parts: [{ type: 'text', text, state: 'done' }],
+    };
+}
+/**
+ * Check if a message has pending tool approvals.
+ */
+function hasPendingApprovals(message) {
+    return message.parts.some(part => part.type === 'tool' && part.needsApproval && part.approvalStatus === 'pending');
+}
+/**
+ * Get tool parts that need approval.
+ */
+function getToolsNeedingApproval(message) {
+    return message.parts.filter((part) => part.type === 'tool' && part.needsApproval === true && part.approvalStatus === 'pending');
+}
+/**
+ * Create an approval response for a tool.
+ */
+function createApprovalResponse(toolInvocationId, approved) {
+    return { toolInvocationId, approved };
+}
+/**
+ * Create a UI message stream response for Next.js route handlers.
+ *
+ * @example
+ * ```typescript
+ * // In app/api/chat/route.ts
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   const result = await streamText({ model, messages });
+ *   return toUIMessageStreamResponse(result);
+ * }
+ * ```
+ */
+function toUIMessageStreamResponse(stream, options) {
+    const encoder = new TextEncoder();
+    const readable = new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const chunk of stream) {
+                    const data = JSON.stringify(chunk);
+                    controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                }
+                controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+    return new Response(readable, {
+        status: options?.status || 200,
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            ...options?.headers,
+        },
+    });
+}
+/**
+ * Pipe UI message stream to a Node.js response.
+ */
+function pipeUIMessageStreamToResponse(stream, response) {
+    (async () => {
+        try {
+            for await (const chunk of stream) {
+                const data = JSON.stringify(chunk);
+                response.write(`data: ${data}\n\n`);
+            }
+            response.write('data: [DONE]\n\n');
+            response.end();
+        }
+        catch (error) {
+            response.write(`data: ${JSON.stringify({ error: String(error) })}\n\n`);
+            response.end();
+        }
+    })();
+}

package/dist/auto/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * AutoAgents - Automatic agent generation from task descriptions
+ */
+export interface AgentConfig {
+    name: string;
+    role: string;
+    goal: string;
+    backstory?: string;
+    instructions?: string;
+    tools?: string[];
+}
+export interface TaskConfig {
+    description: string;
+    expectedOutput?: string;
+    agent?: string;
+}
+export interface TeamStructure {
+    agents: AgentConfig[];
+    tasks: TaskConfig[];
+    pattern: 'sequential' | 'parallel' | 'hierarchical';
+}
+export interface AutoAgentsConfig {
+    llm?: string;
+    pattern?: 'sequential' | 'parallel' | 'routing' | 'orchestrator-workers' | 'evaluator-optimizer';
+    singleAgent?: boolean;
+    verbose?: boolean;
+}
+/**
+ * AutoAgents - Generate agent configurations from task descriptions
+ */
+export declare class AutoAgents {
+    private provider;
+    private providerPromise;
+    private llmModel;
+    private pattern;
+    private singleAgent;
+    private verbose;
+    constructor(config?: AutoAgentsConfig);
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    private getProvider;
+    /**
+     * Generate agent configuration from task description
+     */
+    generate(taskDescription: string): Promise<TeamStructure>;
+    /**
+     * Recommend a pattern for the task
+     */
+    recommendPattern(taskDescription: string): string;
+    /**
+     * Analyze task complexity
+     */
+    analyzeComplexity(taskDescription: string): 'simple' | 'moderate' | 'complex';
+    private getSystemPrompt;
+    private buildPrompt;
+    private parseResponse;
+}
+/**
+ * Create an AutoAgents instance
+ */
+export declare function createAutoAgents(config?: AutoAgentsConfig): AutoAgents;