@push.rocks/smartai 0.13.3 → 2.0.0

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartai',
-  version: '0.13.3',
-  description: 'SmartAi is a versatile TypeScript library designed to facilitate integration and interaction with various AI models, offering functionalities for chat, audio generation, document processing, and vision tasks.'
+  version: '2.0.0',
+  description: 'Provider registry and capability utilities for ai-sdk (Vercel AI SDK). Core export returns LanguageModel; subpath exports provide vision, audio, image, document and research capabilities.'
 }

package/ts/index.ts

@@ -1,11 +1,8 @@
-export * from './classes.smartai.js';
-export * from './abstract.classes.multimodal.js';
-export * from './provider.openai.js';
-export * from './provider.anthropic.js';
-export * from './provider.perplexity.js';
-export * from './provider.groq.js';
-export * from './provider.mistral.js';
-export * from './provider.ollama.js';
-export * from './provider.xai.js';
-export * from './provider.exo.js';
-export * from './provider.elevenlabs.js';
+export { getModel } from './smartai.classes.smartai.js';
+export type { ISmartAiOptions, TProvider, IOllamaModelOptions, LanguageModelV3 } from './smartai.interfaces.js';
+export { createAnthropicCachingMiddleware } from './smartai.middleware.anthropic.js';
+export { createOllamaModel } from './smartai.provider.ollama.js';
+
+// Re-export commonly used ai-sdk functions for consumer convenience
+export { generateText, streamText, tool, jsonSchema } from 'ai';
+export type { ModelMessage, ToolSet, StreamTextResult } from 'ai';

package/ts/plugins.ts

@@ -1,38 +1,22 @@
-// node native
-import * as path from 'path';
+// ai sdk core
+import { generateText, streamText, wrapLanguageModel, tool, jsonSchema } from 'ai';
+export { generateText, streamText, wrapLanguageModel, tool, jsonSchema };
 
-export {
-  path,
-}
-
-// @push.rocks scope
-import * as qenv from '@push.rocks/qenv';
-import * as smartarray from '@push.rocks/smartarray';
-import * as smartfs from '@push.rocks/smartfs';
-import * as smartpath from '@push.rocks/smartpath';
-import * as smartpdf from '@push.rocks/smartpdf';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrequest from '@push.rocks/smartrequest';
-import * as webstream from '@push.rocks/webstream';
-
-export {
-  smartarray,
-  qenv,
-  smartfs,
-  smartpath,
-  smartpdf,
-  smartpromise,
-  smartrequest,
-  webstream,
-}
-
-// third party
-import * as anthropic from '@anthropic-ai/sdk';
-import * as mistralai from '@mistralai/mistralai';
-import * as openai from 'openai';
+// ai sdk providers
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createGroq } from '@ai-sdk/groq';
+import { createMistral } from '@ai-sdk/mistral';
+import { createXai } from '@ai-sdk/xai';
+import { createPerplexity } from '@ai-sdk/perplexity';
 
 export {
-  anthropic,
-  mistralai,
-  openai,
-}
+  createAnthropic,
+  createOpenAI,
+  createGoogleGenerativeAI,
+  createGroq,
+  createMistral,
+  createXai,
+  createPerplexity,
+};

package/ts/smartai.classes.smartai.ts

