openpond 0.0.30-bootstrap.0

package/dist/chunks/chunk-I6HN3ZGW.js

@@ -0,0 +1,88 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  writePrivateJsonFile
+} from "./chunk-XSAXENQD.js";
+
+// ../../packages/cloud/src/profile/source-upload-cache.ts
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+var SOURCE_UPLOAD_CACHE_PATH = ".openpond/source-upload-cache.json";
+var SOURCE_UPLOAD_CACHE_SCHEMA = "openpond.source-upload-cache.v1";
+async function readSourceUploadCache(rootPath) {
+  try {
+    const raw = await readFile(path.join(rootPath, SOURCE_UPLOAD_CACHE_PATH), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schema !== SOURCE_UPLOAD_CACHE_SCHEMA || !parsed.entries) {
+      return /* @__PURE__ */ new Map();
+    }
+    const cache = /* @__PURE__ */ new Map();
+    for (const [cacheKey, value] of Object.entries(parsed.entries)) {
+      if (!isCacheEntry(value) || cacheKey !== cacheKeyForFile(value)) continue;
+      cache.set(cacheKey, value);
+    }
+    return cache;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function materializeSourceUploadFile(file, cache) {
+  const cacheKey = cacheKeyForFile(file);
+  const cached = cache.get(cacheKey);
+  if (cached) {
+    return {
+      file,
+      entry: {
+        path: file.path,
+        type: "file",
+        contentsBase64: cached.contentsBase64
+      },
+      sha256: cached.sha256
+    };
+  }
+  const contents = await readFile(file.absolutePath);
+  return {
+    file,
+    entry: {
+      path: file.path,
+      type: "file",
+      contentsBase64: contents.toString("base64")
+    },
+    sha256: createHash("sha256").update(contents).digest("hex")
+  };
+}
+async function writeSourceUploadCache(rootPath, files) {
+  const entries = {};
+  for (const item of files) {
+    const cacheEntry = {
+      path: item.file.path,
+      size: item.file.size,
+      mtimeMs: item.file.mtimeMs,
+      ctimeMs: item.file.ctimeMs,
+      sha256: item.sha256,
+      contentsBase64: item.entry.contentsBase64
+    };
+    entries[cacheKeyForFile(cacheEntry)] = cacheEntry;
+  }
+  const cachePath = path.join(rootPath, SOURCE_UPLOAD_CACHE_PATH);
+  await writePrivateJsonFile(cachePath, {
+    schema: SOURCE_UPLOAD_CACHE_SCHEMA,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entries
+  });
+}
+function cacheKeyForFile(input) {
+  return `${input.path}\0${input.size}\0${input.mtimeMs}\0${input.ctimeMs}`;
+}
+function isCacheEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.path === "string" && typeof record.size === "number" && typeof record.mtimeMs === "number" && typeof record.ctimeMs === "number" && typeof record.sha256 === "string" && typeof record.contentsBase64 === "string";
+}
+
+export {
+  SOURCE_UPLOAD_CACHE_PATH,
+  readSourceUploadCache,
+  materializeSourceUploadFile,
+  writeSourceUploadCache
+};

package/dist/chunks/chunk-KRKGHVMQ.js

@@ -0,0 +1,294 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  getOpChatModel,
+  listOpChatModels,
+  sendHostedChatTurn,
+  streamHostedChatTurn
+} from "./chunk-NLBKZZEK.js";
+
+// ../../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 {
+  runOpChatSmoke
+};