openpond-sdk 0.6.1 → 0.6.2

package/README.md

@@ -16,6 +16,21 @@ Node.js 22.14 or newer is required. This package is server-only: never expose an
 
 ## Next.js route handler
 
+Sandbox and model configuration are independently optional. With only `apiKey`,
+Work uses OpenPond's hosted defaults. To run tools in your installed runtime while
+keeping the hosted model, add `sandbox: { endpoint, apiKey }`. To choose a model,
+add `model: { endpoint, apiKey, model }`, where `endpoint` is an OpenAI-compatible
+Chat Completions base URL. Each override requires its own credential; credentials
+are never borrowed from another service. Both overrides together allow omitting
+the hosted `apiKey` for Work.
+
+The customer runtime uses fresh guests for subsequent turns. Persist history and
+outputs in your application, then pass them into the next run. A failed output
+save retains the guest for recovery; retry persistence before deleting it. Hosted
+repository provisioning and spending budgets do not apply to a custom runtime.
+An optional UUID `requestId` lets an application reconcile interrupted allocations
+through sandbox metadata; it does not replay model or tool operations.
+
 ```ts
 // app/api/work/route.ts
 import { createOpenPondClient } from "openpond-sdk";

package/dist/{chunk-APHPXQEA.js → chunk-22RMONJA.js}

@@ -38,11 +38,11 @@ var OpenPondApiError = class extends Error {
   }
 };
 async function apiFetch(baseUrl, token, requestPath, options = {}) {
-  const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, ...init } = options;
+  const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, useEnvironmentApiKey = true, ...init } = options;
   const requestUrl = `${baseUrl}${requestPath}`;
   const headers = new Headers(init.headers);
   headers.set("Content-Type", "application/json");
-  const apiKey = process.env.OPENPOND_API_KEY;
+  const apiKey = useEnvironmentApiKey ? process.env.OPENPOND_API_KEY : void 0;
   const trimmedToken = token?.trim() || "";
   const tokenIsApiKey = trimmedToken.startsWith("opk_");
   const effectiveApiKey = apiKey || (tokenIsApiKey ? trimmedToken : null);
@@ -152,4 +152,4 @@ export {
   apiFetch,
   readApiJson
 };
-//# sourceMappingURL=chunk-APHPXQEA.js.map
+//# sourceMappingURL=chunk-22RMONJA.js.map

package/dist/chunk-22RMONJA.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../cloud/src/api/core.ts"],
+  "sourcesContent": ["const DEFAULT_API_TIMEOUT_MS = 30_000;\nconst DEFAULT_API_RESPONSE_BYTES = 8 * 1024 * 1024;\nexport const LONG_STREAM_API_OPTIONS = { timeoutMs: 15 * 60 * 1000, maxResponseBytes: 64 * 1024 * 1024 } as const;\n\nexport type ApiFetchOptions = RequestInit & {\n  useEnvironmentApiKey?: boolean;\n  timeoutMs?: number;\n  maxResponseBytes?: number;\n};\n\nexport class ApiTimeoutError extends Error {\n  readonly code = \"OPENPOND_API_TIMEOUT\";\n\n  constructor(readonly timeoutMs: number, readonly requestUrl: string) {\n    super(`API request timed out after ${timeoutMs}ms: ${requestUrl}`);\n    this.name = \"ApiTimeoutError\";\n  }\n}\n\nexport class ApiResponseTooLargeError extends Error {\n  readonly code = \"OPENPOND_API_RESPONSE_TOO_LARGE\";\n\n  constructor(readonly maximumBytes: number, readonly requestUrl: string) {\n    super(`API response exceeded ${maximumBytes} bytes: ${requestUrl}`);\n    this.name = \"ApiResponseTooLargeError\";\n  }\n}\n\nexport class OpenPondApiError extends Error {\n  readonly code: string;\n\n  constructor(\n    readonly status: number,\n    errorCode: string | null,\n    label: string,\n    readonly apiMessage: string | null = null,\n  ) {\n    const detail = apiMessage || errorCode;\n    super(`${label} failed: ${status}${detail ? ` ${detail}` : \"\"}`);\n    this.name = \"OpenPondApiError\";\n    this.code = errorCode || \"OPENPOND_API_ERROR\";\n  }\n}\n\nexport async function apiFetch(\n  baseUrl: string,\n  token: string | null,\n  requestPath: string,\n  options: ApiFetchOptions = {},\n): Promise<Response> {\n  const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, useEnvironmentApiKey = true, ...init } = options;\n  const requestUrl = `${baseUrl}${requestPath}`;\n  const headers = new Headers(init.headers);\n  headers.set(\"Content-Type\", \"application/json\");\n  const apiKey = useEnvironmentApiKey ? process.env.OPENPOND_API_KEY : undefined;\n  const trimmedToken = token?.trim() || \"\";\n  const tokenIsApiKey = trimmedToken.startsWith(\"opk_\");\n  const effectiveApiKey = apiKey || (tokenIsApiKey ? trimmedToken : null);\n  if (effectiveApiKey && !headers.has(\"openpond-api-key\")) headers.set(\"openpond-api-key\", effectiveApiKey);\n  if (token) {\n    headers.set(\"Authorization\", tokenIsApiKey ? `ApiKey ${trimmedToken}` : `Bearer ${token}`);\n  } else if (apiKey && !headers.has(\"Authorization\")) {\n    headers.set(\"Authorization\", `ApiKey ${apiKey}`);\n  }\n\n  const timeoutController = new AbortController();\n  const timeoutError = new ApiTimeoutError(timeoutMs, requestUrl);\n  const timer = timeoutMs > 0\n    ? setTimeout(() => timeoutController.abort(timeoutError), timeoutMs)\n    : null;\n  timer?.unref?.();\n  const signal = composedSignal(init.signal, timeoutController.signal, timeoutMs);\n  const cleanup = () => {\n    if (timer) clearTimeout(timer);\n  };\n\n  try {\n    const response = await fetch(requestUrl, { ...init, headers, signal });\n    return boundedResponse(response, {\n      cleanup,\n      maximumBytes: maxResponseBytes,\n      requestUrl,\n      timeoutController,\n      timeoutError,\n    });\n  } catch (error) {\n    cleanup();\n    if (timeoutController.signal.aborted) throw timeoutError;\n    throw error;\n  }\n}\n\nexport async function readApiJson<T>(response: Response, label: string): Promise<T> {\n  let payload: T & { error?: unknown; message?: unknown };\n  try {\n    const text = await response.text();\n    payload = (text ? JSON.parse(text) : {}) as T & { error?: unknown; message?: unknown };\n  } catch (error) {\n    if (error instanceof ApiTimeoutError || error instanceof ApiResponseTooLargeError) throw error;\n    payload = {} as T & { error?: unknown; message?: unknown };\n  }\n  if (!response.ok) {\n    const errorCode = typeof payload.error === \"string\" ? payload.error : null;\n    const apiMessage =\n      typeof payload.message === \"string\" ? payload.message : null;\n    throw new OpenPondApiError(response.status, errorCode, label, apiMessage);\n  }\n  return payload as T;\n}\n\nfunction boundedResponse(\n  response: Response,\n  input: {\n    cleanup: () => void;\n    maximumBytes: number;\n    requestUrl: string;\n    timeoutController: AbortController;\n    timeoutError: ApiTimeoutError;\n  },\n): Response {\n  if (!response.body) {\n    input.cleanup();\n    return response;\n  }\n  const contentLength = Number(response.headers.get(\"content-length\"));\n  if (input.maximumBytes > 0 && Number.isFinite(contentLength) && contentLength > input.maximumBytes) {\n    input.cleanup();\n    void response.body.cancel();\n    throw new ApiResponseTooLargeError(input.maximumBytes, input.requestUrl);\n  }\n\n  const reader = response.body.getReader();\n  let receivedBytes = 0;\n  const body = new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      try {\n        const result = await reader.read();\n        if (result.done) {\n          input.cleanup();\n          controller.close();\n          return;\n        }\n        receivedBytes += result.value.byteLength;\n        if (input.maximumBytes > 0 && receivedBytes > input.maximumBytes) {\n          input.cleanup();\n          await reader.cancel();\n          controller.error(new ApiResponseTooLargeError(input.maximumBytes, input.requestUrl));\n          return;\n        }\n        controller.enqueue(result.value);\n      } catch (error) {\n        input.cleanup();\n        controller.error(input.timeoutController.signal.aborted ? input.timeoutError : error);\n      }\n    },\n    async cancel(reason) {\n      input.cleanup();\n      await reader.cancel(reason);\n    },\n  });\n  return new Response(body, {\n    headers: response.headers,\n    status: response.status,\n    statusText: response.statusText,\n  });\n}\n\nfunction composedSignal(\n  callerSignal: AbortSignal | null | undefined,\n  timeoutSignal: AbortSignal,\n  timeoutMs: number,\n): AbortSignal | undefined {\n  if (timeoutMs <= 0) return callerSignal ?? undefined;\n  return callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/{chunk-QLEJOCQX.js → chunk-6T23L3LH.js}

@@ -1,7 +1,7 @@
 import {
   apiFetch,
   readApiJson
-} from "./chunk-APHPXQEA.js";
+} from "./chunk-22RMONJA.js";
 
 // src/profile-actions.ts
 var OpenPondProfileActionsClient = class {
@@ -69,4 +69,4 @@ function requiredValue(value, name) {
 export {
   OpenPondProfileActionsClient
 };
-//# sourceMappingURL=chunk-QLEJOCQX.js.map
+//# sourceMappingURL=chunk-6T23L3LH.js.map

package/dist/{chunk-27ETSPHQ.js → chunk-FJ7IMEG5.js}

@@ -1,7 +1,7 @@
 import {
   apiFetch,
   readApiJson
-} from "./chunk-APHPXQEA.js";
+} from "./chunk-22RMONJA.js";
 
 // src/project-actions.ts
 import { promises as fs } from "node:fs";
@@ -80,4 +80,4 @@ function projectActionPath(projectId, suffix, teamId) {
 export {
   OpenPondProjectActionsClient
 };
-//# sourceMappingURL=chunk-27ETSPHQ.js.map
+//# sourceMappingURL=chunk-FJ7IMEG5.js.map

package/dist/{chunk-7O5X7DBU.js → chunk-JHKNPQD5.js}

@@ -1,7 +1,7 @@
 import {
   apiFetch,
   readApiJson
-} from "./chunk-APHPXQEA.js";
+} from "./chunk-22RMONJA.js";
 
 // src/workflows.ts
 import { randomUUID } from "node:crypto";
@@ -77,4 +77,4 @@ function requiredId(value, label) {
 export {
   OpenPondWorkflowsClient
 };
-//# sourceMappingURL=chunk-7O5X7DBU.js.map
+//# sourceMappingURL=chunk-JHKNPQD5.js.map

package/dist/index.js

@@ -5,18 +5,18 @@ import {
 import "./chunk-5FBPNWT4.js";
 import {
   OpenPondProjectActionsClient
-} from "./chunk-27ETSPHQ.js";
+} from "./chunk-FJ7IMEG5.js";
 import {
   OpenPondProfileActionsClient
-} from "./chunk-QLEJOCQX.js";
+} from "./chunk-6T23L3LH.js";
 import {
   OpenPondWorkflowsClient
-} from "./chunk-7O5X7DBU.js";
+} from "./chunk-JHKNPQD5.js";
 import {
   OpenPondApiError,
   apiFetch,
   readApiJson
-} from "./chunk-APHPXQEA.js";
+} from "./chunk-22RMONJA.js";
 import "./chunk-LXXQVGQY.js";
 import {
   DEFAULT_REFINER_REVIEW_PROFILE,
@@ -630,14 +630,17 @@ var OpenPondSandboxInstanceClient = class {
   apiKey;
   apiRootUrl;
   sandboxApiUrl;
+  customEndpoint;
   constructor(options) {
     this.apiKey = options.apiKey;
+    this.customEndpoint = options.customEndpoint ?? false;
     this.sandboxApiUrl = normalizeSandboxApiUrl(options.sandboxApiUrl ?? options.baseUrl ?? DEFAULT_OPENPOND_API_BASE_URL);
     this.apiRootUrl = apiRootUrlFromSandboxApiUrl(this.sandboxApiUrl);
   }
   create(input, options = {}) {
     return this.request("", {
       method: "POST",
+      ...this.customEndpoint ? { timeoutMs: 18e4 } : {},
       headers: asyncRequestHeaders(options),
       body: JSON.stringify(input)
     }).then((payload) => payload.sandbox);
@@ -940,11 +943,11 @@ var OpenPondSandboxInstanceClient = class {
     });
   }
   async request(path, init = {}) {
-    const response = await apiFetch(this.sandboxApiUrl, this.apiKey, path, init);
+    const response = await apiFetch(this.sandboxApiUrl, this.apiKey, path, this.customEndpoint ? { ...init, useEnvironmentApiKey: false, redirect: "error" } : init);
     return readApiJson(response, "Sandbox request");
   }
   async requestApiRoot(path, init = {}) {
-    const response = await apiFetch(this.apiRootUrl, this.apiKey, path, init);
+    const response = await apiFetch(this.apiRootUrl, this.apiKey, path, this.customEndpoint ? { ...init, useEnvironmentApiKey: false, redirect: "error" } : init);
     return readApiJson(response, "OpenPond API request");
   }
 };
