openpond 0.0.38 → 0.0.39

package/dist/chunks/{chunk-XCATKTK3.js → chunk-3CDPPVLE.js}

@@ -87,6 +87,7 @@ var json = "json";
 var number = "number";
 var string = "string";
 var CHAT_OPTION_SCHEMA = {
+  agent: string,
   approvalPolicy: string,
   cwd: string,
   json: boolean,
@@ -98,6 +99,7 @@ var CHAT_OPTION_SCHEMA = {
   nonInteractive: boolean,
   project: string,
   provider: string,
+  resume: string,
   sandbox: string,
   server: string,
   stdin: boolean,
@@ -135,6 +137,8 @@ var SANDBOX_OPTION_SCHEMA = {
   dockerfileContext: string,
   dockerfileTarget: string,
   domain: string,
+  env: string,
+  environment: string,
   envLiteral: string,
   envName: string,
   envRef: string,
@@ -351,7 +355,6 @@ var AGENT_OPTION_SCHEMA = {
   targetProjectId: string,
   teamId: string,
   triggerType: string,
-  workItemId: string,
   workflowMode: string
 };
 
@@ -394,7 +397,7 @@ var CLI_COMMAND_REGISTRY = [
     name: "help",
     usage: "openpond help",
     optionSchema: {},
-    handler: async () => (await import("./help-VREQNA4I.js")).printHelp()
+    handler: async () => (await import("./help-LWNREJ7U.js")).printHelp()
   },
   {
     name: "version",
@@ -406,19 +409,19 @@ var CLI_COMMAND_REGISTRY = [
     name: "check-update",
     usage: "openpond check-update",
     optionSchema: {},
-    handler: async () => (await import("./core-commands-YN4RMWA3.js")).runCheckUpdate()
+    handler: async () => (await import("./core-commands-4MRJQZJV.js")).runCheckUpdate()
   },
   {
     name: "login",
     usage: "openpond login [--base-url <url>]",
     optionSchema: CLI_GLOBAL_OPTION_SCHEMA,
-    handler: async ({ options }) => (await import("./core-commands-YN4RMWA3.js")).runLogin(options)
+    handler: async ({ options }) => (await import("./core-commands-4MRJQZJV.js")).runLogin(options)
   },
   {
     name: "init",
     usage: "openpond init [--path <dir>]",
     optionSchema: { path: "string" },
-    handler: async ({ options }) => (await import("./profile-WKZJHEPG.js")).runOpenPondInitCommand(options)
+    handler: async ({ options }) => (await import("./profile-QNECVVGN.js")).runOpenPondInitCommand(options)
   },
   {
     name: "profile",
@@ -444,30 +447,17 @@ var CLI_COMMAND_REGISTRY = [
       kind: "string",
       path: "string",
       publishHostedSource: "boolean",
-      teamId: "string",
-      workItemId: "string"
+      teamId: "string"
     },
-    handler: async ({ options, rest }) => (await import("./profile-WKZJHEPG.js")).runOpenPondProfileCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./profile-QNECVVGN.js")).runOpenPondProfileCommand(options, rest)
   },
   {
     name: "agents",
     usage: "openpond agents [--json]",
     optionSchema: { json: "boolean" },
-    handler: async ({ options, rest }) => (await import("./profile-WKZJHEPG.js")).runOpenPondAgentsCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./profile-QNECVVGN.js")).runOpenPondAgentsCommand(options, rest)
   },
   ...profileSdkAliasDefinitions(),
-  {
-    name: "extend",
-    usage: "openpond extend <instructions>",
-    optionSchema: { cwd: "string" },
-    handler: async ({ options, rest }) => (await import("./extend-REGNTBK3.js")).runOpenPondExtendCommand(options, rest)
-  },
-  {
-    name: "edit",
-    usage: "openpond edit <instructions>",
-    optionSchema: { cwd: "string" },
-    handler: async ({ options, rest }) => (await import("./extend-REGNTBK3.js")).runOpenPondEditCommand(options, rest)
-  },
   {
     name: "extension",
     usage: "openpond extension <add|preview|list|inspect|update|remove> [owner/repo]",
@@ -478,25 +468,33 @@ var CLI_COMMAND_REGISTRY = [
       "openpond extension remove <owner/repo> [--json]"
     ],
     optionSchema: { all: "boolean", json: "boolean", ref: "string" },
-    handler: async ({ options, rest }) => (await import("./extension-7K77DAVL.js")).runOpenPondExtensionCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./extension-GDRW22N3.js")).runOpenPondExtensionCommand(options, rest)
   },
   {
     name: "profiles",
     usage: "openpond profiles [args]",
     optionSchema: { json: "boolean" },
-    handler: async ({ options, rest }) => (await import("./core-commands-YN4RMWA3.js")).runProfiles(options, rest)
+    handler: async ({ options, rest }) => (await import("./core-commands-4MRJQZJV.js")).runProfiles(options, rest)
   },
   {
     name: "account",
     usage: "openpond account",
     optionSchema: { json: "boolean" },
-    handler: async () => (await import("./core-commands-YN4RMWA3.js")).runAccount()
+    handler: async () => (await import("./core-commands-4MRJQZJV.js")).runAccount()
   },
   {
     name: "health",
     usage: "openpond health",
     optionSchema: { json: "boolean" },
-    handler: async ({ options }) => (await import("./core-commands-YN4RMWA3.js")).runHealth(options)
+    handler: async ({ options }) => (await import("./core-commands-4MRJQZJV.js")).runHealth(options)
+  },
+  {
+    name: "app-server",
+    usage: "openpond app-server [--store-dir DIR]",
+    optionSchema: {
+      storeDir: "string"
+    },
+    handler: async ({ options, rest }) => (await import("./app-layer-LTBWNA2F.js")).runOpenPondServerCommand("app-server", options, rest)
   },
   {
     name: "serve",
@@ -507,7 +505,7 @@ var CLI_COMMAND_REGISTRY = [
       listen: "string",
       port: "integer"
     },
-    handler: async ({ options, rest }) => (await import("./app-layer-DPUJRNO2.js")).runOpenPondServerCommand("serve", options, rest)
+    handler: async ({ options, rest }) => (await import("./app-layer-LTBWNA2F.js")).runOpenPondServerCommand("serve", options, rest)
   },
   {
     name: "ui",
@@ -520,7 +518,7 @@ var CLI_COMMAND_REGISTRY = [
       port: "integer",
       webRoot: "string"
     },
-    handler: async ({ options, rest }) => (await import("./app-layer-DPUJRNO2.js")).runOpenPondServerCommand("web", options, rest)
+    handler: async ({ options, rest }) => (await import("./app-layer-LTBWNA2F.js")).runOpenPondServerCommand("web", options, rest)
   },
   {
     name: "tui",
@@ -534,13 +532,13 @@ var CLI_COMMAND_REGISTRY = [
       provider: "string",
       server: "string"
     },
-    handler: async ({ options, rest }) => (await import("./app-layer-DPUJRNO2.js")).runOpenPondTerminalCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./app-layer-LTBWNA2F.js")).runOpenPondTerminalCommand(options, rest)
   },
   {
     name: "chat",
-    usage: "openpond chat (--message-file <path>|--message <text>|--stdin) --non-interactive [--provider <id>] [--model <id>] [--project <id>] [--yes] [--approval-policy <policy>] [--json] [--timeout-sec <n>] [--max-output-bytes <n>] [--sandbox <mode>]",
+    usage: "openpond chat (--message-file <path>|--message <text>|--stdin) --non-interactive [--provider <id>] [--model <id>] [--agent <id>] [--project <id>] [--resume <session-id>] [--yes] [--approval-policy <policy>] [--json] [--timeout-sec <n>] [--max-output-bytes <n>] [--sandbox <mode>]",
     optionSchema: CHAT_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./app-layer-DPUJRNO2.js")).runOpenPondTerminalCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./app-layer-LTBWNA2F.js")).runOpenPondTerminalCommand(options, rest)
   },
   {
     name: "tool",
@@ -576,7 +574,7 @@ var CLI_COMMAND_REGISTRY = [
     name: "sandbox-template",
     usage: "openpond sandbox-template <command> [args]",
     optionSchema: SANDBOX_TEMPLATE_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./sandbox-template-GKNVR4C5.js")).runSandboxTemplateCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./sandbox-template-5B4T4BGU.js")).runSandboxTemplateCommand(options, rest)
   },
   {
     name: "repo",
@@ -593,47 +591,57 @@ var CLI_COMMAND_REGISTRY = [
     aliases: ["organization"],
     usage: "openpond organizations <login|list|use|logout|whoami> [args]",
     optionSchema: {
+      accessToken: "string",
+      arguments: "json",
       callbackPort: "integer",
+      clientId: "string",
+      customDomain: "string",
+      displayName: "string",
+      email: "string",
+      env: "string",
+      environment: "string",
       json: "boolean",
+      name: "string",
       open: "boolean",
-      timeoutSeconds: "integer"
+      origin: "string",
+      primaryContactEmail: "string",
+      printToken: "boolean",
+      resourceUrl: "string",
+      role: "string",
+      scope: "string",
+      scopes: "string",
+      slug: "string",
+      status: "string",
+      timeout: "integer",
+      timeoutSeconds: "integer",
+      tool: "string",
+      toolName: "string",
+      toolset: "string",
+      url: "string"
     },
-    handler: async ({ options, rest }) => (await import("./organizations-I46KG7TC.js")).runOrganizationsCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./organizations-Z5HVD2E7.js")).runOrganizationsCommand(options, rest)
   },
   {
     name: "project",
     usage: "openpond project <list|create|upsert|get|update|sync|source-upload|archive> [args]",
     optionSchema: PROJECT_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./project-agent-ZUC3YMCT.js")).runProjectCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./project-agent-W3V75WBR.js")).runProjectCommand(options, rest)
   },
   {
     name: "agent",
-    usage: "openpond agent <inspect|build|validate|eval|traces|list|create|upsert|get|update|run|run-test|bind-source|source|edit|archive> [args]",
+    usage: "openpond agent <inspect|build|validate|eval|traces|list|create|upsert|get|update|run|run-test|bind-source|source|archive> [args]",
     usages: [
       "openpond agent run <action> [--cwd <project>] [--input <json>]",
       "openpond agent run <agentId> --team-id <id> [--conversation-id <id>] [--target-project-id <projectId>] [--input <json>]",
-      "openpond agent source check-status <workItemId> --team-id <id> [--limit <n>]",
-      "openpond agent edit open <agentId> --team-id <id> --project-id <id> [--message <text>]",
-      "openpond agent edit checkpoint-result|commit-result|pr-result <workItemId> --team-id <id> --ref <artifact-ref>"
+      "openpond agent source checks <agentId> --team-id <id> [--check-kind <kind>]",
+      "openpond agent source publish <agentId> --team-id <id> [--expected-manifest-hash <hash>]"
     ],
     optionSchema: AGENT_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./project-agent-ZUC3YMCT.js")).runAgentCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./project-agent-W3V75WBR.js")).runAgentCommand(options, rest)
   },
   {
-    name: "goal",
-    usage: "openpond goal <command> [args]",
-    optionSchema: {
-      agentId: "string",
-      cwd: "string",
-      goalStorage: "string",
-      json: "boolean",
-      goalId: "string"
-    },
-    handler: async ({ options, rest }) => (await import("./cli-2KBVNDRY.js")).runGoalCommand(options, rest)
-  },
-  {
-    name: "harness",
-    usage: "openpond harness desktop <run|attach> <scenario...> [--isolated|--attach|--packaged|--none] [--app <path>] [--artifacts-dir <path>] [--json <path>]",
+    name: "desktop-test",
+    usage: "openpond desktop-test <run|attach> <scenario...> [--isolated|--attach|--packaged|--none] [--app <path>] [--artifacts-dir <path>] [--json <path>]",
     optionSchema: {
       artifactsDir: "string",
       attach: "boolean",
@@ -650,22 +658,56 @@ var CLI_COMMAND_REGISTRY = [
       token: "string",
       tokenFile: "string"
     },
-    handler: async ({ options, rest }) => (await import("./harness-BHQRMXJR.js")).runHarnessCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./desktop-test-RNMWLOVU.js")).runDesktopTestCommand(options, rest)
   },
   {
     name: "sandbox",
     usage: "openpond sandbox <command> [args]",
     optionSchema: SANDBOX_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./sandbox-command-AAOPFTI5.js")).runSandboxCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./sandbox-command-X3FO74NX.js")).runSandboxCommand(options, rest)
