overai 1.4.0

package/dist/llm/providers/ai-sdk/adapter.js

@@ -0,0 +1,399 @@
+"use strict";
+/**
+ * AI SDK Adapter
+ *
+ * Converts between praisonai-ts message/tool formats and AI SDK formats.
+ * Handles prompt construction, tool definitions, and result parsing.
+ */
+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.toAISDKPrompt = toAISDKPrompt;
+exports.toAISDKTools = toAISDKTools;
+exports.fromAISDKToolCall = fromAISDKToolCall;
+exports.toAISDKToolResult = toAISDKToolResult;
+exports.extractTextFromContent = extractTextFromContent;
+exports.extractToolCallsFromContent = extractToolCallsFromContent;
+exports.fromAISDKResult = fromAISDKResult;
+exports.mapFinishReason = mapFinishReason;
+exports.mapFinishReasonToProvider = mapFinishReasonToProvider;
+exports.fromAISDKStreamChunk = fromAISDKStreamChunk;
+exports.toAISDKToolChoice = toAISDKToolChoice;
+exports.createSimplePrompt = createSimplePrompt;
+/**
+ * Convert praisonai-ts messages to AI SDK prompt format
+ */
+function toAISDKPrompt(messages) {
+    return messages.map(msg => {
+        switch (msg.role) {
+            case 'system':
+                return {
+                    role: 'system',
+                    content: msg.content || ''
+                };
+            case 'user':
+                return {
+                    role: 'user',
+                    content: [{ type: 'text', text: msg.content || '' }]
+                };
+            case 'assistant':
+                if (msg.tool_calls && msg.tool_calls.length > 0) {
+                    return {
+                        role: 'assistant',
+                        content: msg.tool_calls.map(tc => ({
+                            type: 'tool-call',
+                            toolCallId: tc.id,
+                            toolName: tc.function.name,
+                            args: safeParseJSON(tc.function.arguments)
+                        }))
+                    };
+                }
+                return {
+                    role: 'assistant',
+                    content: [{ type: 'text', text: msg.content || '' }]
+                };
+            case 'tool':
+                return {
+                    role: 'tool',
+                    content: [{
+                            type: 'tool-result',
+                            toolCallId: msg.tool_call_id || '',
+                            toolName: msg.name || '',
+                            result: safeParseJSON(msg.content || '')
+                        }]
+                };
+            default:
+                // Fallback to user message for unknown roles
+                return {
+                    role: 'user',
+                    content: [{ type: 'text', text: msg.content || '' }]
+                };
+        }
+    });
+}
+/**
+ * Convert praisonai-ts tool definitions to AI SDK format
+ * AI SDK expects tools created with the tool() helper from @ai-sdk/provider-utils
+ */
+async function toAISDKTools(tools) {
+    const result = {};
+    // Import the tool helper from @ai-sdk/provider-utils
+    let toolHelper;
+    let jsonSchemaHelper;
+    try {
+        const providerUtils = await Promise.resolve().then(() => __importStar(require('@ai-sdk/provider-utils')));
+        toolHelper = providerUtils.tool;
+        jsonSchemaHelper = providerUtils.jsonSchema;
+    }
+    catch {
+        toolHelper = null;
+        jsonSchemaHelper = null;
+    }
+    for (const toolDef of tools) {
+        // Build a proper JSON Schema for the tool parameters
+        const params = toolDef.parameters || {};
+        const schema = {
+            type: 'object',
+            properties: params.properties || {},
+            required: params.required || [],
+            ...(params.additionalProperties !== undefined
+                ? { additionalProperties: params.additionalProperties }
+                : {}),
+        };
+        if (toolHelper && jsonSchemaHelper) {
+            // Use AI SDK's tool() helper for proper tool creation
+            result[toolDef.name] = toolHelper({
+                description: toolDef.description || '',
+                parameters: jsonSchemaHelper(schema),
+            });
+        }
+        else {
+            // Fallback format - create tool-like object manually
+            result[toolDef.name] = {
+                description: toolDef.description || '',
+                parameters: schema,
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Convert AI SDK tool call to praisonai-ts format
+ */
+function fromAISDKToolCall(toolCall) {
+    return {
+        id: toolCall.toolCallId,
+        type: 'function',
+        function: {
+            name: toolCall.toolName,
+            arguments: typeof toolCall.args === 'string'
+                ? toolCall.args
+                : JSON.stringify(toolCall.args)
+        }
+    };
+}
+/**
+ * Convert praisonai-ts tool result to AI SDK format
+ */
+function toAISDKToolResult(toolCallId, toolName, result) {
+    return {
+        toolCallId,
+        toolName,
+        result
+    };
+}
+/**
+ * Extract text content from AI SDK response content
+ */
+function extractTextFromContent(content) {
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    return content
+        .filter((part) => typeof part === 'object' &&
+        part !== null &&
+        'type' in part &&
+        part.type === 'text' &&
+        'text' in part)
+        .map(part => part.text)
+        .join('');
+}
+/**
+ * Extract tool calls from AI SDK response content
+ */
+function extractToolCallsFromContent(content) {
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    return content
+        .filter((part) => typeof part === 'object' &&
+        part !== null &&
+        'type' in part &&
+        part.type === 'tool-call')
+        .map(part => fromAISDKToolCall({
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        args: part.args
+    }));
+}
+/**
+ * Convert AI SDK generate result to praisonai-ts format
+ */
+function fromAISDKResult(result) {
+    // Extract text from content or use text directly
+    let text = result.text || '';
+    if (!text && result.content) {
+        text = extractTextFromContent(result.content);
+    }
+    // Extract tool calls
+    let toolCalls = [];
+    if (result.toolCalls && result.toolCalls.length > 0) {
+        toolCalls = result.toolCalls.map(fromAISDKToolCall);
+    }
+    else if (result.content) {
+        toolCalls = extractToolCallsFromContent(result.content);
+    }
+    // Map usage - provide defaults if not available
+    const usage = result.usage ? {
+        promptTokens: result.usage.promptTokens,
+        completionTokens: result.usage.completionTokens,
+        totalTokens: result.usage.promptTokens + result.usage.completionTokens
+    } : {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0
+    };
+    // Map finish reason to praisonai-ts format
+    const finishReason = mapFinishReasonToProvider(result.finishReason);
+    return {
+        text,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        usage,
+        finishReason,
+        raw: result
+    };
+}
+/**
+ * Map AI SDK finish reason to internal format
+ */
+function mapFinishReason(reason) {
+    if (!reason)
+        return 'unknown';
+    switch (reason.toLowerCase()) {
+        case 'stop':
+        case 'end_turn':
+        case 'end':
+            return 'stop';
+        case 'length':
+        case 'max_tokens':
+            return 'length';
+        case 'tool_calls':
+        case 'tool-calls':
+        case 'function_call':
+            return 'tool-calls';
+        case 'content_filter':
+        case 'content-filter':
+            return 'content-filter';
+        case 'error':
+            return 'error';
+        case 'cancelled':
+        case 'canceled':
+            return 'cancelled';
+        default:
+            return 'unknown';
+    }
+}
+/**
+ * Map AI SDK finish reason to praisonai-ts provider format
+ * Uses underscore format for tool_calls as expected by GenerateTextResult
+ */
+function mapFinishReasonToProvider(reason) {
+    if (!reason)
+        return 'stop';
+    switch (reason.toLowerCase()) {
+        case 'stop':
+        case 'end_turn':
+        case 'end':
+            return 'stop';
+        case 'length':
+        case 'max_tokens':
+            return 'length';
+        case 'tool_calls':
+        case 'tool-calls':
+        case 'function_call':
+            return 'tool_calls';
+        case 'content_filter':
+        case 'content-filter':
+            return 'content_filter';
+        case 'error':
+        case 'cancelled':
+        case 'canceled':
+        default:
+            return 'error';
+    }
+}
+/**
+ * Convert AI SDK stream chunk to praisonai-ts format
+ */
+function fromAISDKStreamChunk(chunk) {
+    switch (chunk.type) {
+        case 'text-delta':
+            if (chunk.textDelta) {
+                return { type: 'text', text: chunk.textDelta };
+            }
+            return null;
+        case 'tool-call':
+            if (chunk.toolCallId && chunk.toolName) {
+                return {
+                    type: 'tool-call-end',
+                    toolCallId: chunk.toolCallId,
+                    args: chunk.args
+                };
+            }
+            return null;
+        case 'tool-call-streaming-start':
+            if (chunk.toolCallId && chunk.toolName) {
+                return {
+                    type: 'tool-call-start',
+                    toolCallId: chunk.toolCallId,
+                    toolName: chunk.toolName
+                };
+            }
+            return null;
+        case 'tool-call-delta':
+            if (chunk.toolCallId && chunk.argsTextDelta) {
+                return {
+                    type: 'tool-call-delta',
+                    toolCallId: chunk.toolCallId,
+                    argsTextDelta: chunk.argsTextDelta
+                };
+            }
+            return null;
+        case 'finish':
+        case 'step-finish':
+            return {
+                type: 'finish',
+                finishReason: mapFinishReason(chunk.finishReason),
+                usage: chunk.usage ? {
+                    promptTokens: chunk.usage.promptTokens,
+                    completionTokens: chunk.usage.completionTokens,
+                    totalTokens: chunk.usage.promptTokens + chunk.usage.completionTokens
+                } : undefined
+            };
+        default:
+            return null;
+    }
+}
+/**
+ * Map praisonai-ts tool choice to AI SDK format
+ */
+function toAISDKToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (typeof toolChoice === 'string') {
+        return toolChoice;
+    }
+    return toolChoice;
+}
+/**
+ * Safely parse JSON, returning the original string if parsing fails
+ */
+function safeParseJSON(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return str;
+    }
+}
+/**
+ * Create a simple prompt from a string
+ */
+function createSimplePrompt(prompt, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+        messages.push({
+            role: 'system',
+            content: systemPrompt
+        });
+    }
+    messages.push({
+        role: 'user',
+        content: [{ type: 'text', text: prompt }]
+    });
+    return messages;
+}

package/dist/llm/providers/ai-sdk/backend.d.ts

@@ -0,0 +1,49 @@
+/**
+ * AI SDK Backend
+ *
+ * Main implementation of the AI SDK backend for praisonai-ts.
+ * Provides generateText, streamText, and generateObject methods
+ * with retry logic, timeouts, and attribution support.
+ */
+import type { LLMProvider, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult } from '../types';
+import type { AISDKBackendConfig } from './types';
+/**
+ * AI SDK Backend - implements LLMProvider interface
+ */
+export declare class AISDKBackend implements LLMProvider {
+    readonly providerId: string;
+    readonly modelId: string;
+    private readonly config;
+    private readonly attribution?;
+    private provider;
+    private model;
+    constructor(modelString: string, config?: AISDKBackendConfig);
+    /**
+     * Initialize the AI SDK provider and model (lazy)
+     */
+    private ensureInitialized;
+    /**
+     * Generate text (non-streaming)
+     */
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    /**
+     * Stream text generation
+     */
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    /**
+     * Generate structured object output
+     */
+    generateObject<T = unknown>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    /**
+     * Get the underlying AI SDK model (for advanced use)
+     */
+    getModel(): Promise<unknown>;
+    /**
+     * Get the underlying AI SDK provider (for advanced use)
+     */
+    getProvider(): Promise<unknown>;
+}
+/**
+ * Create an AI SDK backend instance
+ */
+export declare function createAISDKBackend(modelString: string, config?: AISDKBackendConfig): AISDKBackend;