openpond 0.0.60 → 0.0.62

package/dist/chunks/{chunk-FHP7OMEI.js → chunk-J2REM7LE.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-SMNFI2FU.js";
 import {
   createOpenPondSandboxClient
-} from "./chunk-DXSHQ6TO.js";
+} from "./chunk-JGOP4GCK.js";
 import {
   DEFAULT_CACHE_TTL_MS,
   SANDBOX_RUNTIME_PROFILE_IDS,

package/dist/chunks/{chunk-DXSHQ6TO.js → chunk-JGOP4GCK.js}

@@ -265,6 +265,7 @@ function createSandboxAgentNamespace(client) {
     sourceDeployPlan: (agentId, input) => client.getAgentSourceDeployPlan(agentId, input),
     manifestSnapshots: (agentId, input) => client.listAgentManifestSnapshots(agentId, input),
     requestSourceChecks: (agentId, input) => client.requestAgentSourceChecks(agentId, input),
+    configureSourceSetup: (agentId, input) => client.configureAgentSourceSetup(agentId, input),
     publishSource: (agentId, input) => client.publishAgentSource(agentId, input)
   };
 }
@@ -1190,7 +1191,8 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
     return this.requestApiRoot(`/projects?${query.toString()}`).then((payload) => payload.projects);
   }
   upsertProject(input) {
-    return this.requestApiRoot("/projects", {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/projects?${query.toString()}`, {
       method: "POST",
       body: JSON.stringify(input)
     }).then((payload) => payload.project);
@@ -1257,7 +1259,8 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
     return this.requestApiRoot(`/agents?${query.toString()}`).then((payload) => payload.agents);
   }
   upsertAgent(input) {
-    return this.requestApiRoot("/agents", {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/agents?${query.toString()}`, {
       method: "POST",
       body: JSON.stringify(input)
     }).then((payload) => payload.agent);
@@ -1279,12 +1282,14 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
     }).then((payload) => payload.agent);
   }
   runAgent(agentId, input) {
-    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/run`, {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/run?${query.toString()}`, {
       method: "POST",
       headers: {
         Prefer: "respond-async"
       },
-      body: JSON.stringify(input)
+      body: JSON.stringify(body)
     });
   }
   getAgentSourceDeployPlan(agentId, input) {
@@ -1302,9 +1307,15 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
     const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/source/checks?${query.toString()}`, {
       method: "POST",
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      timeoutMs: 15 * 60 * 1e3
     });
   }
+  configureAgentSourceSetup(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/source/setup?${query.toString()}`, { method: "POST", body: JSON.stringify(body) });
+  }
   publishAgentSource(agentId, input) {
     const query = new URLSearchParams({ teamId: input.teamId });
     const { teamId: _teamId, ...body } = input;

package/dist/chunks/{chunk-SKUS4NPW.js → chunk-K4JEWEJQ.js}

@@ -6,15 +6,16 @@ import {
   readApiJson,
   resolveOpChatApiBaseUrl,
   sendHostedChatTurn
-} from "./chunk-DXSHQ6TO.js";
+} from "./chunk-JGOP4GCK.js";
 
 // ../../packages/sdk/src/work.ts
 var DEFAULT_MODEL = "openpond-chat";
 var DEFAULT_MAX_STEPS = 24;
 var MAX_TOOL_OUTPUT_CHARS = 4e4;
-var WORK_OUTPUT_DIRECTORY = "/workspace/outputs";
-var WORK_INPUT_DIRECTORY = "/workspace/inputs/previous-outputs";
-var WORK_INPUT_MANIFEST = "/workspace/inputs/.openpond-context.json";
+var MAX_WORK_COMMAND_CHARS = 2e4;
+var WORK_OUTPUT_DIRECTORY = "outputs";
+var WORK_INPUT_DIRECTORY = "inputs/previous-outputs";
+var WORK_INPUT_MANIFEST = "inputs/.openpond-context.json";
 var MAX_WORK_OUTPUTS = 100;
 var MAX_WORK_INPUTS = 100;
 var MAX_WORK_INPUT_BYTES = 100 * 1024 * 1024;
