@providerprotocol/ai 0.0.1

package/dist/index.js

@@ -0,0 +1,898 @@
+import {
+  createProvider
+} from "./chunk-Y6Q7JCNP.js";
+import {
+  AssistantMessage,
+  Message,
+  ToolResultMessage,
+  UserMessage,
+  generateId,
+  isAssistantMessage,
+  isToolResultMessage,
+  isUserMessage
+} from "./chunk-QUUX4G7U.js";
+import {
+  ExponentialBackoff,
+  LinearBackoff,
+  NoRetry,
+  RetryAfterStrategy,
+  TokenBucket
+} from "./chunk-CUCRF5W6.js";
+import {
+  DynamicKey,
+  RoundRobinKeys,
+  UPPError,
+  WeightedKeys
+} from "./chunk-FTFX2VET.js";
+
+// src/types/turn.ts
+function createTurn(messages, toolExecutions, usage, cycles, data) {
+  const response = messages.filter((m) => m.type === "assistant").pop();
+  if (!response) {
+    throw new Error("Turn must contain at least one assistant message");
+  }
+  return {
+    messages,
+    response,
+    toolExecutions,
+    usage,
+    cycles,
+    data
+  };
+}
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cycles: []
+  };
+}
+function aggregateUsage(usages) {
+  const cycles = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const usage of usages) {
+    inputTokens += usage.inputTokens;
+    outputTokens += usage.outputTokens;
+    cycles.push({
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens
+    });
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    cycles
+  };
+}
+
+// src/types/stream.ts
+function createStreamResult(generator, turnPromise, abortController) {
+  return {
+    [Symbol.asyncIterator]() {
+      return generator;
+    },
+    turn: turnPromise,
+    abort() {
+      abortController.abort();
+    }
+  };
+}
+function textDelta(text2, index = 0) {
+  return {
+    type: "text_delta",
+    index,
+    delta: { text: text2 }
+  };
+}
+function toolCallDelta(toolCallId, toolName, argumentsJson, index = 0) {
+  return {
+    type: "tool_call_delta",
+    index,
+    delta: { toolCallId, toolName, argumentsJson }
+  };
+}
+function messageStart() {
+  return {
+    type: "message_start",
+    index: 0,
+    delta: {}
+  };
+}
+function messageStop() {
+  return {
+    type: "message_stop",
+    index: 0,
+    delta: {}
+  };
+}
+function contentBlockStart(index) {
+  return {
+    type: "content_block_start",
+    index,
+    delta: {}
+  };
+}
+function contentBlockStop(index) {
+  return {
+    type: "content_block_stop",
+    index,
+    delta: {}
+  };
+}
+
+// src/core/llm.ts
+var DEFAULT_MAX_ITERATIONS = 10;
+function llm(options) {
+  const { model: modelRef, config = {}, params, system, tools, toolStrategy, structure } = options;
+  const provider = modelRef.provider;
+  if (!provider.modalities.llm) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support LLM modality`,
+      "INVALID_REQUEST",
+      provider.name,
+      "llm"
+    );
+  }
+  const boundModel = provider.modalities.llm.bind(modelRef.modelId);
+  const capabilities = boundModel.capabilities;
+  if (structure && !capabilities.structuredOutput) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support structured output`,
+      "INVALID_REQUEST",
+      provider.name,
+      "llm"
+    );
+  }
+  if (tools && tools.length > 0 && !capabilities.tools) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support tools`,
+      "INVALID_REQUEST",
+      provider.name,
+      "llm"
+    );
+  }
+  const instance = {
+    model: boundModel,
+    system,
+    params,
+    capabilities,
+    async generate(historyOrInput, ...inputs) {
+      const { history, messages } = parseInputs(historyOrInput, inputs);
+      return executeGenerate(
+        boundModel,
+        config,
+        system,
+        params,
+        tools,
+        toolStrategy,
+        structure,
+        history,
+        messages
+      );
+    },
+    stream(historyOrInput, ...inputs) {
+      if (!capabilities.streaming) {
+        throw new UPPError(
+          `Provider '${provider.name}' does not support streaming`,
+          "INVALID_REQUEST",
+          provider.name,
+          "llm"
+        );
+      }
+      const { history, messages } = parseInputs(historyOrInput, inputs);
+      return executeStream(
+        boundModel,
+        config,
+        system,
+        params,
+        tools,
+        toolStrategy,
+        structure,
+        history,
+        messages
+      );
+    }
+  };
+  return instance;
+}
+function isMessageInstance(value) {
+  if (value instanceof Message) {
+    return true;
+  }
+  if (typeof value === "object" && value !== null && "timestamp" in value && "type" in value && "id" in value) {
+    const obj = value;
+    const messageTypes = ["user", "assistant", "tool_result"];
+    return messageTypes.includes(obj.type);
+  }
+  return false;
+}
+function parseInputs(historyOrInput, inputs) {
+  if (typeof historyOrInput === "object" && historyOrInput !== null && "messages" in historyOrInput && Array.isArray(historyOrInput.messages)) {
+    const thread = historyOrInput;
+    const newMessages2 = inputs.map(inputToMessage);
+    return { history: [...thread.messages], messages: newMessages2 };
+  }
+  if (Array.isArray(historyOrInput) && historyOrInput.length > 0) {
+    const first = historyOrInput[0];
+    if (isMessageInstance(first)) {
+      const newMessages2 = inputs.map(inputToMessage);
+      return { history: historyOrInput, messages: newMessages2 };
+    }
+  }
+  const allInputs = [historyOrInput, ...inputs];
+  const newMessages = allInputs.map(inputToMessage);
+  return { history: [], messages: newMessages };
+}
+function inputToMessage(input) {
+  if (typeof input === "string") {
+    return new UserMessage(input);
+  }
+  if ("type" in input && "id" in input && "timestamp" in input) {
+    return input;
+  }
+  const block = input;
+  if (block.type === "text") {
+    return new UserMessage(block.text);
+  }
+  return new UserMessage([block]);
+}
+async function executeGenerate(model, config, system, params, tools, toolStrategy, structure, history, newMessages) {
+  validateMediaCapabilities(
+    [...history, ...newMessages],
+    model.capabilities,
+    model.provider.name
+  );
+  const maxIterations = toolStrategy?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const allMessages = [...history, ...newMessages];
+  const toolExecutions = [];
+  const usages = [];
+  let cycles = 0;
+  let structuredData;
+  while (cycles < maxIterations + 1) {
+    cycles++;
+    const request = {
+      messages: allMessages,
+      system,
+      params,
+      tools,
+      structure,
+      config
+    };
+    const response = await model.complete(request);
+    usages.push(response.usage);
+    allMessages.push(response.message);
+    if (response.data !== void 0) {
+      structuredData = response.data;
+    }
+    if (response.message.hasToolCalls && tools && tools.length > 0) {
+      if (response.data !== void 0) {
+        break;
+      }
+      if (cycles >= maxIterations) {
+        await toolStrategy?.onMaxIterations?.(maxIterations);
+        throw new UPPError(
+          `Tool execution exceeded maximum iterations (${maxIterations})`,
+          "INVALID_REQUEST",
+          model.provider.name,
+          "llm"
+        );
+      }
+      const results = await executeTools(
+        response.message,
+        tools,
+        toolStrategy,
+        toolExecutions
+      );
+      allMessages.push(new ToolResultMessage(results));
+      continue;
+    }
+    break;
+  }
+  const data = structure ? structuredData : void 0;
+  return createTurn(
+    allMessages.slice(history.length),
+    // Only messages from this turn
+    toolExecutions,
+    aggregateUsage(usages),
+    cycles,
+    data
+  );
+}
+function executeStream(model, config, system, params, tools, toolStrategy, structure, history, newMessages) {
+  validateMediaCapabilities(
+    [...history, ...newMessages],
+    model.capabilities,
+    model.provider.name
+  );
+  const abortController = new AbortController();
+  const allMessages = [...history, ...newMessages];
+  const toolExecutions = [];
+  const usages = [];
+  let cycles = 0;
+  let generatorError = null;
+  let structuredData;
+  let resolveGenerator;
+  let rejectGenerator;
+  const generatorDone = new Promise((resolve, reject) => {
+    resolveGenerator = resolve;
+    rejectGenerator = reject;
+  });
+  const maxIterations = toolStrategy?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  async function* generateStream() {
+    try {
+      while (cycles < maxIterations + 1) {
+        cycles++;
+        const request = {
+          messages: allMessages,
+          system,
+          params,
+          tools,
+          structure,
+          config,
+          signal: abortController.signal
+        };
+        const streamResult = model.stream(request);
+        for await (const event of streamResult) {
+          yield event;
+        }
+        const response = await streamResult.response;
+        usages.push(response.usage);
+        allMessages.push(response.message);
+        if (response.data !== void 0) {
+          structuredData = response.data;
+        }
+        if (response.message.hasToolCalls && tools && tools.length > 0) {
+          if (response.data !== void 0) {
+            break;
+          }
+          if (cycles >= maxIterations) {
+            await toolStrategy?.onMaxIterations?.(maxIterations);
+            throw new UPPError(
+              `Tool execution exceeded maximum iterations (${maxIterations})`,
+              "INVALID_REQUEST",
+              model.provider.name,
+              "llm"
+            );
+          }
+          const results = await executeTools(
+            response.message,
+            tools,
+            toolStrategy,
+            toolExecutions
+          );
+          allMessages.push(new ToolResultMessage(results));
+          continue;
+        }
+        break;
+      }
+      resolveGenerator();
+    } catch (error) {
+      generatorError = error;
+      rejectGenerator(error);
+      throw error;
+    }
+  }
+  const turnPromise = (async () => {
+    await generatorDone;
+    if (generatorError) {
+      throw generatorError;
+    }
+    const data = structure ? structuredData : void 0;
+    return createTurn(
+      allMessages.slice(history.length),
+      toolExecutions,
+      aggregateUsage(usages),
+      cycles,
+      data
+    );
+  })();
+  return createStreamResult(generateStream(), turnPromise, abortController);
+}
+async function executeTools(message, tools, toolStrategy, executions) {
+  const toolCalls = message.toolCalls ?? [];
+  const results = [];
+  const toolMap = new Map(tools.map((t) => [t.name, t]));
+  const promises = toolCalls.map(async (call) => {
+    const tool = toolMap.get(call.toolName);
+    if (!tool) {
+      return {
+        toolCallId: call.toolCallId,
+        result: `Tool '${call.toolName}' not found`,
+        isError: true
+      };
+    }
+    const startTime = Date.now();
+    await toolStrategy?.onToolCall?.(tool, call.arguments);
+    if (toolStrategy?.onBeforeCall) {
+      const shouldRun = await toolStrategy.onBeforeCall(tool, call.arguments);
+      if (!shouldRun) {
+        return {
+          toolCallId: call.toolCallId,
+          result: "Tool execution skipped",
+          isError: true
+        };
+      }
+    }
+    let approved = true;
+    if (tool.approval) {
+      try {
+        approved = await tool.approval(call.arguments);
+      } catch (error) {
+        throw error;
+      }
+    }
+    if (!approved) {
+      const execution = {
+        toolName: tool.name,
+        toolCallId: call.toolCallId,
+        arguments: call.arguments,
+        result: "Tool execution denied",
+        isError: true,
+        duration: Date.now() - startTime,
+        approved: false
+      };
+      executions.push(execution);
+      return {
+        toolCallId: call.toolCallId,
+        result: "Tool execution denied by approval handler",
+        isError: true
+      };
+    }
+    try {
+      const result = await tool.run(call.arguments);
+      await toolStrategy?.onAfterCall?.(tool, call.arguments, result);
+      const execution = {
+        toolName: tool.name,
+        toolCallId: call.toolCallId,
+        arguments: call.arguments,
+        result,
+        isError: false,
+        duration: Date.now() - startTime,
+        approved
+      };
+      executions.push(execution);
+      return {
+        toolCallId: call.toolCallId,
+        result,
+        isError: false
+      };
+    } catch (error) {
+      await toolStrategy?.onError?.(tool, call.arguments, error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const execution = {
+        toolName: tool.name,
+        toolCallId: call.toolCallId,
+        arguments: call.arguments,
+        result: errorMessage,
+        isError: true,
+        duration: Date.now() - startTime,
+        approved
+      };
+      executions.push(execution);
+      return {
+        toolCallId: call.toolCallId,
+        result: errorMessage,
+        isError: true
+      };
+    }
+  });
+  results.push(...await Promise.all(promises));
+  return results;
+}
+function validateMediaCapabilities(messages, capabilities, providerName) {
+  for (const msg of messages) {
+    if (!isUserMessage(msg)) continue;
+    for (const block of msg.content) {
+      if (block.type === "image" && !capabilities.imageInput) {
+        throw new UPPError(
+          `Provider '${providerName}' does not support image input`,
+          "INVALID_REQUEST",
+          providerName,
+          "llm"
+        );
+      }
+      if (block.type === "video" && !capabilities.videoInput) {
+        throw new UPPError(
+          `Provider '${providerName}' does not support video input`,
+          "INVALID_REQUEST",
+          providerName,
+          "llm"
+        );
+      }
+      if (block.type === "audio" && !capabilities.audioInput) {
+        throw new UPPError(
+          `Provider '${providerName}' does not support audio input`,
+          "INVALID_REQUEST",
+          providerName,
+          "llm"
+        );
+      }
+    }
+  }
+}
+
+// src/core/image.ts
+var Image = class _Image {
+  source;
+  mimeType;
+  width;
+  height;
+  constructor(source, mimeType, width, height) {
+    this.source = source;
+    this.mimeType = mimeType;
+    this.width = width;
+    this.height = height;
+  }
+  /**
+   * Check if this image has data loaded (false for URL sources)
+   */
+  get hasData() {
+    return this.source.type !== "url";
+  }
+  /**
+   * Convert to base64 string (throws if source is URL)
+   */
+  toBase64() {
+    if (this.source.type === "base64") {
+      return this.source.data;
+    }
+    if (this.source.type === "bytes") {
+      return btoa(
+        Array.from(this.source.data).map((b) => String.fromCharCode(b)).join("")
+      );
+    }
+    throw new Error("Cannot convert URL image to base64. Fetch the image first.");
+  }
+  /**
+   * Convert to data URL (throws if source is URL)
+   */
+  toDataUrl() {
+    const base64 = this.toBase64();
+    return `data:${this.mimeType};base64,${base64}`;
+  }
+  /**
+   * Get raw bytes (throws if source is URL)
+   */
+  toBytes() {
+    if (this.source.type === "bytes") {
+      return this.source.data;
+    }
+    if (this.source.type === "base64") {
+      const binaryString = atob(this.source.data);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return bytes;
+    }
+    throw new Error("Cannot get bytes from URL image. Fetch the image first.");
+  }
+  /**
+   * Get the URL (only for URL sources)
+   */
+  toUrl() {
+    if (this.source.type === "url") {
+      return this.source.url;
+    }
+    throw new Error("This image does not have a URL source.");
+  }
+  /**
+   * Convert to ImageBlock for use in messages
+   */
+  toBlock() {
+    return {
+      type: "image",
+      source: this.source,
+      mimeType: this.mimeType,
+      width: this.width,
+      height: this.height
+    };
+  }
+  /**
+   * Create from file path (reads file into memory)
+   */
+  static async fromPath(path) {
+    const file = Bun.file(path);
+    const data = await file.arrayBuffer();
+    const mimeType = file.type || detectMimeType(path);
+    return new _Image(
+      { type: "bytes", data: new Uint8Array(data) },
+      mimeType
+    );
+  }
+  /**
+   * Create from URL reference (does not fetch - providers handle URL conversion)
+   */
+  static fromUrl(url, mimeType) {
+    const detected = mimeType || detectMimeTypeFromUrl(url);
+    return new _Image({ type: "url", url }, detected);
+  }
+  /**
+   * Create from raw bytes
+   */
+  static fromBytes(data, mimeType) {
+    return new _Image({ type: "bytes", data }, mimeType);
+  }
+  /**
+   * Create from base64 string
+   */
+  static fromBase64(base64, mimeType) {
+    return new _Image({ type: "base64", data: base64 }, mimeType);
+  }
+  /**
+   * Create from an existing ImageBlock
+   */
+  static fromBlock(block) {
+    return new _Image(
+      block.source,
+      block.mimeType,
+      block.width,
+      block.height
+    );
+  }
+};
+function detectMimeType(path) {
+  const ext = path.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "png":
+      return "image/png";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    case "svg":
+      return "image/svg+xml";
+    case "bmp":
+      return "image/bmp";
+    case "ico":
+      return "image/x-icon";
+    default:
+      return "application/octet-stream";
+  }
+}
+function detectMimeTypeFromUrl(url) {
+  try {
+    const pathname = new URL(url).pathname;
+    return detectMimeType(pathname);
+  } catch {
+    return "application/octet-stream";
+  }
+}
+
+// src/types/content.ts
+function text(content) {
+  return { type: "text", text: content };
+}
+function isTextBlock(block) {
+  return block.type === "text";
+}
+function isImageBlock(block) {
+  return block.type === "image";
+}
+function isAudioBlock(block) {
+  return block.type === "audio";
+}
+function isVideoBlock(block) {
+  return block.type === "video";
+}
+function isBinaryBlock(block) {
+  return block.type === "binary";
+}
+
+// src/types/thread.ts
+var Thread = class _Thread {
+  /** Unique thread identifier */
+  id;
+  /** Internal message storage */
+  _messages;
+  /** Creation timestamp */
+  _createdAt;
+  /** Last update timestamp */
+  _updatedAt;
+  /**
+   * Create a new thread, optionally with initial messages
+   */
+  constructor(messages) {
+    this.id = generateId();
+    this._messages = messages ? [...messages] : [];
+    this._createdAt = /* @__PURE__ */ new Date();
+    this._updatedAt = /* @__PURE__ */ new Date();
+  }
+  /** All messages in the thread (readonly) */
+  get messages() {
+    return this._messages;
+  }
+  /** Number of messages */
+  get length() {
+    return this._messages.length;
+  }
+  /**
+   * Append messages from a turn
+   */
+  append(turn) {
+    this._messages.push(...turn.messages);
+    this._updatedAt = /* @__PURE__ */ new Date();
+    return this;
+  }
+  /**
+   * Add raw messages
+   */
+  push(...messages) {
+    this._messages.push(...messages);
+    this._updatedAt = /* @__PURE__ */ new Date();
+    return this;
+  }
+  /**
+   * Add a user message
+   */
+  user(content) {
+    this._messages.push(new UserMessage(content));
+    this._updatedAt = /* @__PURE__ */ new Date();
+    return this;
+  }
+  /**
+   * Add an assistant message
+   */
+  assistant(content) {
+    this._messages.push(new AssistantMessage(content));
+    this._updatedAt = /* @__PURE__ */ new Date();
+    return this;
+  }
+  /**
+   * Get messages by type
+   */
+  filter(type) {
+    return this._messages.filter((m) => m.type === type);
+  }
+  /**
+   * Get the last N messages
+   */
+  tail(count) {
+    return this._messages.slice(-count);
+  }
+  /**
+   * Create a new thread with a subset of messages
+   */
+  slice(start, end) {
+    return new _Thread(this._messages.slice(start, end));
+  }
+  /**
+   * Clear all messages
+   */
+  clear() {
+    this._messages = [];
+    this._updatedAt = /* @__PURE__ */ new Date();
+    return this;
+  }
+  /**
+   * Convert to plain message array
+   */
+  toMessages() {
+    return [...this._messages];
+  }
+  /**
+   * Serialize to JSON
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      messages: this._messages.map((m) => this.messageToJSON(m)),
+      createdAt: this._createdAt.toISOString(),
+      updatedAt: this._updatedAt.toISOString()
+    };
+  }
+  /**
+   * Deserialize from JSON
+   */
+  static fromJSON(json) {
+    const messages = json.messages.map((m) => _Thread.messageFromJSON(m));
+    const thread = new _Thread(messages);
+    thread.id = json.id;
+    thread._createdAt = new Date(json.createdAt);
+    thread._updatedAt = new Date(json.updatedAt);
+    return thread;
+  }
+  /**
+   * Iterate over messages
+   */
+  [Symbol.iterator]() {
+    return this._messages[Symbol.iterator]();
+  }
+  /**
+   * Convert a message to JSON
+   */
+  messageToJSON(m) {
+    const base = {
+      id: m.id,
+      type: m.type,
+      content: [],
+      metadata: m.metadata,
+      timestamp: m.timestamp.toISOString()
+    };
+    if (m instanceof UserMessage) {
+      base.content = m.content;
+    } else if (m instanceof AssistantMessage) {
+      base.content = m.content;
+      base.toolCalls = m.toolCalls;
+    } else if (m instanceof ToolResultMessage) {
+      base.results = m.results;
+    }
+    return base;
+  }
+  /**
+   * Reconstruct a message from JSON
+   */
+  static messageFromJSON(json) {
+    const options = {
+      id: json.id,
+      metadata: json.metadata
+    };
+    switch (json.type) {
+      case "user":
+        return new UserMessage(json.content, options);
+      case "assistant":
+        return new AssistantMessage(
+          json.content,
+          json.toolCalls,
+          options
+        );
+      case "tool_result":
+        return new ToolResultMessage(json.results ?? [], options);
+      default:
+        throw new Error(`Unknown message type: ${json.type}`);
+    }
+  }
+};
+
+// src/index.ts
+var ai = {
+  llm
+  // embedding, // Coming soon
+  // image,     // Coming soon
+};
+export {
+  AssistantMessage,
+  DynamicKey,
+  ExponentialBackoff,
+  Image,
+  LinearBackoff,
+  Message,
+  NoRetry,
+  RetryAfterStrategy,
+  RoundRobinKeys,
+  Thread,
+  TokenBucket,
+  ToolResultMessage,
+  UPPError,
+  UserMessage,
+  WeightedKeys,
+  aggregateUsage,
+  ai,
+  contentBlockStart,
+  contentBlockStop,
+  createProvider,
+  createStreamResult,
+  createTurn,
+  emptyUsage,
+  isAssistantMessage,
+  isAudioBlock,
+  isBinaryBlock,
+  isImageBlock,
+  isTextBlock,
+  isToolResultMessage,
+  isUserMessage,
+  isVideoBlock,
+  llm,
+  messageStart,
+  messageStop,
+  text,
+  textDelta,
+  toolCallDelta
+};
+//# sourceMappingURL=index.js.map