@yourgpt/llm-sdk 2.1.4-alpha.0 → 2.1.4-alpha.2

package/dist/{types-COAOEe_y.d.ts → types-DtPQaoJi.d.ts}

@@ -1,346 +1,4 @@
-import { z } from 'zod';
-
-/**
- * Core Types for @yourgpt/llm-sdk
- *
- * Modern, instance-based types following Vercel AI SDK patterns.
- */
-
-/**
- * A language model instance that can generate text.
- * This is what provider functions like `openai('gpt-4o')` return.
- */
-interface LanguageModel {
-    /** Provider identifier (e.g., 'openai', 'anthropic') */
-    readonly provider: string;
-    /** Model identifier (e.g., 'gpt-4o', 'claude-3-5-sonnet') */
-    readonly modelId: string;
-    /** Model capabilities for feature detection */
-    readonly capabilities: ModelCapabilities;
-    /**
-     * Generate a complete response (non-streaming)
-     * Used internally by generateText()
-     */
-    doGenerate(params: DoGenerateParams): Promise<DoGenerateResult>;
-    /**
-     * Stream a response
-     * Used internally by streamText()
-     */
-    doStream(params: DoGenerateParams): AsyncGenerator<StreamChunk>;
-}
-/**
- * Model capabilities for UI feature flags
- */
-interface ModelCapabilities {
-    /** Supports image inputs */
-    supportsVision: boolean;
-    /** Supports tool/function calling */
-    supportsTools: boolean;
-    /** Supports streaming responses */
-    supportsStreaming: boolean;
-    /** Supports JSON mode / structured output */
-    supportsJsonMode: boolean;
-    /** Supports extended thinking (Claude) */
-    supportsThinking: boolean;
-    /** Supports PDF document inputs */
-    supportsPDF: boolean;
-    /** Maximum context tokens */
-    maxTokens: number;
-    /** Supported image MIME types */
-    supportedImageTypes: string[];
-}
-/**
- * Default capabilities for unknown models
- */
-declare const DEFAULT_CAPABILITIES: ModelCapabilities;
-/**
- * Core message types for LLM conversations
- */
-type CoreMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
-interface SystemMessage {
-    role: "system";
-    content: string;
-}
-interface UserMessage {
-    role: "user";
-    content: string | UserContentPart[];
-}
-interface AssistantMessage {
-    role: "assistant";
-    content: string | null;
-    toolCalls?: ToolCall$1[];
-}
-interface ToolMessage {
-    role: "tool";
-    toolCallId: string;
-    content: string;
-}
-/**
- * Content parts for multimodal user messages
- */
-type UserContentPart = TextPart | ImagePart | FilePart;
-interface TextPart {
-    type: "text";
-    text: string;
-}
-interface ImagePart {
-    type: "image";
-    /** Base64 data or URL */
-    image: string | Uint8Array;
-    /** MIME type (e.g., 'image/png') */
-    mimeType?: string;
-}
-interface FilePart {
-    type: "file";
-    /** Base64 data or URL */
-    data: string;
-    /** MIME type (e.g., 'application/pdf') */
-    mimeType: string;
-}
-/**
- * Tool definition with Zod schema support
- */
-interface Tool<TParams = unknown, TResult = unknown> {
-    /** Tool description for the LLM */
-    description: string;
-    /** Zod schema for parameters */
-    parameters: z.ZodType<TParams>;
-    /** Execute function */
-    execute: (params: TParams, context: ToolContext$1) => Promise<TResult>;
-    /**
-     * Hide this tool's execution from the chat UI.
-     * When true, tool calls and results won't be displayed to the user,
-     * but the tool will still execute normally.
-     * @default false
-     */
-    hidden?: boolean;
-}
-/**
- * Context passed to tool execute function
- */
-interface ToolContext$1 {
-    /** Abort signal for cancellation */
-    abortSignal?: AbortSignal;
-    /** Unique tool call ID */
-    toolCallId: string;
-    /** Optional: messages in conversation */
-    messages?: CoreMessage[];
-}
-/**
- * Tool call from LLM response
- */
-interface ToolCall$1 {
-    /** Unique ID for this tool call */
-    id: string;
-    /** Tool name */
-    name: string;
-    /** Parsed arguments */
-    args: Record<string, unknown>;
-}
-/**
- * Tool execution result
- */
-interface ToolResult {
-    /** Tool call ID this result corresponds to */
-    toolCallId: string;
-    /** Result data (will be JSON stringified for LLM) */
-    result: unknown;
-}
-/**
- * Parameters for model.doGenerate() and model.doStream()
- */
-interface DoGenerateParams {
-    /** Messages to send to LLM */
-    messages: CoreMessage[];
-    /** Tools available to the LLM (already formatted for provider) */
-    tools?: unknown[];
-    /** Temperature (0-2) */
-    temperature?: number;
-    /** Maximum tokens to generate */
-    maxTokens?: number;
-    /** Abort signal */
-    signal?: AbortSignal;
-}
-/**
- * Result from model.doGenerate()
- */
-interface DoGenerateResult {
-    /** Generated text content */
-    text: string;
-    /** Tool calls requested by the LLM */
-    toolCalls: ToolCall$1[];
-    /** Why generation stopped */
-    finishReason: FinishReason;
-    /** Token usage */
-    usage: TokenUsage;
-    /** Raw provider response (for debugging) */
-    rawResponse?: unknown;
-}
-/**
- * Finish reason for generation
- */
-type FinishReason = "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown";
-/**
- * Token usage statistics
- */
-interface TokenUsage {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-}
-/**
- * Stream chunk from model.doStream()
- */
-type StreamChunk = TextDeltaChunk | ToolCallChunk | ToolResultChunk | FinishChunk | ErrorChunk;
-interface TextDeltaChunk {
-    type: "text-delta";
-    text: string;
-}
-interface ToolCallChunk {
-    type: "tool-call";
-    toolCall: ToolCall$1;
-}
-interface ToolResultChunk {
-    type: "tool-result";
-    toolCallId: string;
-    result: unknown;
-}
-interface FinishChunk {
-    type: "finish";
-    finishReason: FinishReason;
-    usage?: TokenUsage;
-}
-interface ErrorChunk {
-    type: "error";
-    error: Error;
-}
-/**
- * Parameters for generateText()
- */
-interface GenerateTextParams {
-    /** Language model to use */
-    model: LanguageModel;
-    /** Simple prompt (converted to user message) */
-    prompt?: string;
-    /** System prompt */
-    system?: string;
-    /** Full message history */
-    messages?: CoreMessage[];
-    /** Tools available to the LLM */
-    tools?: Record<string, Tool>;
-    /** Maximum agentic steps (tool call loops) */
-    maxSteps?: number;
-    /** Temperature (0-2) */
-    temperature?: number;
-    /** Maximum tokens to generate */
-    maxTokens?: number;
-    /** Abort signal */
-    signal?: AbortSignal;
-}
-/**
- * Result from generateText()
- */
-interface GenerateTextResult {
-    /** Final text output */
-    text: string;
-    /** Token usage */
-    usage: TokenUsage;
-    /** Why generation stopped */
-    finishReason: FinishReason;
-    /** All steps taken (for agentic workflows) */
-    steps: GenerateStep[];
-    /** All tool calls made across all steps */
-    toolCalls: ToolCall$1[];
-    /** All tool results across all steps */
-    toolResults: ToolResult[];
-    /** Final message list including tool interactions */
-    response: {
-        messages: CoreMessage[];
-    };
-}
-/**
- * A single step in the generation process
- */
-interface GenerateStep {
-    /** Text generated in this step */
-    text: string;
-    /** Tool calls made in this step */
-    toolCalls: ToolCall$1[];
-    /** Tool results from this step */
-    toolResults: ToolResult[];
-    /** Finish reason for this step */
-    finishReason: FinishReason;
-    /** Token usage for this step */
-    usage: TokenUsage;
-}
-/**
- * Parameters for streamText() - same as generateText
- */
-type StreamTextParams = GenerateTextParams;
-/**
- * Result from streamText()
- */
-interface StreamTextResult {
-    /** Async iterable of text chunks only */
-    textStream: AsyncIterable<string>;
-    /** Async iterable of all stream parts */
-    fullStream: AsyncIterable<StreamPart>;
-    /** Promise that resolves to full text when complete */
-    readonly text: Promise<string>;
-    /** Promise that resolves to usage when complete */
-    readonly usage: Promise<TokenUsage>;
-    /** Promise that resolves to finish reason when complete */
-    readonly finishReason: Promise<FinishReason>;
-    /** Convert to plain text streaming Response */
-    toTextStreamResponse(options?: ResponseOptions): Response;
-    /** Convert to data stream Response (SSE with tool calls) */
-    toDataStreamResponse(options?: ResponseOptions): Response;
-}
-/**
- * Stream part for fullStream
- */
-type StreamPart = {
-    type: "text-delta";
-    text: string;
-} | {
-    type: "tool-call-start";
-    toolCallId: string;
-    toolName: string;
-} | {
-    type: "tool-call-delta";
-    toolCallId: string;
-    argsText: string;
-} | {
-    type: "tool-call-complete";
-    toolCall: ToolCall$1;
-} | {
-    type: "tool-result";
-    toolCallId: string;
-    result: unknown;
-} | {
-    type: "step-start";
-    step: number;
-} | {
-    type: "step-finish";
-    step: number;
-    finishReason: FinishReason;
-} | {
-    type: "finish";
-    finishReason: FinishReason;
-    usage: TokenUsage;
-} | {
-    type: "error";
-    error: Error;
-};
-/**
- * Options for Response helpers
- */
-interface ResponseOptions {
-    /** Additional headers */
-    headers?: Record<string, string>;
-    /** Response status (default: 200) */
-    status?: number;
-}
+import { t as TokenUsage } from './types-CR8mi9I0.js';
 
 /**
  * Stream event types for llm-sdk
@@ -547,6 +205,8 @@ interface DoneEvent extends BaseEvent {
     messages?: DoneEventMessage[];
     /** Token usage (server-side only, stripped before sending to client) */
     usage?: TokenUsageRaw;