@@ -1834,6 +1837,77 @@ async function* streamHostedChatTurn(options) {
   }
 }
 
+// src/work-sandbox.ts
+function workSandbox(client, custom) {
+  return {
+    supportsResume: !custom,
+    get: (...args) => client.get(...args),
+    start: custom ? async () => {
+      throw new Error("This runtime does not support resuming a stopped guest; start fresh Work with saved outputs");
+    } : (...args) => client.start(...args),
+    exec: (id, input) => client.exec(id, custom ? { ...input, timeoutSeconds: Math.min(input.timeoutSeconds ?? 30, 60) } : input),
+    mkdir: (...args) => client.mkdir(...args),
+    uploadFile: (...args) => client.uploadFile(...args),
+    uploadFileBase64: (...args) => client.uploadFileBase64(...args),
+    listFiles: (...args) => client.listFiles(...args),
+    downloadFileResponse: (...args) => client.downloadFileResponse(...args),
+    stop: (...args) => client.stop(...args),
+    delete: (...args) => client.delete(...args),
+    createWork: ({ requestId, repo, budgetUsd, metadata }) => {
+      if (custom) {
+        if (repo?.trim()) throw new Error("This runtime does not support repository provisioning; provide Work inputs instead");
+        if (budgetUsd !== void 0) throw new Error("Hosted spending budgets are not supported by this runtime");
+        const request = { resources: custom.resources ?? { cpu: 1, memoryGb: 2, diskGb: 10 }, ...requestId ? { requestId } : {} };
+        return client.create(request);
+      }
+      const budget = budgetUsd?.trim() || "1.00";
+      return client.create({
+        ...repo?.trim() ? { repo: repo.trim() } : {},
+        runtimeProfileId: "openpond-work-v1",
+        resources: { cpu: 2, memoryGb: 4, diskGb: 16 },
+        budget: { maxUsd: budget },
+        quotas: { maxSpendUsd: budget, maxDurationSeconds: 3600, idleTimeoutSeconds: 900, maxCommands: 200, maxOpenPorts: 4 },
+        metadata: { source: "openpond-sdk-work", ...metadata, ...requestId ? { workRequestId: requestId } : {} }
+      }, { async: true });
+    }
+  };
+}
+function configuredEndpoint(value, name) {
+  const endpoint = new URL(value);
+  if (!["http:", "https:"].includes(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.search || endpoint.hash)
+    throw new Error(`${name} must be an HTTP(S) endpoint without embedded credentials, query or fragment`);
+  return endpoint.toString().replace(/\/$/, "");
+}
+function configuredKey(value, name) {
+  if (!value?.trim()) throw new Error(`${name} is required`);
+  return value.trim();
+}
+
+// src/work-model.ts
+import { z } from "zod";
+var completionSchema = z.object({
+  choices: z.array(z.object({ message: z.object({
+    content: z.string().nullable().optional(),
+    tool_calls: z.array(z.object({
+      id: z.string().min(1),
+      type: z.literal("function"),
+      function: z.object({ name: z.string().min(1), arguments: z.string() })
+    })).optional()
+  }) })).min(1)
+});
+async function workModelTurn(options, custom) {
+  if (!custom) return sendHostedChatTurn(options);
+  const response = await fetch(`${options.apiBaseUrl}/chat/completions`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${options.token}`, "content-type": "application/json" },
+    body: JSON.stringify({ model: options.model, messages: options.messages, tools: options.tools, tool_choice: "auto", stream: false }),
+    signal: options.signal,
+    redirect: "error"
+  });
+  if (!response.ok) throw new Error(`Configured model request failed (${response.status})`);
+  return completionSchema.parse(await response.json());
+}
+
 // src/work.ts
 var DEFAULT_MODEL = "openpond-chat";
 var DEFAULT_MAX_STEPS = 24;
@@ -1850,11 +1924,15 @@ var OpenPondWorkClient = class {
   #apiBaseUrl;
   #chatApiBaseUrl;
   #sandboxes;
+  #defaultModel;
+  #customModel;
   constructor(input) {
     this.#apiKey = input.apiKey;
     this.#apiBaseUrl = input.apiBaseUrl;
     this.#chatApiBaseUrl = input.chatApiBaseUrl;
-    this.#sandboxes = input.sandboxes;
+    this.#sandboxes = workSandbox(input.sandboxes, input.sandboxConfig);
+    this.#defaultModel = input.defaultModel ?? DEFAULT_MODEL;
+    this.#customModel = input.customModel ?? false;
   }
   async run(input) {
     const prompt = input.prompt.trim();
@@ -1889,10 +1967,10 @@ var OpenPondWorkClient = class {
       for (let step = 1; step <= maxSteps; step += 1) {
         input.signal?.throwIfAborted();
         await emit({ type: "status", message: `Thinking \xB7 step ${step}` });
-        const completion = await sendHostedChatTurn({
+        const completion = await workModelTurn({
           apiBaseUrl: this.#chatApiBaseUrl,
           token: this.#apiKey,
-          model: input.model?.trim() || DEFAULT_MODEL,
+          model: input.model?.trim() || this.#defaultModel,
           messages,
           tools: WORK_TOOLS,
           toolChoice: "auto",
@@ -1903,7 +1981,7 @@ var OpenPondWorkClient = class {
             apiBaseUrl: this.#apiBaseUrl,
             ...input.metadata
           }
-        });
+        }, this.#customModel);
         const choice = completion.choices?.[0];
         const assistantText = choice?.message?.content?.trim() ?? "";
         const toolCalls = choice?.message?.tool_calls ?? [];
@@ -1932,6 +2010,7 @@ var OpenPondWorkClient = class {
           return result;
         }
         for (const [index, toolCall] of toolCalls.entries()) {
+          input.signal?.throwIfAborted();
           const result = await this.#executeTool(
             sandbox.id,
             toolCall,
@@ -1958,9 +2037,14 @@ var OpenPondWorkClient = class {
     }
   }
   async deleteSandbox(sandboxId) {
-    const sandbox = await this.#sandboxes.get(sandboxId);
-    if (sandbox.state === "deleted") return;
-    await this.#sandboxes.delete(sandboxId);
+    try {
+      const sandbox = await this.#sandboxes.get(sandboxId);
+      if (sandbox.state === "deleted") return;
+      await this.#sandboxes.delete(sandboxId);
+    } catch (error) {
+      if (error instanceof OpenPondApiError && error.status === 404) return;
+      throw error;
+    }
   }
   async #stageInputs(sandboxId, inputs) {
     if (inputs.length === 0) return;
@@ -2028,7 +2112,7 @@ var OpenPondWorkClient = class {
             error: message
           });
           if ((input.cleanup ?? "keep") !== "keep") {
-            await this.#cleanupSandbox(sandboxId, "stop", lifecycle, emit);
+            await this.#preserveFailedOutputs(sandboxId, lifecycle, emit);
           }
           throw error;
         }
@@ -2037,7 +2121,7 @@ var OpenPondWorkClient = class {
     } else if ((input.cleanup ?? "keep") === "delete" && !input.discardOutputs) {
       lifecycle.persistence.status = "failed";
       lifecycle.persistence.error = "Deleting a Work sandbox with outputs requires persistOutput or discardOutputs: true";
-      await this.#cleanupSandbox(sandboxId, "stop", lifecycle, emit);
+      await this.#preserveFailedOutputs(sandboxId, lifecycle, emit);
       throw new Error(lifecycle.persistence.error);
     } else {
       lifecycle.persistence.status = "not_requested";
@@ -2049,6 +2133,16 @@ var OpenPondWorkClient = class {
       emit
     );
   }
+  async #preserveFailedOutputs(sandboxId, lifecycle, emit) {
+    if (this.#sandboxes.supportsResume) {
+      await this.#cleanupSandbox(sandboxId, "stop", lifecycle, emit);
+      return;
+    }
+    lifecycle.cleanup.status = "pending";
+    lifecycle.cleanup.finalSandboxState = "running";
+    lifecycle.cleanup.error = "Output persistence must be retried before guest deletion";
+    await emit({ type: "cleanup", policy: lifecycle.cleanupPolicy, status: "pending", sandboxState: "running", error: lifecycle.cleanup.error });
+  }
   async #cleanupSandbox(sandboxId, policy, lifecycle, emit) {
     if (policy === "keep") return;
     lifecycle.cleanup.status = "running";
@@ -2109,24 +2203,7 @@ var OpenPondWorkClient = class {
       const ready = await this.#waitUntilRunning(existing.id, input.signal);
       return ready;
     }
-    const budgetUsd = input.budgetUsd?.trim() || "1.00";
-    const created = await this.#sandboxes.create(
-      {
-        ...input.repo?.trim() ? { repo: input.repo.trim() } : {},
-        runtimeProfileId: "openpond-work-v1",
-        resources: { cpu: 2, memoryGb: 4, diskGb: 16 },
-        budget: { maxUsd: budgetUsd },
-        quotas: {
-          maxSpendUsd: budgetUsd,
-          maxDurationSeconds: 3600,
-          idleTimeoutSeconds: 900,
-          maxCommands: 200,
-          maxOpenPorts: 4
-        },
-        metadata: { source: "openpond-sdk-work", ...input.metadata }
-      },
-      { async: true }
-    );
+    const created = await this.#sandboxes.createWork(input);
     return this.#waitUntilRunning(created.id, input.signal);
   }
   async #waitUntilRunning(sandboxId, signal) {
@@ -2381,20 +2458,35 @@ var OpenPondClient = class {
   profileActions;
   learning;
   constructor(options) {
-    const apiKey = options.apiKey.trim();
-    if (!apiKey) throw new Error("OpenPond API key is required");
+    const apiKey = options.apiKey?.trim() ?? "";
+    if (!apiKey && (!options.sandbox || !options.model))
+      throw new Error("OpenPond API key is required when using a default sandbox or model");
+    const sandbox = options.sandbox ? {
+      ...options.sandbox,
+      endpoint: configuredEndpoint(options.sandbox.endpoint, "Sandbox endpoint"),
+      apiKey: configuredKey(options.sandbox.apiKey, "Sandbox API key")
+    } : void 0;
+    const model = options.model ? {
+      endpoint: configuredEndpoint(options.model.endpoint, "Model endpoint"),
+      apiKey: configuredKey(options.model.apiKey, "Model API key"),
+      model: configuredKey(options.model.model, "Model ID")
+    } : void 0;
     const apiBaseUrl = options.baseUrl?.trim() || "https://api.openpond.ai";
     this.learning = (scope) => new OpenPondLearningClient({ apiKey, baseUrl: apiBaseUrl, scope });
     this.sandboxes = createOpenPondSandboxClient({
-      apiKey,
+      apiKey: sandbox?.apiKey ?? apiKey,
       baseUrl: apiBaseUrl,
-      sandboxApiUrl: options.sandboxApiUrl
+      sandboxApiUrl: sandbox?.endpoint ?? options.sandboxApiUrl,
+      customEndpoint: Boolean(sandbox)
     });
     this.work = new OpenPondWorkClient({
-      apiKey,
+      apiKey: model?.apiKey ?? apiKey,
       apiBaseUrl,
-      chatApiBaseUrl: options.chatApiUrl?.trim() || resolveOpChatApiBaseUrl({ apiBaseUrl, env: {} }),
-      sandboxes: this.sandboxes
+      chatApiBaseUrl: model?.endpoint || options.chatApiUrl?.trim() || resolveOpChatApiBaseUrl({ apiBaseUrl, env: {} }),
+      sandboxes: this.sandboxes,
+      sandboxConfig: sandbox,
+      defaultModel: model?.model,
+      customModel: Boolean(model)
     });
     this.workflows = new OpenPondWorkflowsClient({ apiKey, apiBaseUrl });
     this.actions = new OpenPondProjectActionsClient({ apiKey, apiBaseUrl });