+  },
+  {
+    name: "training",
+    usage: "openpond training <start|status|watch|logs|cancel|artifacts> <model-run-id|run-id>",
+    usages: [
+      "openpond training start <model-run-id> [--manifest <path>] [--yes] [--max-spend <usd>] [--retention-days <days>] [--detach] [--json]",
+      "openpond training status <run-id> [--json]",
+      "openpond training watch <run-id> [--interval-ms <ms>] [--json]",
+      "openpond training logs <run-id> [--json]",
+      "openpond training cancel <run-id> [--json]",
+      "openpond training artifacts <run-id> [--json]"
+    ],
+    optionSchema: {
+      apiBaseUrl: "string",
+      detach: "boolean",
+      intervalMs: "integer",
+      json: "boolean",
+      manifest: "string",
+      maxSpend: "number",
+      retentionDays: "integer",
+      yes: "boolean"
+    },
+    handler: async ({ options, rest }) => (await import("./training-BR5A7SPU.js")).runTrainingCommand(options, rest)
   },
   {
     name: "opchat",
     usage: "openpond opchat <command> [args]",
     optionSchema: {
+      compatModel: "string",
+      compatibilityModel: "string",
+      env: "string",
+      environment: "string",
       json: "boolean",
+      message: "string",
+      model: "string",
+      opchatApiBaseUrl: "string",
+      opchatApiUrl: "string",
+      prompt: "string",
+      skipStream: "boolean",
+      skipTool: "boolean",
       stream: "boolean"
     },
-    handler: async ({ options, rest }) => (await import("./opchat-D63YTNSX.js")).runOpChatCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./opchat-2K2JIGK3.js")).runOpChatCommand(options, rest)
   },
   {
     name: "teams-bot",
@@ -674,7 +716,7 @@ var CLI_COMMAND_REGISTRY = [
       json: "boolean",
       teamId: "string"
     },
-    handler: async ({ options, rest }) => (await import("./teams-bot-PSL3ZO6Z.js")).runTeamsBotCommand(options, rest)
+    handler: async ({ options, rest }) => (await import("./teams-bot-NTQ6VFFL.js")).runTeamsBotCommand(options, rest)
   },
   {
     name: "apps",
@@ -695,7 +737,7 @@ var CLI_COMMAND_REGISTRY = [
     name: "opentool",
     usage: "openpond opentool <init|validate|build> [args]",
     optionSchema: {},
-    handler: async ({ rest }) => (await import("./core-commands-YN4RMWA3.js")).runOpentool(rest)
+    handler: async ({ rest }) => (await import("./core-commands-4MRJQZJV.js")).runOpentool(rest)
   }
 ];
 var CLI_COMMAND_BY_NAME = /* @__PURE__ */ new Map();