@@ -332,6 +333,11 @@ var OpenPondWorkClient = class {
     }
     const command = typeof args.command === "string" ? args.command.trim() : "";
     if (!command) return toolMessage(toolCallId, { error: "command is required" });
+    if (command.length > MAX_WORK_COMMAND_CHARS) {
+      const output = `command exceeds the ${MAX_WORK_COMMAND_CHARS} character limit`;
+      await emit({ type: "tool", toolCallId, command, status: "failed", output });
+      return toolMessage(toolCallId, { status: "failed", error: output });
+    }
     await emit({ type: "tool", toolCallId, command, status: "started" });
     try {
       const response = await this.#sandboxes.exec(sandboxId, {
@@ -371,7 +377,12 @@ var WORK_TOOLS = [
         type: "object",
         additionalProperties: false,
         properties: {
-          command: { type: "string", description: "Shell command to execute." }
+          command: {
+            type: "string",
+            minLength: 1,
+            maxLength: MAX_WORK_COMMAND_CHARS,
+            description: "Shell command to execute."
+          }
         },
         required: ["command"]
       }
@@ -601,11 +612,147 @@ function projectActionPath(projectId, suffix, teamId) {
   return `/v1/project-actions/${encodeURIComponent(projectId)}/${suffix}?teamId=${encodeURIComponent(teamId)}`;
 }
 
+// ../../packages/sdk/src/profile-actions.ts
+var OpenPondProfileActionsClient = class {
+  #apiKey;
+  #apiBaseUrl;
+  constructor(input) {
+    this.#apiKey = input.apiKey;
+    this.#apiBaseUrl = input.apiBaseUrl.replace(/\/+$/, "");
+  }
+  async catalog(input) {
+    const teamId = requiredValue(input.teamId, "teamId");
+    const search = new URLSearchParams({ teamId });
+    if (input.profileId?.trim()) search.set("profileId", input.profileId.trim());
+    if (input.profileName?.trim()) {
+      search.set("profileName", input.profileName.trim());
+    }
+    const response = await apiFetch(
+      this.#apiBaseUrl,
+      this.#apiKey,
+      `/v1/profile/actions?${search.toString()}`
+    );
+    return (await readApiJson(
+      response,
+      "Get Profile Action catalog"
+    )).catalog;
+  }
+  async run(input) {
+    const teamId = requiredValue(input.teamId, "teamId");
+    const actionKey = requiredValue(input.actionKey, "actionKey");
+    const idempotencyKey = requiredValue(input.idempotencyKey, "idempotencyKey");
+    const catalogVersion = requiredValue(input.catalogVersion, "catalogVersion");
+    const response = await apiFetch(
+      this.#apiBaseUrl,
+      this.#apiKey,
+      `/v1/profile/actions/run?${new URLSearchParams({ teamId }).toString()}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          ...input.profileId?.trim() ? { profileId: input.profileId.trim() } : {},
+          ...input.profileName?.trim() ? { profileName: input.profileName.trim() } : {},
+          actionKey,
+          value: input.value ?? {},
+          conversationId: input.conversationId ?? null,
+          createConversation: input.createConversation,
+          conversationTitle: input.conversationTitle ?? null,
+          idempotencyKey,
+          catalogVersion,
+          externalCapabilityLeases: input.externalCapabilityLeases
+        })
+      }
+    );
+    return readApiJson(
+      response,
+      "Run Profile Action"
+    );
+  }
+};
+function requiredValue(value, name) {
+  const normalized = value.trim();
+  if (!normalized) throw new Error(`${name} is required`);
+  return normalized;
+}
+
+// ../../packages/sdk/src/workflows.ts
+import { randomUUID } from "node:crypto";
+var OpenPondWorkflowsClient = class {
+  #apiKey;
+  #apiBaseUrl;
+  constructor(input) {
+    this.#apiKey = input.apiKey;
+    this.#apiBaseUrl = input.apiBaseUrl.replace(/\/+$/, "");
+  }
+  async list(options = {}) {
+    return this.#request("", "List Workflows", {
+      signal: options.signal
+    });
+  }
+  async create(input, options = {}) {
+    return this.#request("", "Create Workflow", {
+      method: "POST",
+      body: JSON.stringify({
+        ...input,
+        clientRequestId: input.clientRequestId?.trim() || randomUUID()
+      }),
+      signal: options.signal
+    });
+  }
+  async update(scheduleId, input, options = {}) {
+    return this.#request(
+      `/schedules/${encodeURIComponent(requiredId(scheduleId, "scheduleId"))}`,
+      "Update Workflow",
+      {
+        method: "PATCH",
+        body: JSON.stringify(input),
+        signal: options.signal
+      }
+    );
+  }
+  async delete(scheduleId, options = {}) {
+    return this.#request(
+      `/schedules/${encodeURIComponent(requiredId(scheduleId, "scheduleId"))}`,
+      "Delete Workflow",
+      { method: "DELETE", signal: options.signal }
+    );
+  }
+  async runNow(scheduleId, input = {}, options = {}) {
+    return this.#request(
+      `/schedules/${encodeURIComponent(requiredId(scheduleId, "scheduleId"))}/run`,
+      "Run Workflow",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          clientRequestId: input.clientRequestId?.trim() || randomUUID()
+        }),
+        signal: options.signal
+      }
+    );
+  }
+  async #request(suffix, label, options = {}) {
+    const response = await apiFetch(
+      this.#apiBaseUrl,
+      this.#apiKey,
+      `/v1/saved-work${suffix}`,
+      options
+    );
+    return readApiJson(response, label);
+  }
+};
+function requiredId(value, label) {
+  const normalized = value.trim();
+  if (!normalized) throw new Error(`${label} is required`);
+  return normalized;
+}
+
 // ../../packages/sdk/src/index.ts
 var OpenPondClient = class {
   sandboxes;
   work;
+  workflows;
   actions;
+  profileActions;
   constructor(options) {
     const apiKey = options.apiKey.trim();
     if (!apiKey) throw new Error("OpenPond API key is required");
@@ -621,7 +768,9 @@ var OpenPondClient = class {
       chatApiBaseUrl: options.chatApiUrl?.trim() || resolveOpChatApiBaseUrl({ apiBaseUrl, env: {} }),
       sandboxes: this.sandboxes
     });
+    this.workflows = new OpenPondWorkflowsClient({ apiKey, apiBaseUrl });
     this.actions = new OpenPondProjectActionsClient({ apiKey, apiBaseUrl });
+    this.profileActions = new OpenPondProfileActionsClient({ apiKey, apiBaseUrl });
   }
 };
 function createOpenPondClient(options) {

package/dist/chunks/{chunk-2J3LG4U7.js → chunk-KMBJLBQH.js}

@@ -15,7 +15,7 @@ import {
   resolveRepoUrl,
   runCommand,
   warnOnRepoHostMismatch
-} from "./chunk-FHP7OMEI.js";
+} from "./chunk-J2REM7LE.js";
 import {
   normalizeTemplateRepoUrl,
   resolveApiBaseUrlOption,
@@ -28,7 +28,7 @@ import {
   compareSemver,
   fetchLatestNpmVersion,
   getInstalledCliVersion
-} from "./chunk-RC3N77IV.js";
+} from "./chunk-GMX47RLP.js";
 import {
   checkOpenPondApiHealth,
   createHeadlessApps,

package/dist/chunks/{chunk-LDRWEAOB.js → chunk-MBF44RYK.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   now
-} from "./chunk-TOCZQEPW.js";
+} from "./chunk-FYB6ELFM.js";
 
 // ../server/src/workspace/workspace-command.ts
 import { spawn, spawnSync } from "node:child_process";

package/dist/chunks/{chunk-NFNEENNR.js → chunk-OYWTQABY.js}

@@ -443,7 +443,7 @@ async function runProviderRound(input) {
   const toolCallBatches = [];
   try {
     for await (const delta of input.stream) {
-      input.onDelta?.(delta);
+      await input.onDelta?.(delta);
       if (input.signal.aborted) {
         throw input.signal.reason ?? new Error("Provider round interrupted.");
       }

package/dist/chunks/{chunk-I23UKEYS.js → chunk-PLDCQVNW.js}

@@ -15,7 +15,7 @@ import {
   parseSandboxRuntimePromotionPolicyOption,
   parseSandboxWorkflowModeOption,
   runProcessCommand
-} from "./chunk-FHP7OMEI.js";
+} from "./chunk-J2REM7LE.js";
 import {
   optionString,
   optionalJsonObject,
@@ -123,9 +123,15 @@ function agentSdkRunScriptCommand(packageManager, scriptName) {
   if (packageManager === "bun") return `bun run ${scriptName}`;
   return `pnpm run ${scriptName}`;
 }
+function agentSdkRunJsonScriptCommand(packageManager, scriptName) {
+  if (packageManager === "pnpm") return `pnpm --silent run ${scriptName}`;
+  if (packageManager === "yarn") return `yarn --silent ${scriptName}`;
+  if (packageManager === "npm") return `npm run --silent ${scriptName}`;
+  if (packageManager === "bun") return `bun run --silent ${scriptName}`;
+  return `pnpm --silent run ${scriptName}`;
+}
 
 // ../../packages/cloud/src/profile/project-source-upload-agent-sdk.ts
-var OPENPOND_PNPM_PACKAGE_MANAGER = "pnpm@11.13.0";
 var AGENT_SDK_VENDOR_TARBALL_PATH = ".openpond/vendor/openpond-agent-sdk.tgz";
 var AGENT_SDK_VENDOR_NPM_DEPENDENCY_DIR = ".openpond/vendor/npm";
 var AGENT_SDK_MATERIALIZED_DEPENDENCY_SPEC = `file:${AGENT_SDK_VENDOR_TARBALL_PATH}`;
@@ -152,10 +158,15 @@ async function buildAgentSdkMaterializedDependency(projectPath, packageJson) {
   if (!sdkSource) return null;
   const tempDir = await fs.mkdtemp(path3.join(tmpdir(), "openpond-agent-sdk-pack-"));
   try {
-    const sdkContents = sdkSource.kind === "package_root" ? await packOpenPondAgentSdkPackageRoot(sdkSource.packageRoot, tempDir) : sdkSource.tarballContents;
+    const sdkContents = sdkSource.kind === "package_root" ? await packOpenPondAgentSdkPackageRoot(sdkSource.packageRoot, tempDir) : sdkSource.kind === "registry" ? await packOpenPondAgentSdkRegistryPackage(
+      sdkSource.versionSpec,
+      tempDir
+    ) : sdkSource.tarballContents;
     const sdkDependencyTarballs = await packAgentSdkRuntimeDependencyTarballs({
       sdkPackageJson: sdkSource.packageJson,
       dependencyBaseDir: sdkSource.dependencyBaseDir,
+      projectPackageJson: packageJson,
+      projectPath,
       tempDir
     });
     const packageManager = detectAgentSdkPackageManager(projectPath, packageJson);
@@ -226,23 +237,49 @@ ${details}` : ""}`
   return fs.readFile(path3.join(tempDir, tarballName));
 }
 async function packAgentSdkRuntimeDependencyTarballs(params) {
-  const dependencies = recordStringMap(params.sdkPackageJson.dependencies);
-  const pending = Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)).map(([packageName, versionSpec]) => ({ packageName, versionSpec }));
+  const sdkDependencies = recordStringMap(params.sdkPackageJson.dependencies);
+  const projectDependencies = recordStringMap(
+    params.projectPackageJson.dependencies
+  );
+  const projectDevDependencies = recordStringMap(
+    params.projectPackageJson.devDependencies
+  );
+  delete projectDependencies["openpond-agent-sdk"];
+  delete projectDevDependencies["openpond-agent-sdk"];
+  const pending = [
+    ...Object.entries(sdkDependencies).map(([packageName, versionSpec]) => ({
+      packageName,
+      versionSpec,
+      dependencyBaseDir: params.dependencyBaseDir
+    })),
+    ...Object.entries(projectDependencies).map(([packageName, versionSpec]) => ({
+      packageName,
+      versionSpec,
+      dependencyBaseDir: params.projectPath
+    })),
+    ...Object.entries(projectDevDependencies).map(
+      ([packageName, versionSpec]) => ({
+        packageName,
+        versionSpec,
+        dependencyBaseDir: params.projectPath
+      })
+    )
+  ].sort((left, right) => left.packageName.localeCompare(right.packageName));
   const seen = /* @__PURE__ */ new Set();
   const tarballs = [];
   while (pending.length > 0) {
-    const { packageName, versionSpec } = pending.shift();
+    const { packageName, versionSpec, dependencyBaseDir } = pending.shift();
     if (seen.has(packageName)) continue;
     seen.add(packageName);
     const packTarget = npmPackTargetForDependency({
       packageName,
       versionSpec,
-      dependencyBaseDir: params.dependencyBaseDir
+      dependencyBaseDir
     });
     const pack = await runCommand(
       "npm",
       ["pack", "--silent", "--pack-destination", params.tempDir, packTarget],
-      { cwd: params.dependencyBaseDir }
+      { cwd: dependencyBaseDir }
     );
     if (pack.code !== 0) {
       const details = [pack.stderr.trim(), pack.stdout.trim()].filter(Boolean).join("\n");
@@ -258,7 +295,14 @@ ${details}` : ""}`
       );
     }
     const contents = await fs.readFile(path3.join(params.tempDir, tarballName));
-    const packedPackageJson = readPackageJsonFromNpmTarball(contents);
+    let packedPackageJson;
+    try {
+      packedPackageJson = readPackageJsonFromNpmTarball(contents);
+    } catch (error) {
+      throw new Error(
+        `failed to inspect packed dependency ${packageName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
     tarballs.push({
       packageName,
       source: "npm_dependency_tarball",
@@ -273,13 +317,21 @@ ${details}` : ""}`
     for (const [dependencyName, dependencySpec] of Object.entries(
       recordStringMap(packedPackageJson.dependencies)
     )) {
-      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
+      pending.push({
+        packageName: dependencyName,
+        versionSpec: dependencySpec,
+        dependencyBaseDir
+      });
     }
     for (const [dependencyName, dependencySpec] of Object.entries(
       recordStringMap(packedPackageJson.optionalDependencies)
     )) {
       if (!isSupportedSandboxOptionalDependency(dependencyName)) continue;
-      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
+      pending.push({
+        packageName: dependencyName,
+        versionSpec: dependencySpec,
+        dependencyBaseDir
+      });
     }
   }
   return tarballs.sort((left, right) => left.packageName.localeCompare(right.packageName));
@@ -303,6 +355,33 @@ function npmPackTargetForDependency(params) {
 function sanitizeNpmPackageNameForVendor(packageName) {
   return packageName.replace(/^@/, "").replace(/[\/\\]/g, "__").replace(/[^a-zA-Z0-9._-]/g, "_");
 }
+async function packOpenPondAgentSdkRegistryPackage(versionSpec, tempDir) {
+  const pack = await runCommand(
+    "npm",
+    [
+      "pack",
+      "--silent",
+      "--pack-destination",
+      tempDir,
+      `openpond-agent-sdk@${versionSpec}`
+    ],
+    { cwd: tempDir }
+  );
+  if (pack.code !== 0) {
+    const details = [pack.stderr.trim(), pack.stdout.trim()].filter(Boolean).join("\n");
+    throw new Error(
+      `failed to pack openpond-agent-sdk for source upload${details ? `:
+${details}` : ""}`
+    );
+  }
+  const tarballName = pack.stdout.trim().split(/\r?\n/).filter(Boolean).pop();
+  if (!tarballName) {
+    throw new Error(
+      "failed to pack openpond-agent-sdk for source upload: npm pack did not return a tarball name"
+    );
+  }
+  return fs.readFile(path3.join(tempDir, tarballName));
+}
 function resolveLocalOpenPondAgentSdkMaterializationSource(projectPath, packageJson) {
   const versionSpec = readOpenPondAgentSdkVersionSpec(packageJson);
   if (versionSpec?.startsWith("file:")) {
@@ -344,6 +423,23 @@ function resolveLocalOpenPondAgentSdkMaterializationSource(projectPath, packageJ
       };
     }
   }
+  const installedPackageRoot = path3.join(
+    projectPath,
+    "node_modules",
+    "openpond-agent-sdk"
+  );
+  if (isOpenPondAgentSdkPackageRoot(installedPackageRoot)) {
+    const installedPackageJson = JSON.parse(
+      readFileSyncUtf8(path3.join(installedPackageRoot, "package.json"))
+    );
+    const installedVersion = text(installedPackageJson.version);
+    return {
+      kind: "registry",
+      versionSpec: installedVersion ?? versionSpec ?? "latest",
+      dependencyBaseDir: installedPackageRoot,
+      packageJson: installedPackageJson
+    };
+  }
   return null;
 }
 function findOpenPondAgentSdkPackageRootInAncestors(projectPath) {
@@ -389,14 +485,14 @@ function readPackageJsonFromNpmTarball(tarballContents) {
     }
     const dataStart = offset + 512;
     const dataEnd = dataStart + size;
-    if (entryPath === "package/package.json") {
+    if (entryPath === "package/package.json" || entryPath.endsWith("/package.json")) {
       return JSON.parse(
         tarContents.subarray(dataStart, dataEnd).toString("utf8")
       );
     }
     offset = dataStart + Math.ceil(size / 512) * 512;
   }
-  throw new Error("failed to read openpond-agent-sdk tarball: missing package.json");
+  throw new Error("failed to read npm package tarball: missing package.json");
 }
 function readTarString(header, start, length) {
   const field = header.subarray(start, start + length);
@@ -417,8 +513,8 @@ function rewriteAgentSdkPackageJsonForMaterialization(packageJson, dependencyTar
   if (Object.keys(overrides).length > 0) {
     rewritten.overrides = overrides;
   }
-  if (packageManager === "unknown") {
-    rewritten.packageManager = OPENPOND_PNPM_PACKAGE_MANAGER;
+  if (packageManager === "pnpm" || packageManager === "unknown") {
+    delete rewritten.packageManager;
   }
   for (const key of ["devDependencies", "peerDependencies"]) {
     const entries = recordCopy(rewritten[key]);
@@ -954,7 +1050,8 @@ function buildAgentSdkCommandHints(packageJson, packageManager) {
       packageJson,
       packageManager,
       "agent:inspect",
-      "openpond-agent inspect --json"
+      "openpond-agent inspect --json",
+      true
     ),
     build: buildAgentSdkCommandHint(
       packageJson,
@@ -976,11 +1073,11 @@ function buildAgentSdkCommandHints(packageJson, packageManager) {
     )
   };
 }
-function buildAgentSdkCommandHint(packageJson, packageManager, scriptName, fallback) {
+function buildAgentSdkCommandHint(packageJson, packageManager, scriptName, fallback, jsonOutput = false) {
   const scripts = packageJson.scripts;
   const hasScript = scripts && typeof scripts === "object" && !Array.isArray(scripts) && typeof scripts[scriptName] === "string";
   if (!hasScript) return fallback;
-  return agentSdkRunScriptCommand(packageManager, scriptName);
+  return jsonOutput ? agentSdkRunJsonScriptCommand(packageManager, scriptName) : agentSdkRunScriptCommand(packageManager, scriptName);
 }
 function readOpenPondAgentSdkVersionSpec2(packageJson) {
   for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {