@yourgpt/llm-sdk 2.1.4-alpha.1 → 2.1.4-alpha.3

package/dist/types-VDgiUvH2.d.mts

@@ -0,0 +1,355 @@
+import { L as LLMAdapter, T as ToolDefinition, U as UnifiedToolCall, h as UnifiedToolResult } from './base-5n-UuPfS.mjs';
+
+/**
+ * Provider Types
+ *
+ * Defines interfaces for:
+ * 1. Provider Formatters (for tool transformations in agent loop)
+ * 2. Multi-provider architecture (AIProvider, capabilities, configs)
+ */
+
+/**
+ * Provider formatter interface
+ *
+ * Each provider implements this interface to handle:
+ * - Tool definition transformation
+ * - Tool call parsing from responses
+ * - Tool result formatting
+ * - Stop reason detection
+ */
+interface ProviderFormatter {
+    /**
+     * Transform unified tool definitions to provider format
+     */
+    transformTools(tools: ToolDefinition[]): unknown[];
+    /**
+     * Parse tool calls from provider response
+     */
+    parseToolCalls(response: unknown): UnifiedToolCall[];
+    /**
+     * Format tool results for provider
+     */
+    formatToolResults(results: UnifiedToolResult[]): unknown[];
+    /**
+     * Check if response indicates tool use is requested
+     */
+    isToolUseStop(response: unknown): boolean;
+    /**
+     * Check if response indicates end of turn
+     */
+    isEndTurnStop(response: unknown): boolean;
+    /**
+     * Get stop reason string from response
+     */
+    getStopReason(response: unknown): string;
+    /**
+     * Extract text content from response
+     */
+    extractTextContent(response: unknown): string;
+    /**
+     * Build assistant message with tool calls for conversation history
+     */
+    buildAssistantToolMessage(toolCalls: UnifiedToolCall[], textContent?: string): unknown;
+    /**
+     * Build user message with tool results for conversation history
+     */
+    buildToolResultMessage(results: UnifiedToolResult[]): unknown;
+}
+/**
+ * Anthropic tool definition format
+ */
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Anthropic tool_use block from response
+ */
+interface AnthropicToolUse {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Anthropic tool_result block
+ */
+interface AnthropicToolResult {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+}
+/**
+ * OpenAI tool definition format
+ */
+interface OpenAITool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    };
+}
+/**
+ * OpenAI tool call from response
+ */
+interface OpenAIToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * OpenAI tool result message
+ */
+interface OpenAIToolResult {
+    role: "tool";
+    tool_call_id: string;
+    content: string;
+}
+/**
+ * Google Gemini function declaration
+ */
+interface GeminiFunctionDeclaration {
+    name: string;
+    description: string;
+    parameters?: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Gemini function call from response
+ */
+interface GeminiFunctionCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+/**
+ * Gemini function response
+ */
+interface GeminiFunctionResponse {
+    name: string;
+    response: Record<string, unknown>;
+}
+/**
+ * Capabilities of a model for UI feature flags
+ * UI components can use this to enable/disable features
+ */
+interface ProviderCapabilities {
+    /** Supports image inputs */
+    supportsVision: boolean;
+    /** Supports tool/function calling */
+    supportsTools: boolean;
+    /** Supports extended thinking (Claude, DeepSeek) */
+    supportsThinking: boolean;
+    /** Supports streaming responses */
+    supportsStreaming: boolean;
+    /** Supports PDF document inputs */
+    supportsPDF: boolean;
+    /** Supports audio inputs */
+    supportsAudio: boolean;
+    /** Supports video inputs */
+    supportsVideo: boolean;
+    /** Maximum context tokens */
+    maxTokens: number;
+    /** Supported image MIME types */
+    supportedImageTypes: string[];
+    /** Supported audio MIME types */
+    supportedAudioTypes?: string[];
+    /** Supported video MIME types */
+    supportedVideoTypes?: string[];
+    /** Supports JSON mode / structured output */
+    supportsJsonMode?: boolean;
+    /** Supports system messages */
+    supportsSystemMessages?: boolean;
+}
+/**
+ * AI Provider interface (object form)
+ *
+ * Wraps existing LLMAdapter with additional metadata:
+ * - Supported models list
+ * - Per-model capabilities
+ * - Provider name
+ */
+interface AIProviderObject {
+    /** Provider name (e.g., 'openai', 'anthropic') */
+    readonly name: string;
+    /** List of supported model IDs */
+    readonly supportedModels: string[];
+    /**
+     * Get a language model adapter for the given model ID
+     * Returns the existing LLMAdapter interface - no breaking changes
+     */
+    languageModel(modelId: string): LLMAdapter;
+    /**
+     * Get capabilities for a specific model
+     * UI components use this to enable/disable features
+     */
+    getCapabilities(modelId: string): ProviderCapabilities;
+    /**
+     * Optional: Get an embedding model (future expansion)
+     */
+    embeddingModel?(modelId: string): EmbeddingModel;
+}
+/**
+ * Callable AI Provider (Vercel AI SDK style)
+ *
+ * A function that returns a LanguageModel when called with a model ID,
+ * but also has properties for provider metadata and methods.
+ *
+ * @example
+ * ```typescript
+ * const openai = createOpenAI({ apiKey: '...' });
+ *
+ * // Callable - returns LanguageModel directly (Vercel AI SDK style)
+ * const model = openai('gpt-4o');
+ *
+ * // Also supports method calls (backward compatible)
+ * const model2 = openai.languageModel('gpt-4o');
+ *
+ * // Check capabilities
+ * const caps = openai.getCapabilities('gpt-4o');
+ * if (caps.supportsVision) {
+ *   // Show image upload button
+ * }
+ * ```
+ */
+interface AIProvider extends AIProviderObject {
+    /**
+     * Call the provider directly with a model ID to get a LanguageModel
+     * This is the Vercel AI SDK style pattern
+     */
+    (modelId: string): LLMAdapter;
+}
+/**
+ * Embedding model interface (for future expansion)
+ */
+interface EmbeddingModel {
+    readonly provider: string;
+    readonly modelId: string;
+    embed(texts: string[]): Promise<number[][]>;
+}
+/**
+ * Base provider configuration
+ */
+interface BaseProviderConfig {
+    /** API key (falls back to environment variable) */
+    apiKey?: string;
+    /** Custom base URL */
+    baseUrl?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Custom headers to include */
+    headers?: Record<string, string>;
+}
+/**
+ * OpenAI provider configuration
+ */
+interface OpenAIProviderConfig extends BaseProviderConfig {
+    /** OpenAI organization ID */
+    organization?: string;
+    /** OpenAI project ID */
+    project?: string;
+    /** Vision detail level for images */
+    imageDetail?: "auto" | "low" | "high";
+}
+/**
+ * Anthropic provider configuration
+ */
+interface AnthropicProviderConfig extends BaseProviderConfig {
+    /** Extended thinking budget in tokens (minimum 1024) */
+    thinkingBudget?: number;
+    /** Enable prompt caching */
+    cacheControl?: boolean;
+}
+/**
+ * Google provider configuration
+ */
+interface GoogleProviderConfig extends BaseProviderConfig {
+    /** Safety settings */
+    safetySettings?: GoogleSafetySetting[];
+    /** Grounding configuration (for web search) */
+    groundingConfig?: GoogleGroundingConfig;
+}
+/**
+ * Google safety setting
+ */
+interface GoogleSafetySetting {
+    category: "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_DANGEROUS_CONTENT";
+    threshold: "BLOCK_NONE" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_HIGH_AND_ABOVE";
+}
+/**
+ * Google grounding configuration
+ */
+interface GoogleGroundingConfig {
+    /** Enable Google Search grounding */
+    googleSearchRetrieval?: boolean;
+}
+/**
+ * xAI provider configuration
+ */
+interface XAIProviderConfig extends BaseProviderConfig {
+}
+/**
+ * Azure OpenAI provider configuration
+ */
+interface AzureProviderConfig extends BaseProviderConfig {
+    /** Azure resource name */
+    resourceName: string;
+    /** Deployment name */
+    deploymentName: string;
+    /** API version (default: 2024-02-15-preview) */
+    apiVersion?: string;
+}
+/**
+ * Ollama model-specific options
+ * These map to Ollama's native API options
+ */
+interface OllamaModelOptions {
+    /** Context window size (default varies by model) */
+    num_ctx?: number;
+    /** Max tokens to predict (-1 = infinite, -2 = fill context) */
+    num_predict?: number;
+    /** Mirostat sampling (0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0) */
+    mirostat?: 0 | 1 | 2;
+    /** Mirostat learning rate (default: 0.1) */
+    mirostat_eta?: number;
+    /** Mirostat target entropy (default: 5.0) */
+    mirostat_tau?: number;
+    /** Repeat penalty (default: 1.1) */
+    repeat_penalty?: number;
+    /** Random seed for reproducibility (-1 = random) */
+    seed?: number;
+    /** Top-k sampling (default: 40) */
+    top_k?: number;
+    /** Top-p (nucleus) sampling (default: 0.9) */
+    top_p?: number;
+    /** Min-p sampling (default: 0.0) */
+    min_p?: number;
+    /** Stop sequences */
+    stop?: string[];
+    /** Temperature override (also available in config) */
+    temperature?: number;
+}
+/**
+ * Ollama provider configuration
+ */
+interface OllamaProviderConfig extends BaseProviderConfig {
+    /** Default Ollama-specific model options */
+    options?: OllamaModelOptions;
+}
+
+export type { AIProvider as A, BaseProviderConfig as B, GoogleProviderConfig as G, OpenAIProviderConfig as O, ProviderCapabilities as P, XAIProviderConfig as X, AnthropicProviderConfig as a, AzureProviderConfig as b, OllamaProviderConfig as c, OllamaModelOptions as d, ProviderFormatter as e, AnthropicTool as f, AnthropicToolUse as g, AnthropicToolResult as h, OpenAITool as i, OpenAIToolCall as j, OpenAIToolResult as k, GeminiFunctionDeclaration as l, GeminiFunctionCall as m, GeminiFunctionResponse as n };

package/dist/yourgpt/index.d.mts

@@ -0,0 +1,77 @@
+import { e as StorageMessage, d as StorageAdapter, v as StorageFile } from '../types-CR8mi9I0.mjs';
+import 'zod';
+
+/**
+ * @yourgpt/llm-sdk/yourgpt
+ *
+ * YourGPT platform integration — session & message persistence.
+ * Implements the generic StorageAdapter interface.
+ *
+ * @example
+ * ```ts
+ * import { createRuntime } from '@yourgpt/llm-sdk'
+ * import { createYourGPT } from '@yourgpt/llm-sdk/yourgpt'
+ *
+ * const yourgpt = createYourGPT({ apiKey, widgetUid })
+ * const runtime = createRuntime({ provider, model, storage: yourgpt })
+ *
+ * // That's it — runtime auto-creates sessions and persists messages.
+ * app.post('/api/copilot/chat', runtime.expressHandler())
+ * ```
+ */
+
+interface YourGPTConfig {
+    /** Your YourGPT API key — server-side only, never expose to browser */
+    apiKey: string;
+    /** Widget UID — scopes all sessions to this project */
+    widgetUid: string;
+    /** Override API base URL. Defaults to https://api.yourgpt.ai */
+    endpoint?: string;
+    /**
+     * Error handler — called when any adapter operation fails.
+     * Receives the error and the operation name (createSession, saveMessages, uploadFile).
+     * If not provided, errors are thrown to the caller.
+     *
+     * @example
+     * ```ts
+     * onError: (error, operation, params) => {
+     *   logger.error(`[YourGPT] ${operation} failed:`, error, params);
+     *   Sentry.captureException(error, { tags: { operation }, extra: params });
+     * }
+     * ```
+     */
+    onError?: (error: Error, operation: string, params?: Record<string, unknown>) => void;
+}
+/** @deprecated Use `YourGPTConfig` instead */
+type YourGPTAdapterConfig = YourGPTConfig;
+interface YourGPTSession {
+    /** Use this as threadId in subsequent chat requests */
+    id: string;
+    title?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** @deprecated Use `StorageMessage` from `@yourgpt/llm-sdk` instead */
+type NewYourGPTMessage = StorageMessage;
+interface CreateSessionData {
+    title?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * YourGPT platform adapter.
+ * Extends StorageAdapter with richer session return type.
+ */
+interface YourGPT extends StorageAdapter {
+    createSession(data?: CreateSessionData): Promise<YourGPTSession>;
+    saveMessages(sessionId: string, messages: StorageMessage[]): Promise<void>;
+    uploadFile(file: StorageFile): Promise<{
+        url: string;
+    }>;
+}
+/** @deprecated Use `YourGPT` instead */
+type YourGPTAdapter = YourGPT;
+declare function createYourGPT(config: YourGPTConfig): YourGPT;
+/** @deprecated Use `createYourGPT` instead */
+declare const createYourGPTAdapter: typeof createYourGPT;
+
+export { type CreateSessionData, type NewYourGPTMessage, type YourGPT, type YourGPTAdapter, type YourGPTAdapterConfig, type YourGPTConfig, type YourGPTSession, createYourGPT, createYourGPTAdapter };

package/dist/yourgpt/index.d.ts

@@ -0,0 +1,77 @@
+import { e as StorageMessage, d as StorageAdapter, v as StorageFile } from '../types-CR8mi9I0.js';
+import 'zod';
+
+/**
+ * @yourgpt/llm-sdk/yourgpt
+ *
+ * YourGPT platform integration — session & message persistence.
+ * Implements the generic StorageAdapter interface.
+ *
+ * @example
+ * ```ts
+ * import { createRuntime } from '@yourgpt/llm-sdk'
+ * import { createYourGPT } from '@yourgpt/llm-sdk/yourgpt'
+ *
+ * const yourgpt = createYourGPT({ apiKey, widgetUid })
+ * const runtime = createRuntime({ provider, model, storage: yourgpt })
+ *
+ * // That's it — runtime auto-creates sessions and persists messages.
+ * app.post('/api/copilot/chat', runtime.expressHandler())
+ * ```
+ */
+
+interface YourGPTConfig {
+    /** Your YourGPT API key — server-side only, never expose to browser */
+    apiKey: string;
+    /** Widget UID — scopes all sessions to this project */
+    widgetUid: string;
+    /** Override API base URL. Defaults to https://api.yourgpt.ai */
+    endpoint?: string;
+    /**
+     * Error handler — called when any adapter operation fails.
+     * Receives the error and the operation name (createSession, saveMessages, uploadFile).
+     * If not provided, errors are thrown to the caller.
+     *
+     * @example
+     * ```ts
+     * onError: (error, operation, params) => {
+     *   logger.error(`[YourGPT] ${operation} failed:`, error, params);
+     *   Sentry.captureException(error, { tags: { operation }, extra: params });
+     * }
+     * ```
+     */
+    onError?: (error: Error, operation: string, params?: Record<string, unknown>) => void;
+}
+/** @deprecated Use `YourGPTConfig` instead */
+type YourGPTAdapterConfig = YourGPTConfig;
+interface YourGPTSession {
+    /** Use this as threadId in subsequent chat requests */
+    id: string;
+    title?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** @deprecated Use `StorageMessage` from `@yourgpt/llm-sdk` instead */
+type NewYourGPTMessage = StorageMessage;
+interface CreateSessionData {
+    title?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * YourGPT platform adapter.
+ * Extends StorageAdapter with richer session return type.
+ */
+interface YourGPT extends StorageAdapter {
+    createSession(data?: CreateSessionData): Promise<YourGPTSession>;
+    saveMessages(sessionId: string, messages: StorageMessage[]): Promise<void>;
+    uploadFile(file: StorageFile): Promise<{
+        url: string;
+    }>;
+}
+/** @deprecated Use `YourGPT` instead */
+type YourGPTAdapter = YourGPT;
+declare function createYourGPT(config: YourGPTConfig): YourGPT;
+/** @deprecated Use `createYourGPT` instead */
+declare const createYourGPTAdapter: typeof createYourGPT;
+
+export { type CreateSessionData, type NewYourGPTMessage, type YourGPT, type YourGPTAdapter, type YourGPTAdapterConfig, type YourGPTConfig, type YourGPTSession, createYourGPT, createYourGPTAdapter };

package/dist/yourgpt/index.js

@@ -0,0 +1,167 @@
+'use strict';
+
+// src/yourgpt/index.ts
+function createYourGPT(config) {
+  const base = (config.endpoint ?? "https://api.yourgpt.ai").replace(/\/$/, "");
+  const headers = {
+    "Content-Type": "application/json",
+    "api-key": config.apiKey
+  };
+  const onError = config.onError;
+  async function call(path, body = {}) {
+    const payload = { widget_uid: config.widgetUid, ...body };
+    const res = await fetch(`${base}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => res.statusText);
+      throw new Error(`YourGPT API [${res.status}] ${path}: ${text}`);
+    }
+    return res.json();
+  }
+  async function safe(operation, params, fn) {
+    try {
+      return await fn();
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (onError) {
+        onError(error, operation, params);
+      }
+      throw error;
+    }
+  }
+  return {
+    async createSession(data = {}) {
+      return safe("createSession", { title: data.title }, async () => {
+        const raw = await call(
+          "/chatbot/v1/copilot-sdk/createSession",
+          data
+        );
+        const d = raw.data ?? raw;
+        return {
+          id: String(d.session_uid ?? d.id),
+          title: d.title ?? void 0,
+          createdAt: new Date(d.createdAt ?? d.created_at),
+          updatedAt: new Date(d.updatedAt ?? d.updated_at)
+        };
+      });
+    },
+    async saveMessages(sessionId, messages) {
+      return safe(
+        "saveMessages",
+        {
+          sessionId,
+          messageCount: messages.length,
+          roles: messages.map((m) => m.role)
+        },
+        async () => {
+          const num = Number(sessionId);
+          const sessionUid = Number.isSafeInteger(num) ? num : sessionId;
+          const toolResults = /* @__PURE__ */ new Map();
+          for (const msg of messages) {
+            if (msg.role === "tool" && msg.toolCallId) {
+              toolResults.set(msg.toolCallId, msg.content ?? "");
+            }
+          }
+          for (const msg of messages) {
+            if (msg.role === "tool") {
+              continue;
+            } else if (msg.role === "assistant" && msg.toolCalls?.length) {
+              if (msg.content) {
+                await call("/chatbot/v1/copilot-sdk/createMessage", {
+                  session_uid: sessionUid,
+                  message: msg.content,
+                  send_by: "assistant",
+                  content_type: "text"
+                });
+              }
+              for (const tc of msg.toolCalls) {
+                const toolName = tc.function?.name ?? "unknown";
+                let toolArgs = {};
+                try {
+                  toolArgs = typeof tc.function?.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function?.arguments ?? {};
+                } catch {
+                }
+                const response = tc.id ? toolResults.get(tc.id) ?? null : null;
+                await call("/chatbot/v1/copilot-sdk/createToolMessage", {
+                  session_uid: sessionUid,
+                  skill: "copilot-tool",
+                  extra_data: {
+                    tool_name: toolName,
+                    tool_arguments: toolArgs,
+                    tool_call_id: tc.id ?? null,
+                    status: "completed",
+                    tool_response: response
+                  }
+                });
+              }
+            } else if (msg.role === "user" || msg.role === "assistant") {
+              await call("/chatbot/v1/copilot-sdk/createMessage", {
+                session_uid: sessionUid,
+                message: msg.content,
+                send_by: msg.role === "user" ? "user" : "assistant",
+                content_type: msg.contentType || "text",
+                ...msg.url ? { url: msg.url } : {}
+              });
+            }
+          }
+        }
+      );
+    },
+    async uploadFile(file) {
+      return safe(
+        "uploadFile",
+        {
+          filename: file.filename,
+          mimeType: file.mimeType,
+          dataLength: file.data?.length
+        },
+        async () => {
+          const raw = await call("/chatbot/v1/copilot-sdk/getSignedUrl", {
+            file_name: file.filename || `upload_${Date.now()}`
+          });
+          const signedUrl = raw.data?.upload_url ?? raw.data?.url ?? raw.url;
+          const successUrl = raw.data?.file_url ?? raw.data?.success_url ?? raw.success_url;
+          if (!signedUrl) {
+            throw new Error(
+              "uploadFile: no signed URL in response \u2014 " + JSON.stringify(raw)
+            );
+          }
+          let body;
+          let rawData = file.data;
+          const dataUriMatch = rawData.match(/^data:[^;]+;base64,(.+)$/);
+          if (dataUriMatch) rawData = dataUriMatch[1];
+          if (typeof Buffer !== "undefined") {
+            body = Buffer.from(rawData, "base64");
+          } else {
+            const binary = atob(rawData);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++)
+              bytes[i] = binary.charCodeAt(i);
+            body = new Blob([bytes], { type: file.mimeType });
+          }
+          const uploadRes = await fetch(signedUrl, {
+            method: "PUT",
+            headers: { "Content-Type": file.mimeType },
+            body
+          });
+          if (!uploadRes.ok) {
+            throw new Error(
+              `uploadFile: PUT to signed URL failed with ${uploadRes.status}`
+            );
+          }
+          const finalUrl = successUrl || signedUrl.split("?")[0];
+          return { url: finalUrl };
+        }
+      );
+    }
+  };
+}
+var createYourGPTAdapter = createYourGPT;
+
+exports.createYourGPT = createYourGPT;
+exports.createYourGPTAdapter = createYourGPTAdapter;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map