@@ -0,0 +1,51 @@
+import * as plugins from './plugins.js';
+import type { ISmartAiOptions, LanguageModelV3 } from './smartai.interfaces.js';
+import { createOllamaModel } from './smartai.provider.ollama.js';
+import { createAnthropicCachingMiddleware } from './smartai.middleware.anthropic.js';
+
+/**
+ * Returns a LanguageModelV3 for the given provider and model.
+ * This is the primary API — consumers use the returned model with AI SDK's
+ * generateText(), streamText(), etc.
+ */
+export function getModel(options: ISmartAiOptions): LanguageModelV3 {
+  switch (options.provider) {
+    case 'anthropic': {
+      const p = plugins.createAnthropic({ apiKey: options.apiKey });
+      const base = p(options.model) as LanguageModelV3;
+      if (options.promptCaching === false) return base;
+      return plugins.wrapLanguageModel({
+        model: base,
+        middleware: createAnthropicCachingMiddleware(),
+      }) as unknown as LanguageModelV3;
+    }
+    case 'openai': {
+      const p = plugins.createOpenAI({ apiKey: options.apiKey });
+      return p(options.model) as LanguageModelV3;
+    }
+    case 'google': {
+      const p = plugins.createGoogleGenerativeAI({ apiKey: options.apiKey });
+      return p(options.model) as LanguageModelV3;
+    }
+    case 'groq': {
+      const p = plugins.createGroq({ apiKey: options.apiKey });
+      return p(options.model) as LanguageModelV3;
+    }
+    case 'mistral': {
+      const p = plugins.createMistral({ apiKey: options.apiKey });
+      return p(options.model) as LanguageModelV3;
+    }
+    case 'xai': {
+      const p = plugins.createXai({ apiKey: options.apiKey });
+      return p(options.model) as LanguageModelV3;
+    }
+    case 'perplexity': {
+      const p = plugins.createPerplexity({ apiKey: options.apiKey });
+      return p(options.model) as LanguageModelV3;
+    }
+    case 'ollama':
+      return createOllamaModel(options);
+    default:
+      throw new Error(`Unknown provider: ${(options as ISmartAiOptions).provider}`);
+  }
+}

package/ts/smartai.interfaces.ts

@@ -0,0 +1,53 @@
+import type { LanguageModelV3 } from '@ai-sdk/provider';
+
+export type TProvider =
+  | 'anthropic'
+  | 'openai'
+  | 'google'
+  | 'groq'
+  | 'mistral'
+  | 'xai'
+  | 'perplexity'
+  | 'ollama';
+
+export interface ISmartAiOptions {
+  provider: TProvider;
+  model: string;
+  apiKey?: string;
+  /** For Ollama: base URL of the local server. Default: http://localhost:11434 */
+  baseUrl?: string;
+  /**
+   * Ollama-specific model runtime options.
+   * Only used when provider === 'ollama'.
+   */
+  ollamaOptions?: IOllamaModelOptions;
+  /**
+   * Enable Anthropic prompt caching on system + recent messages.
+   * Only used when provider === 'anthropic'. Default: true.
+   */
+  promptCaching?: boolean;
+}
+
+/**
+ * Ollama model runtime options passed in the request body `options` field.
+ * @see https://github.com/ollama/ollama/blob/main/docs/modelfile.md
+ */
+export interface IOllamaModelOptions {
+  /** Context window size. Default: 2048. */
+  num_ctx?: number;
+  /** 0 = deterministic. Default: 0.8. For Qwen models use 0.55. */
+  temperature?: number;
+  top_k?: number;
+  top_p?: number;
+  repeat_penalty?: number;
+  num_predict?: number;
+  stop?: string[];
+  seed?: number;
+  /**
+   * Enable thinking/reasoning mode (Qwen3, QwQ, DeepSeek-R1 etc.).
+   * The custom Ollama provider handles this directly.
+   */
+  think?: boolean;
+}
+
+export type { LanguageModelV3 };

package/ts/smartai.middleware.anthropic.ts