@@ -767,11 +809,11 @@ function profileSdkAliasDefinitions() {
     name,
     usage: `openpond ${name} [args]`,
     optionSchema: PROFILE_SDK_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./profile-WKZJHEPG.js")).runOpenPondProfileSdkAlias(name, options, rest)
+    handler: async ({ options, rest }) => (await import("./profile-QNECVVGN.js")).runOpenPondProfileSdkAlias(name, options, rest)
   }));
 }
 async function runToolCommand({ options, rest }) {
-  const { runToolList, runToolRun } = await import("./core-commands-YN4RMWA3.js");
+  const { runToolList, runToolRun } = await import("./core-commands-4MRJQZJV.js");
   const subcommand = rest[0];
   if (subcommand === "list") {
     const target = rest[1];
@@ -795,8 +837,8 @@ async function runToolCommand({ options, rest }) {
   throw new Error("usage: tool <list|run> <handle>/<repo> [args]");
 }
 async function runBacktestCommand({ options, rest }) {
-  const { runBacktestRun } = await import("./core-commands-YN4RMWA3.js");
-  const { runBacktestEvents, runBacktestGet } = await import("./apps-AKBI6AS7.js");
+  const { runBacktestRun } = await import("./core-commands-4MRJQZJV.js");
+  const { runBacktestEvents, runBacktestGet } = await import("./apps-CZAJBGE3.js");
   const subcommand = rest[0] || "run";
   if (subcommand === "run") {
     const target = rest[1];
@@ -830,7 +872,7 @@ async function runBacktestCommand({ options, rest }) {
   throw new Error("usage: backtest <run|events|get> <handle>/<repo> [args]");
 }
 async function runDeployCommand({ options, rest }) {
-  const { runDeployWatch } = await import("./core-commands-YN4RMWA3.js");
+  const { runDeployWatch } = await import("./core-commands-4MRJQZJV.js");
   const subcommand = rest[0] || "watch";
   if (subcommand !== "watch") {
     throw new Error(
@@ -846,7 +888,7 @@ async function runDeployCommand({ options, rest }) {
   await runDeployWatch(options, target);
 }
 async function runTemplateCommand({ options, rest }) {
-  const { runTemplateBranches, runTemplateStatus, runTemplateUpdate } = await import("./core-commands-YN4RMWA3.js");
+  const { runTemplateBranches, runTemplateStatus, runTemplateUpdate } = await import("./core-commands-4MRJQZJV.js");
   const subcommand = rest[0] || "status";
   const target = rest[1];
   if (!target) {
@@ -871,7 +913,7 @@ async function runTemplateCommand({ options, rest }) {
   );
 }
 async function runRepoCommand({ options, rest }) {
-  const { runRepoCreate, runRepoPush } = await import("./core-commands-YN4RMWA3.js");
+  const { runRepoCreate, runRepoPush } = await import("./core-commands-4MRJQZJV.js");
   const subcommand = rest[0] || "create";
   if (subcommand === "create") {
     await runRepoCreate(options, rest.slice(1));
@@ -898,7 +940,7 @@ async function runAppsCommand({ options, rest }) {
     runAppsSummary,
     runAppsTools,
     runAppsToolsExecute
-  } = await import("./apps-AKBI6AS7.js");
+  } = await import("./apps-CZAJBGE3.js");
   const subcommand = rest[0];
   if (subcommand === "list") {
     await runAppsList(options);

package/dist/chunks/{chunk-JWF37O5E.js → chunk-3HW6OSHP.js}

@@ -4,7 +4,7 @@ import {
   parseSandboxRuntimeProfileIdOption,
   parseSandboxRuntimePromotionPolicyOption,
   parseSandboxWorkflowModeOption
-} from "./chunk-275WCETC.js";
+} from "./chunk-FCVVOMIP.js";
 import {
   parseBooleanOption,
   parseCsvOption,
@@ -79,7 +79,6 @@ function formatSandboxLine(sandbox) {
   return [
     sandbox.id,
     sandbox.state,
-    sandbox.runtimeDriver,
     `spent=${captured}/${budget}`,
     mppMode,
     repo
@@ -589,7 +588,6 @@ function summarizeSandbox(sandbox) {
   return {
     id: sandbox.id,
     state: sandbox.state,
-    runtimeDriver: sandbox.runtimeDriver,
     repo: sandbox.repo,
     runtimeId: sandbox.runtimeId ?? null,
     repoRef: sandbox.repoRef ?? null,

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
 };