+    /** Session ID — present when storage adapter created a session for this request */
+    threadId?: string;
 }
 /**
  * Union of all stream events
@@ -1457,4 +1117,4 @@ interface OllamaProviderConfig extends BaseProviderConfig {
     options?: OllamaModelOptions;
 }
 
-export { type GoogleProviderConfig as $, type AIProvider as A, type ToolResultChunk as B, type CoreMessage as C, type DoneEventMessage as D, type FinishChunk as E, type FilePart as F, type GenerateTextParams as G, type ErrorChunk as H, type ImagePart as I, type TokenUsage as J, type KnowledgeBaseConfig as K, type LLMAdapter as L, type Message as M, type FinishReason as N, DEFAULT_CAPABILITIES as O, type ProviderToolRuntimeOptions as P, type ChatCompletionRequest as Q, type ResponseOptions as R, type StreamTextParams as S, type ToolContext$1 as T, type UserMessage as U, type AdapterFactory as V, type WebSearchConfig as W, type ProviderCapabilities as X, type BaseProviderConfig as Y, type OpenAIProviderConfig as Z, type AnthropicProviderConfig as _, type GenerateTextResult as a, type XAIProviderConfig as a0, type AzureProviderConfig as a1, type OllamaProviderConfig as a2, type OllamaModelOptions as a3, type ProviderFormatter as a4, type AnthropicTool as a5, type AnthropicToolUse as a6, type AnthropicToolResult as a7, type OpenAITool as a8, type OpenAIToolCall as a9, attachmentToOpenAIImage as aA, type AnthropicContentBlock as aB, type OpenAIContentBlock as aC, type OpenAIToolResult as aa, type GeminiFunctionDeclaration as ab, type GeminiFunctionCall as ac, type GeminiFunctionResponse as ad, type LLMConfig as ae, type ToolLocation as af, type UnifiedToolCall as ag, type UnifiedToolResult as ah, type ToolExecution as ai, type OpenAIToolSelectionHints as aj, type AnthropicToolSelectionHints as ak, type ToolNativeProviderHints as al, type OpenAIProviderToolOptions as am, type AnthropicProviderToolOptions as an, type Citation as ao, type CompletionResult as ap, formatMessages as aq, formatTools as ar, formatMessagesForAnthropic as as, formatMessagesForOpenAI as at, messageToAnthropicContent as au, messageToOpenAIContent as av, hasImageAttachments as aw, hasMediaAttachments as ax, attachmentToAnthropicImage as ay, attachmentToAnthropicDocument as az, type StreamTextResult as b, type Tool as c, type ActionDefinition as d, type ToolDefinition as e, type ToolProfile as f, type StreamEvent as g, type ToolCallInfo as h, type TokenUsageRaw as i, type ToolResponse as j, type LanguageModel as k, type ModelCapabilities as l, type DoGenerateParams as m, type DoGenerateResult as n, type SystemMessage as o, type AssistantMessage as p, type ToolMessage as q, type UserContentPart as r, type TextPart as s, type ToolCall$1 as t, type ToolResult as u, type GenerateStep as v, type StreamPart as w, type StreamChunk as x, type TextDeltaChunk as y, type ToolCallChunk as z };
+export { hasImageAttachments as $, type AIProvider as A, type BaseProviderConfig as B, type ChatCompletionRequest as C, type DoneEventMessage as D, type AnthropicToolSelectionHints as E, type ToolNativeProviderHints as F, type GoogleProviderConfig as G, type OpenAIProviderToolOptions as H, type AnthropicProviderToolOptions as I, type Citation as J, type KnowledgeBaseConfig as K, type LLMAdapter as L, type Message as M, type CompletionResult as N, type OpenAIProviderConfig as O, type ProviderToolRuntimeOptions as P, formatMessages as Q, formatTools as R, type StreamEvent as S, type ToolDefinition as T, type UnifiedToolCall as U, formatMessagesForAnthropic as V, type WebSearchConfig as W, type XAIProviderConfig as X, formatMessagesForOpenAI as Y, messageToAnthropicContent as Z, messageToOpenAIContent as _, type ActionDefinition as a, hasMediaAttachments as a0, attachmentToAnthropicImage as a1, attachmentToAnthropicDocument as a2, attachmentToOpenAIImage as a3, type AnthropicContentBlock as a4, type OpenAIContentBlock as a5, type ToolProfile as b, type ToolCallInfo as c, type TokenUsageRaw as d, type ToolResponse as e, type AdapterFactory as f, type ProviderCapabilities as g, type AnthropicProviderConfig as h, type AzureProviderConfig as i, type OllamaProviderConfig as j, type OllamaModelOptions as k, type ProviderFormatter as l, type AnthropicTool as m, type AnthropicToolUse as n, type AnthropicToolResult as o, type OpenAITool as p, type OpenAIToolCall as q, type OpenAIToolResult as r, type GeminiFunctionDeclaration as s, type GeminiFunctionCall as t, type GeminiFunctionResponse as u, type LLMConfig as v, type ToolLocation as w, type UnifiedToolResult as x, type ToolExecution as y, type OpenAIToolSelectionHints as z };

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