@@ -0,0 +1,38 @@
+import type { LanguageModelV3Middleware, LanguageModelV3Prompt } from '@ai-sdk/provider';
+
+/**
+ * Creates middleware that adds Anthropic prompt caching directives.
+ * Marks the last system message and last user message with ephemeral cache control,
+ * reducing input token cost and latency on repeated calls.
+ */
+export function createAnthropicCachingMiddleware(): LanguageModelV3Middleware {
+  return {
+    specificationVersion: 'v3',
+    transformParams: async ({ params }) => {
+      const messages = [...params.prompt] as Array<Record<string, unknown>>;
+
+      // Find the last system message and last user message
+      let lastSystemIdx = -1;
+      let lastUserIdx = -1;
+      for (let i = 0; i < messages.length; i++) {
+        if (messages[i].role === 'system') lastSystemIdx = i;
+        if (messages[i].role === 'user') lastUserIdx = i;
+      }
+
+      const targets = [lastSystemIdx, lastUserIdx].filter(i => i >= 0);
+      for (const idx of targets) {
+        const msg = { ...messages[idx] };
+        msg.providerOptions = {
+          ...(msg.providerOptions as Record<string, unknown> || {}),
+          anthropic: {
+            ...((msg.providerOptions as Record<string, unknown>)?.anthropic as Record<string, unknown> || {}),
+            cacheControl: { type: 'ephemeral' },
+          },
+        };
+        messages[idx] = msg;
+      }
+
+      return { ...params, prompt: messages as unknown as LanguageModelV3Prompt };
+    },
+  };
+}

package/ts/smartai.provider.ollama.ts

