openpond 0.0.37 → 0.0.39

package/dist/chunks/{chunk-43YI36NA.js → chunk-3KLQ52B2.js}

@@ -1,10 +1,228 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
-  getOpChatModel,
-  listOpChatModels,
-  sendHostedChatTurn,
-  streamHostedChatTurn
-} from "./chunk-HLCTINEP.js";
+  withVercelProtectionBypass
+} from "./chunk-DBHSOTYZ.js";
+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(requestUrl, 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 withVercelProtectionBypass(requestUrl, 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(requestUrl, 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(requestUrl, 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(
+      requestUrl,
+      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(
+      requestUrl,
+      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";
@@ -290,5 +508,10 @@ function formatUsage(usage) {
 }
 
 export {
+  resolveOpChatApiBaseUrl,
+  listOpChatModels,
+  getOpChatModel,
+  sendHostedChatTurn,
+  streamHostedChatTurn,
   runOpChatSmoke
 };