openpond 0.2.0 → 0.2.1

package/dist/chunks/chunk-BVY5JYM6.js

@@ -1,512 +0,0 @@
-import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  DEFAULT_OPENPOND_OPCHAT_API_BASE_URL
-} from "./chunk-KSRWKXRB.js";
-
-// ../../packages/cloud/src/hosted-chat.ts
-import { randomUUID } from "node:crypto";
-function normalizeApiBaseUrl(value) {
-  const trimmed = normalizeOptionalOpChatApiBaseUrl(value);
-  if (!trimmed) throw new Error("apiBaseUrl is required");
-  return trimmed;
-}
-function trimTrailingSlashes(value) {
-  return value.replace(/\/+$/, "");
-}
-function normalizeOptionalOpChatApiBaseUrl(value) {
-  let trimmed = trimTrailingSlashes(value?.trim() ?? "");
-  if (!trimmed) return null;
-  trimmed = trimmed.replace(/\/chat\/completions$/i, "").replace(/\/models(?:\/[^/]+)?$/i, "");
-  if (trimmed.endsWith("/opchat/v1")) return trimmed;
-  if (trimmed.endsWith("/opchat")) return `${trimmed}/v1`;
-  if (trimmed.endsWith("/v1")) {
-    trimmed = trimmed.slice(0, -"/v1".length);
-  }
-  return `${trimTrailingSlashes(trimmed)}/opchat/v1`;
-}
-function resolveOpChatApiBaseUrl(options = {}) {
-  const runtimeEnv = options.env ?? (typeof process !== "undefined" ? process.env : {});
-  const explicit = normalizeOptionalOpChatApiBaseUrl(options.opChatApiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_OPCHAT_API_URL);
-  if (explicit) return explicit;
-  const migrationInput = normalizeOptionalOpChatApiBaseUrl(options.chatApiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_CHAT_API_URL) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_GATEWAY_URL);
-  if (migrationInput) return migrationInput;
-  const apiBase = normalizeOptionalOpChatApiBaseUrl(options.apiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_API_URL);
-  return apiBase ?? DEFAULT_OPENPOND_OPCHAT_API_BASE_URL;
-}
-function requireToken(value) {
-  const trimmed = value.trim();
-  if (!trimmed) throw new Error("OpenPond API key is required");
-  return trimmed;
-}
-function hostedHeaders(token, accept, requestId) {
-  const headers = new Headers();
-  headers.set("Authorization", `Bearer ${requireToken(token)}`);
-  headers.set("Content-Type", "application/json");
-  headers.set("Accept", accept);
-  headers.set("x-openpond-client", "openpond-code");
-  headers.set("x-openpond-request-id", requestId || randomUUID());
-  return headers;
-}
-async function readError(response) {
-  const text = await response.text().catch(() => "");
-  if (!text) return response.statusText || `HTTP ${response.status}`;
-  try {
-    const payload = JSON.parse(text);
-    const error = typeof payload.error === "string" ? payload.error : payload.error && typeof payload.error === "object" && !Array.isArray(payload.error) ? payload.error : null;
-    const code = typeof payload.code === "string" ? payload.code : error && typeof error !== "string" && typeof error.code === "string" ? error.code : null;
-    const message = typeof payload.message === "string" ? payload.message : error && typeof error !== "string" && typeof error.message === "string" ? error.message : null;
-    const label = typeof error === "string" ? error : error && typeof error.type === "string" ? error.type : null;
-    return [code, label, message].filter(Boolean).join(": ") || text;
-  } catch {
-    return text;
-  }
-}
-function buildHostedChatBody(options, stream) {
-  const body = {
-    model: options.model,
-    messages: options.messages,
-    stream
-  };
-  if (typeof options.temperature === "number") {
-    body.temperature = options.temperature;
-  }
-  if (typeof options.maxTokens === "number") {
-    body.max_tokens = options.maxTokens;
-  }
-  if (options.tools) {
-    body.tools = options.tools;
-  }
-  const toolChoice = options.toolChoice ?? options.tool_choice;
-  if (toolChoice !== void 0) {
-    body.tool_choice = toolChoice;
-  }
-  if (options.metadata) {
-    body.metadata = options.metadata;
-  }
-  return body;
-}
-async function listOpChatModels(options) {
-  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
-  const requestUrl = `${apiBaseUrl}/models`;
-  const response = await fetch(requestUrl, {
-    method: "GET",
-    headers: hostedHeaders(options.token, "application/json"),
-    signal: options.signal
-  });
-  if (!response.ok) {
-    throw new Error(
-      `Hosted model list failed: ${response.status} ${await readError(
-        response
-      )}`
-    );
-  }
-  return await response.json();
-}
-async function getOpChatModel(options) {
-  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
-  const requestUrl = `${apiBaseUrl}/models/${encodeURIComponent(options.model)}`;
-  const response = await fetch(
-    requestUrl,
-    {
-      method: "GET",
-      headers: hostedHeaders(options.token, "application/json"),
-      signal: options.signal
-    }
-  );
-  if (!response.ok) {
-    throw new Error(
-      `Hosted model lookup failed: ${response.status} ${await readError(
-        response
-      )}`
-    );
-  }
-  return await response.json();
-}
-async function sendHostedChatTurn(options) {
-  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
-  const requestUrl = `${apiBaseUrl}/chat/completions`;
-  const response = await fetch(requestUrl, {
-    method: "POST",
-    headers: hostedHeaders(
-      options.token,
-      "application/json",
-      options.requestId
-    ),
-    body: JSON.stringify(buildHostedChatBody(options, false)),
-    signal: options.signal
-  });
-  if (!response.ok) {
-    throw new Error(
-      `Hosted chat failed: ${response.status} ${await readError(response)}`
-    );
-  }
-  return await response.json();
-}
-async function* parseOpenAISSE(stream, signal) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const readAbortError = () => signal?.reason instanceof Error ? signal.reason : new Error("hosted_chat_aborted");
-  try {
-    while (true) {
-      if (signal?.aborted) throw readAbortError();
-      const result = await reader.read();
-      if (result.done) break;
-      buffer += decoder.decode(result.value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data:")) continue;
-        const data = trimmed.slice(5).trim();
-        if (!data) continue;
-        if (data === "[DONE]") return;
-        yield JSON.parse(data);
-      }
-    }
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-async function* streamHostedChatTurn(options) {
-  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
-  const requestUrl = `${apiBaseUrl}/chat/completions`;
-  const response = await fetch(requestUrl, {
-    method: "POST",
-    headers: hostedHeaders(
-      options.token,
-      "text/event-stream",
-      options.requestId
-    ),
-    body: JSON.stringify(buildHostedChatBody(options, true)),
-    signal: options.signal
-  });
-  if (!response.ok || !response.body) {
-    throw new Error(
-      `Hosted chat stream failed: ${response.status} ${await readError(
-        response
-      )}`
-    );
-  }
-  for await (const raw of parseOpenAISSE(response.body, options.signal)) {
-    const chunk = raw;
-    if (chunk.error) {
-      throw new Error(chunk.error.message || "Hosted chat stream error");
-    }
-    if (chunk.usage) {
-      yield { type: "usage", usage: chunk.usage, raw };
-    }
-    const choice = chunk.choices?.[0];
-    if (!choice) continue;
-    const content = choice.delta?.content;
-    if (content) {
-      yield { type: "text_delta", text: content, raw };
-    }
-    const reasoning = choice.delta?.reasoning_content;
-    if (reasoning) {
-      yield { type: "reasoning_delta", text: reasoning, raw };
-    }
-    const toolCalls = choice.delta?.tool_calls;
-    if (Array.isArray(toolCalls) && toolCalls.length > 0) {
-      yield { type: "tool_call_delta", toolCalls, raw };
-    }
-    if (choice.finish_reason !== void 0 && choice.finish_reason !== null) {
-      yield { type: "finish", finishReason: choice.finish_reason, raw };
-    }
-  }
-}
-
-// ../../packages/cloud/src/opchat-smoke.ts
-var DEFAULT_MODEL = "openpond-chat";
-var COMPATIBILITY_MODEL = "deepseek-v4-flash";
-var INVALID_MODEL = "not-a-real-opchat-model";
-async function runOpChatSmoke(options) {
-  const defaultModel = options.defaultModel || DEFAULT_MODEL;
-  const compatibilityModel = options.compatibilityModel || COMPATIBILITY_MODEL;
-  const invalidModel = options.invalidModel || INVALID_MODEL;
-  const log = options.log || (() => void 0);
-  log(`opchat base: ${options.apiBaseUrl}`);
-  const models = await listOpChatModels({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token
-  });
-  const listedModels = models.data.map((model) => model.id);
-  requireModel(listedModels, defaultModel);
-  requireModel(listedModels, compatibilityModel);
-  log(`models: ${listedModels.join(", ")}`);
-  const defaultLookup = await getOpChatModel({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token,
-    model: defaultModel
-  });
-  const compatibilityLookup = await getOpChatModel({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token,
-    model: compatibilityModel
-  });
-  const invalidModelError = await expectInvalidModel({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token,
-    model: invalidModel
-  });
-  log(`invalid model error: ${invalidModelError}`);
-  const nonStreaming = summarizeCompletion(
-    defaultModel,
-    await sendHostedChatTurn({
-      apiBaseUrl: options.apiBaseUrl,
-      token: options.token,
-      model: defaultModel,
-      messages: [
-        {
-          role: "user",
-          content: "Reply with a short plain sentence confirming OpChat works."
-        }
-      ],
-      metadata: { source: "openpond-code-opchat-smoke", mode: "non_stream" }
-    })
-  );
-  requireText(nonStreaming, `${defaultModel} non-streaming response`);
-  log(
-    `${defaultModel} non-stream: id=${nonStreaming.id ?? "unknown"} usage=${formatUsage(
-      nonStreaming.usage
-    )}`
-  );
-  const streaming = options.skipStream ? void 0 : await runStreamSmoke({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token,
-    model: defaultModel
-  });
-  if (streaming) {
-    log(
-      `${defaultModel} stream: chunks=${streaming.textDeltaCount} finish=${streaming.finishReason ?? "none"} usage=${formatUsage(streaming.usage)}`
-    );
-  }
-  const compatibilityNonStreaming = summarizeCompletion(
-    compatibilityModel,
-    await sendHostedChatTurn({
-      apiBaseUrl: options.apiBaseUrl,
-      token: options.token,
-      model: compatibilityModel,
-      messages: [
-        {
-          role: "user",
-          content: "Reply with one short sentence confirming compatibility."
-        }
-      ],
-      metadata: {
-        source: "openpond-code-opchat-smoke",
-        mode: "compatibility_non_stream"
-      }
-    })
-  );
-  requireText(
-    compatibilityNonStreaming,
-    `${compatibilityModel} non-streaming response`
-  );
-  log(
-    `${compatibilityModel} non-stream: id=${compatibilityNonStreaming.id ?? "unknown"} usage=${formatUsage(compatibilityNonStreaming.usage)}`
-  );
-  const toolCalling = options.skipTool ? void 0 : await runToolSmoke({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token,
-    model: defaultModel
-  });
-  if (toolCalling) {
-    log(
-      `${defaultModel} tool: calls=${toolCalling.toolCallCount} names=${toolCalling.toolNames.join(
-        ","
-      )}`
-    );
-  }
-  return {
-    apiBaseUrl: options.apiBaseUrl,
-    listedModels,
-    defaultModel,
-    compatibilityModel,
-    modelLookups: [defaultLookup.id, compatibilityLookup.id],
-    invalidModelError,
-    nonStreaming,
-    compatibilityNonStreaming,
-    ...streaming ? { streaming } : {},
-    ...toolCalling ? { toolCalling } : {}
-  };
-}
-async function expectInvalidModel(options) {
-  try {
-    await getOpChatModel(options);
-  } catch (error) {
-    return error instanceof Error ? error.message : String(error);
-  }
-  throw new Error(`expected invalid model ${options.model} to fail`);
-}
-async function runStreamSmoke(options) {
-  const startedAt = Date.now();
-  let firstTextAt = null;
-  let text = "";
-  let textDeltaCount = 0;
-  let finishReason = null;
-  let usage = null;
-  for await (const chunk of streamHostedChatTurn({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token,
-    model: options.model,
-    messages: [
-      {
-        role: "user",
-        content: "Reply with a short streamed sentence."
-      }
-    ],
-    metadata: { source: "openpond-code-opchat-smoke", mode: "stream" }
-  })) {
-    if (chunk.type === "text_delta") {
-      firstTextAt ??= Date.now();
-      text += chunk.text;
-      textDeltaCount += 1;
-    } else if (chunk.type === "finish") {
-      finishReason = chunk.finishReason;
-    } else if (chunk.type === "usage") {
-      usage = chunk.usage;
-    }
-  }
-  if (textDeltaCount === 0 || !text.trim()) {
-    throw new Error("streaming response did not emit text deltas");
-  }
-  if (!finishReason) {
-    throw new Error("streaming response did not emit a terminal finish marker");
-  }
-  return {
-    model: options.model,
-    textDeltaCount,
-    textPreview: previewText(text),
-    firstTextMs: firstTextAt === null ? null : firstTextAt - startedAt,
-    totalMs: Date.now() - startedAt,
-    finishReason,
-    usage
-  };
-}
-async function runToolSmoke(options) {
-  const tools = [
-    {
-      type: "function",
-      function: {
-        name: "get_current_weather",
-        description: "Get the current weather for a city.",
-        parameters: {
-          type: "object",
-          properties: {
-            location: {
-              type: "string",
-              description: "City and region, for example Boston, MA."
-            }
-          },
-          required: ["location"]
-        }
-      }
-    }
-  ];
-  const messages = [
-    {
-      role: "user",
-      content: "Use the get_current_weather tool for Boston, then wait for the result."
-    }
-  ];
-  const toolCompletion = await sendHostedChatTurn({
-    apiBaseUrl: options.apiBaseUrl,
-    token: options.token,
-    model: options.model,
-    messages,
-    tools,
-    toolChoice: "auto",
-    metadata: { source: "openpond-code-opchat-smoke", mode: "tool_call" }
-  });
-  const choice = toolCompletion.choices?.[0];
-  const toolCalls = choice?.message?.tool_calls ?? [];
-  if (toolCalls.length === 0) {
-    throw new Error("tool smoke did not receive an assistant tool call");
-  }
-  const toolResultMessages = buildToolResultMessages(toolCalls);
-  const followUp = summarizeCompletion(
-    options.model,
-    await sendHostedChatTurn({
-      apiBaseUrl: options.apiBaseUrl,
-      token: options.token,
-      model: options.model,
-      messages: [
-        ...messages,
-        {
-          role: "assistant",
-          content: choice?.message?.content ?? null,
-          tool_calls: toolCalls
-        },
-        ...toolResultMessages
-      ],
-      metadata: { source: "openpond-code-opchat-smoke", mode: "tool_result" }
-    })
-  );
-  requireText(followUp, "tool follow-up response");
-  return {
-    model: options.model,
-    toolCallCount: toolCalls.length,
-    toolNames: toolCalls.map((toolCall) => toolCall.function?.name).filter((name) => Boolean(name)),
-    finishReason: choice?.finish_reason ?? null,
-    followUp
-  };
-}
-function buildToolResultMessages(toolCalls) {
-  return toolCalls.map((toolCall, index) => {
-    if (!toolCall.id) {
-      throw new Error(`tool call ${index} is missing an id`);
-    }
-    return {
-      role: "tool",
-      tool_call_id: toolCall.id,
-      content: JSON.stringify({
-        location: "Boston, MA",
-        temperature: "58 F",
-        conditions: "clear"
-      })
-    };
-  });
-}
-function summarizeCompletion(model, completion) {
-  const choice = completion.choices?.[0];
-  return {
-    model,
-    id: completion.id ?? null,
-    finishReason: choice?.finish_reason ?? null,
-    textPreview: previewText(choice?.message?.content ?? ""),
-    usage: completion.usage ?? null
-  };
-}
-function requireModel(models, expected) {
-  if (!models.includes(expected)) {
-    throw new Error(`model list did not include ${expected}`);
-  }
-}
-function requireText(summary, label) {
-  if (!summary.textPreview.trim()) {
-    throw new Error(`${label} did not include assistant text`);
-  }
-}
-function previewText(value, maxLength = 120) {
-  const normalized = value.replace(/\s+/g, " ").trim();
-  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 1)}...`;
-}
-function formatUsage(usage) {
-  if (!usage) return "none";
-  return String(
-    usage.total_tokens ?? usage.input_tokens ?? usage.output_tokens ?? "unknown"
-  );
-}
-
-export {
-  resolveOpChatApiBaseUrl,
-  listOpChatModels,
-  getOpChatModel,
-  sendHostedChatTurn,
-  streamHostedChatTurn,
-  runOpChatSmoke
-};