@@ -0,0 +1,426 @@
+import type {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3StreamResult,
+  LanguageModelV3StreamPart,
+  LanguageModelV3Prompt,
+  LanguageModelV3Content,
+  LanguageModelV3Usage,
+  LanguageModelV3FinishReason,
+} from '@ai-sdk/provider';
+import type { ISmartAiOptions, IOllamaModelOptions } from './smartai.interfaces.js';
+
+interface IOllamaMessage {
+  role: string;
+  content: string;
+  images?: string[];
+  tool_calls?: Array<{
+    function: { name: string; arguments: Record<string, unknown> };
+  }>;
+  thinking?: string;
+}
+
+interface IOllamaTool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+/**
+ * Convert AI SDK V3 prompt messages to Ollama's message format.
+ */
+function convertPromptToOllamaMessages(prompt: LanguageModelV3Prompt): IOllamaMessage[] {
+  const messages: IOllamaMessage[] = [];
+
+  for (const msg of prompt) {
+    if (msg.role === 'system') {
+      // System message content is a plain string in V3
+      messages.push({ role: 'system', content: msg.content });
+    } else if (msg.role === 'user') {
+      let text = '';
+      const images: string[] = [];
+      for (const part of msg.content) {
+        if (part.type === 'text') {
+          text += part.text;
+        } else if (part.type === 'file' && part.mediaType?.startsWith('image/')) {
+          // Handle image files — Ollama expects base64 images
+          if (typeof part.data === 'string') {
+            images.push(part.data);
+          } else if (part.data instanceof Uint8Array) {
+            images.push(Buffer.from(part.data).toString('base64'));
+          }
+        }
+      }
+      const m: IOllamaMessage = { role: 'user', content: text };
+      if (images.length > 0) m.images = images;
+      messages.push(m);
+    } else if (msg.role === 'assistant') {
+      let text = '';
+      let thinking = '';
+      const toolCalls: IOllamaMessage['tool_calls'] = [];
+      for (const part of msg.content) {
+        if (part.type === 'text') {
+          text += part.text;
+        } else if (part.type === 'reasoning') {
+          thinking += part.text;
+        } else if (part.type === 'tool-call') {
+          const args = typeof part.input === 'string'
+            ? JSON.parse(part.input as string)
+            : (part.input as Record<string, unknown>);
+          toolCalls.push({
+            function: {
+              name: part.toolName,
+              arguments: args,
+            },
+          });
+        }
+      }
+      const m: IOllamaMessage = { role: 'assistant', content: text };
+      if (toolCalls.length > 0) m.tool_calls = toolCalls;
+      if (thinking) m.thinking = thinking;
+      messages.push(m);
+    } else if (msg.role === 'tool') {
+      for (const part of msg.content) {
+        if (part.type === 'tool-result') {
+          let resultContent = '';
+          if (part.output) {
+            if (part.output.type === 'text') {
+              resultContent = part.output.value;
+            } else if (part.output.type === 'json') {
+              resultContent = JSON.stringify(part.output.value);
+            }
+          }
+          messages.push({ role: 'tool', content: resultContent });
+        }
+      }
+    }
+  }
+
+  return messages;
+}
+
+/**
+ * Convert AI SDK V3 tools to Ollama's tool format.
+ */
+function convertToolsToOllamaTools(tools: LanguageModelV3CallOptions['tools']): IOllamaTool[] | undefined {
+  if (!tools || tools.length === 0) return undefined;
+
+  return tools
+    .filter((t): t is Extract<typeof t, { type: 'function' }> => t.type === 'function')
+    .map(t => ({
+      type: 'function' as const,
+      function: {
+        name: t.name,
+        description: t.description ?? '',
+        parameters: t.inputSchema as Record<string, unknown>,
+      },
+    }));
+}
+
+function makeUsage(promptTokens?: number, completionTokens?: number): LanguageModelV3Usage {
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: undefined,
+      cacheRead: undefined,
+      cacheWrite: undefined,
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: completionTokens,
+      reasoning: undefined,
+    },
+  };
+}
+
+function makeFinishReason(reason?: string): LanguageModelV3FinishReason {
+  if (reason === 'tool_calls' || reason === 'tool-calls') {
+    return { unified: 'tool-calls', raw: reason };
+  }
+  return { unified: 'stop', raw: reason ?? 'stop' };
+}
+
+let idCounter = 0;
+function generateId(): string {
+  return `ollama-${Date.now()}-${idCounter++}`;
+}
+
+/**
+ * Custom LanguageModelV3 implementation for Ollama.
+ * Calls Ollama's native /api/chat endpoint directly to support
+ * think, num_ctx, temperature, and other model options.
+ */
+export function createOllamaModel(options: ISmartAiOptions): LanguageModelV3 {
+  const baseUrl = options.baseUrl ?? 'http://localhost:11434';
+  const modelId = options.model;
+  const ollamaOpts: IOllamaModelOptions = { ...options.ollamaOptions };
+
+  // Apply default temperature of 0.55 for Qwen models
+  if (modelId.toLowerCase().includes('qwen') && ollamaOpts.temperature === undefined) {
+    ollamaOpts.temperature = 0.55;
+  }
+
+  const model: LanguageModelV3 = {
+    specificationVersion: 'v3',
+    provider: 'ollama',
+    modelId,
+    supportedUrls: {},
+
+    async doGenerate(callOptions: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult> {
+      const messages = convertPromptToOllamaMessages(callOptions.prompt);
+      const tools = convertToolsToOllamaTools(callOptions.tools);
+
+      const ollamaModelOptions: Record<string, unknown> = { ...ollamaOpts };
+      // Override with call-level options if provided
+      if (callOptions.temperature !== undefined) ollamaModelOptions.temperature = callOptions.temperature;
+      if (callOptions.topP !== undefined) ollamaModelOptions.top_p = callOptions.topP;
+      if (callOptions.topK !== undefined) ollamaModelOptions.top_k = callOptions.topK;
+      if (callOptions.maxOutputTokens !== undefined) ollamaModelOptions.num_predict = callOptions.maxOutputTokens;
+      if (callOptions.seed !== undefined) ollamaModelOptions.seed = callOptions.seed;
+      if (callOptions.stopSequences) ollamaModelOptions.stop = callOptions.stopSequences;
+      // Remove think from options — it goes at the top level
+      const { think, ...modelOpts } = ollamaModelOptions;
+
+      const requestBody: Record<string, unknown> = {
+        model: modelId,
+        messages,
+        stream: false,
+        options: modelOpts,
+      };
+
+      // Add think parameter at the top level (Ollama API requirement)
+      if (ollamaOpts.think !== undefined) {
+        requestBody.think = ollamaOpts.think;
+      }
+
+      if (tools) requestBody.tools = tools;
+
+      const response = await fetch(`${baseUrl}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(requestBody),
+        signal: callOptions.abortSignal,
+      });
+
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Ollama API error ${response.status}: ${body}`);
+      }
+
+      const result = await response.json() as Record<string, unknown>;
+      const message = result.message as Record<string, unknown>;
+
+      // Build content array
+      const content: LanguageModelV3Content[] = [];
+
+      // Add reasoning if present
+      if (message.thinking && typeof message.thinking === 'string') {
+        content.push({ type: 'reasoning', text: message.thinking });
+      }
+
+      // Add text content
+      if (message.content && typeof message.content === 'string') {
+        content.push({ type: 'text', text: message.content });
+      }
+
+      // Add tool calls if present
+      if (Array.isArray(message.tool_calls)) {
+        for (const tc of message.tool_calls as Array<Record<string, unknown>>) {
+          const fn = tc.function as Record<string, unknown>;
+          content.push({
+            type: 'tool-call',
+            toolCallId: generateId(),
+            toolName: fn.name as string,
+            input: JSON.stringify(fn.arguments),
+          });
+        }
+      }
+
+      const finishReason = Array.isArray(message.tool_calls) && (message.tool_calls as unknown[]).length > 0
+        ? makeFinishReason('tool_calls')
+        : makeFinishReason('stop');
+
+      return {
+        content,
+        finishReason,
+        usage: makeUsage(
+          (result.prompt_eval_count as number) ?? undefined,
+          (result.eval_count as number) ?? undefined,
+        ),
+        warnings: [],
+        request: { body: requestBody },
+      };
+    },
+
+    async doStream(callOptions: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult> {
+      const messages = convertPromptToOllamaMessages(callOptions.prompt);
+      const tools = convertToolsToOllamaTools(callOptions.tools);
+
+      const ollamaModelOptions: Record<string, unknown> = { ...ollamaOpts };
+      if (callOptions.temperature !== undefined) ollamaModelOptions.temperature = callOptions.temperature;
+      if (callOptions.topP !== undefined) ollamaModelOptions.top_p = callOptions.topP;
+      if (callOptions.topK !== undefined) ollamaModelOptions.top_k = callOptions.topK;
+      if (callOptions.maxOutputTokens !== undefined) ollamaModelOptions.num_predict = callOptions.maxOutputTokens;
+      if (callOptions.seed !== undefined) ollamaModelOptions.seed = callOptions.seed;
+      if (callOptions.stopSequences) ollamaModelOptions.stop = callOptions.stopSequences;
+      const { think, ...modelOpts } = ollamaModelOptions;
+
+      const requestBody: Record<string, unknown> = {
+        model: modelId,
+        messages,
+        stream: true,
+        options: modelOpts,
+      };
+
+      if (ollamaOpts.think !== undefined) {
+        requestBody.think = ollamaOpts.think;
+      }
+
+      if (tools) requestBody.tools = tools;
+
+      const response = await fetch(`${baseUrl}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(requestBody),
+        signal: callOptions.abortSignal,
+      });
+
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Ollama API error ${response.status}: ${body}`);
+      }
+
+      const reader = response.body!.getReader();
+      const decoder = new TextDecoder();
+
+      const textId = generateId();
+      const reasoningId = generateId();
+      let textStarted = false;
+      let reasoningStarted = false;
+      let hasToolCalls = false;
+      let closed = false;
+
+      const stream = new ReadableStream<LanguageModelV3StreamPart>({
+        async pull(controller) {
+          if (closed) return;
+
+          const processLine = (line: string) => {
+            if (!line.trim()) return;
+            let json: Record<string, unknown>;
+            try {
+              json = JSON.parse(line);
+            } catch {
+              return;
+            }
+
+            const msg = json.message as Record<string, unknown> | undefined;
+
+            // Handle thinking/reasoning content
+            if (msg?.thinking && typeof msg.thinking === 'string') {
+              if (!reasoningStarted) {
+                reasoningStarted = true;
+                controller.enqueue({ type: 'reasoning-start', id: reasoningId });
+              }
+              controller.enqueue({ type: 'reasoning-delta', id: reasoningId, delta: msg.thinking });
+            }
+
+            // Handle text content
+            if (msg?.content && typeof msg.content === 'string') {
+              if (reasoningStarted && !textStarted) {
+                controller.enqueue({ type: 'reasoning-end', id: reasoningId });
+              }
+              if (!textStarted) {
+                textStarted = true;
+                controller.enqueue({ type: 'text-start', id: textId });
+              }
+              controller.enqueue({ type: 'text-delta', id: textId, delta: msg.content });
+            }
+
+            // Handle tool calls
+            if (Array.isArray(msg?.tool_calls)) {
+              hasToolCalls = true;
+              for (const tc of msg!.tool_calls as Array<Record<string, unknown>>) {
+                const fn = tc.function as Record<string, unknown>;
+                const callId = generateId();
+                controller.enqueue({
+                  type: 'tool-call',
+                  toolCallId: callId,
+                  toolName: fn.name as string,
+                  input: JSON.stringify(fn.arguments),
+                });
+              }
+            }
+
+            // Handle done
+            if (json.done) {
+              if (reasoningStarted && !textStarted) {
+                controller.enqueue({ type: 'reasoning-end', id: reasoningId });
+              }
+              if (textStarted) {
+                controller.enqueue({ type: 'text-end', id: textId });
+              }
+              controller.enqueue({
+                type: 'finish',
+                finishReason: hasToolCalls
+                  ? makeFinishReason('tool_calls')
+                  : makeFinishReason('stop'),
+                usage: makeUsage(
+                  (json.prompt_eval_count as number) ?? undefined,
+                  (json.eval_count as number) ?? undefined,
+                ),
+              });
+              closed = true;
+              controller.close();
+            }
+          };
+
+          try {
+            let buffer = '';
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                if (buffer.trim()) processLine(buffer);
+                if (!closed) {
+                  controller.enqueue({
+                    type: 'finish',
+                    finishReason: makeFinishReason('stop'),
+                    usage: makeUsage(undefined, undefined),
+                  });
+                  closed = true;
+                  controller.close();
+                }
+                return;
+              }
+
+              buffer += decoder.decode(value, { stream: true });
+              const lines = buffer.split('\n');
+              buffer = lines.pop() || '';
+              for (const line of lines) {
+                processLine(line);
+                if (closed) return;
+              }
+            }
+          } catch (error) {
+            if (!closed) {
+              controller.error(error);
+              closed = true;
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        },
+      });
+
+      return {
+        stream,
+        request: { body: requestBody },
+      };
+    },
+  };
+
+  return model;
+}

package/ts_audio/index.ts

@@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+import { Readable } from 'stream';
+
+export interface IOpenAiTtsOptions {
+  apiKey: string;
+  text: string;
+  voice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+  model?: 'tts-1' | 'tts-1-hd';
+  responseFormat?: 'mp3' | 'opus' | 'aac' | 'flac';
+  speed?: number;
+}
+
+export async function textToSpeech(options: IOpenAiTtsOptions): Promise<NodeJS.ReadableStream> {
+  const client = new plugins.OpenAI({ apiKey: options.apiKey });
+  const result = await client.audio.speech.create({
+    model: options.model ?? 'tts-1',
+    voice: options.voice ?? 'alloy',
+    input: options.text,
+    response_format: options.responseFormat ?? 'mp3',
+    speed: options.speed ?? 1,
+  });
+  const stream = result.body;
+  return Readable.fromWeb(stream as any);
+}

package/ts_audio/plugins.ts

@@ -0,0 +1,2 @@
+import OpenAI from 'openai';
+export { OpenAI };