openpond 0.0.56 → 0.0.58

package/dist/chunks/{chunk-Q4YKGVNG.js → chunk-AD6KZWHL.js}

@@ -1,4 +1,17 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  assertSafeBranchName,
+  isGeneratedWorkspacePath,
+  listPlainWorkspaceFiles,
+  loadWorkspaceDiffAtPath,
+  loadWorkspaceStateAtPath,
+  normalizeWorkspaceFilePath,
+  readLocalImageFile,
+  runCommand,
+  truncatePatch,
+  uniqueSortedPaths,
+  workspaceImageContentType
+} from "./chunk-BFR6VZ2A.js";
 import {
   AGENT_PROTOCOL_VERSION,
   AGENT_RPC_METHODS,
@@ -16,32 +29,19 @@ import {
   runProviderRound,
   runProviderRoundLoop
 } from "./chunk-NFNEENNR.js";
-import {
-  getBundledRuntimeVersion,
-  loadOpenPondAccountContext,
-  loadOpenPondHostedModels,
-  streamOpenPondHostedChatTurn
-} from "./chunk-EIRW6Z6S.js";
-import {
-  assertSafeBranchName,
-  isGeneratedWorkspacePath,
-  listPlainWorkspaceFiles,
-  loadWorkspaceDiffAtPath,
-  loadWorkspaceStateAtPath,
-  normalizeWorkspaceFilePath,
-  readLocalImageFile,
-  runCommand,
-  truncatePatch,
-  uniqueSortedPaths,
-  workspaceImageContentType
-} from "./chunk-H44J7BB4.js";
 import {
   HOSTED_CHAT_SYSTEM_PROMPT,
   VERSION,
   event,
   now,
   textFromUnknown
-} from "./chunk-OSLQMUIB.js";
+} from "./chunk-OI65U2B5.js";
+import {
+  getBundledRuntimeVersion,
+  loadOpenPondAccountContext,
+  loadOpenPondHostedModels,
+  streamOpenPondHostedChatTurn
+} from "./chunk-LMQ4MPQI.js";
 import {
   AppPreferencesSchema,
   ApplyCreateImproveRunActionRequestSchema,
@@ -158,7 +158,7 @@ import {
   runAgentSdkProjectCommand,
   runProfileSkillCommand,
   sidebarFileBookmarkId
-} from "./chunk-55KT7K5P.js";
+} from "./chunk-PVGJXCAK.js";
 import {
   AgentSnapshotSchema,
   AttemptReceiptSchema,
@@ -236,7 +236,7 @@ import {
   stableId,
   uniqueEventRefs,
   validateConnectedAppProviderOperationRequest
-} from "./chunk-US7DOPAH.js";
+} from "./chunk-VG4H4TQG.js";
 import {
   external_exports
 } from "./chunk-WYDVQOBL.js";
@@ -246,7 +246,7 @@ import {
   createOpenPondSandboxClient,
   normalizeSandboxApiUrl,
   withVercelProtectionBypass
-} from "./chunk-KHNHUA2H.js";
+} from "./chunk-DXSHQ6TO.js";
 import {
   __commonJS,
   __toESM
@@ -7864,11 +7864,16 @@ function executableSearchPath(environment = process.env, platform = process.plat
 }
 
 // ../server/src/harness/local-harness-refiner-context.ts
-var MAX_REFINER_SOURCE_BYTES = 6e4;
+var MAX_REFINER_SOURCE_BYTES = 36e3;
 var MAX_PDF_ARTIFACTS = 10;
 var MAX_PDF_BYTES = 20 * 1024 * 1024;
+var MAX_REVIEW_TIMELINE_EVENTS = 40;
+var MAX_REVIEW_TIMELINE_CHARS = 24e3;
+var MAX_PRIOR_CONVERSATION_TURNS = 3;
+var MAX_PRIOR_INCIDENTS = 3;
+var MAX_PRIOR_INCIDENT_TIMELINE_EVENTS = 6;
 var execFileAsync = promisify(execFile);
-async function loadBoundedRefinerContext(store, trigger, observations) {
+async function loadBoundedRefinerContext(store, trigger, observations, workspaceId) {
   const [session, turn, events, turns, usageRecords] = await Promise.all([
     store.getSession(trigger.runRef),
     store.getTurn(trigger.turnId),
@@ -7918,6 +7923,30 @@ async function loadBoundedRefinerContext(store, trigger, observations) {
       0
     ) || receiptProfile.totalTokens
   };
+  const executionProfile = {
+    modelRequestCount: durableUsage.modelRequestCount,
+    failedModelRequestCount: usageRecords.filter(
+      (record9) => record9.status === "failed" || record9.status === "interrupted"
+    ).length,
+    promptTokens: durableUsage.promptTokens,
+    completionTokens: durableUsage.completionTokens,
+    totalTokens: durableUsage.totalTokens,
+    toolFailureCount: observationKinds.filter((kind) => kind === "tool_failure").length,
+    retryCount: observationKinds.filter((kind) => kind === "retry").length,
+    recoveryCount: observationKinds.filter((kind) => kind === "recovery").length
+  };
+  const artifactDiagnostics = await inspectBoundedPdfArtifactDiagnostics(session?.cwd);
+  const timelineCandidates = events.filter(
+    (runtimeEvent) => runtimeEvent.turnId === trigger.turnId && isRefinerReviewTimelineEvent(runtimeEvent) && (runtimeEvent.sequence === void 0 || runtimeEvent.sequence <= trigger.boundary.eventSequence)
+  ).sort(compareRuntimeEvents);
+  const timeline = boundedReviewTimeline(timelineCandidates);
+  const priorConversation = orderedTurns.slice(Math.max(0, turnIndex - MAX_PRIOR_CONVERSATION_TURNS), Math.max(0, turnIndex)).map((candidate) => conversationTurn(candidate, events));
+  const priorIncidents = workspaceId ? await loadRelevantPriorIncidentPackets({
+    store,
+    workspaceId,
+    trigger,
+    observations
+  }) : [];
   return {
     task: {
       prompt: turn?.prompt ? redactAndBoundRefinerText(turn.prompt, 8e3) : null,
@@ -7925,19 +7954,8 @@ async function loadBoundedRefinerContext(store, trigger, observations) {
       assistantOutputLinkCount: countAbsoluteLinks(assistantOutput),
       previousAssistantOutput: previousTurn ? assistantOutputForTurn(events, previousTurn.id) : null
     },
-    artifactDiagnostics: await inspectBoundedPdfArtifactDiagnostics(session?.cwd),
-    executionProfile: {
-      modelRequestCount: durableUsage.modelRequestCount,
-      failedModelRequestCount: usageRecords.filter(
-        (record9) => record9.status === "failed" || record9.status === "interrupted"
-      ).length,
-      promptTokens: durableUsage.promptTokens,
-      completionTokens: durableUsage.completionTokens,
-      totalTokens: durableUsage.totalTokens,
-      toolFailureCount: observationKinds.filter((kind) => kind === "tool_failure").length,
-      retryCount: observationKinds.filter((kind) => kind === "retry").length,
-      recoveryCount: observationKinds.filter((kind) => kind === "recovery").length
-    },
+    artifactDiagnostics,
+    executionProfile,
     eventExcerpts: evidenceEvents.map((runtimeEvent) => {
       const data = asRecord(runtimeEvent.data);
       const result = asRecord(data.result);
@@ -7954,9 +7972,242 @@ async function loadBoundedRefinerContext(store, trigger, observations) {
         stderr: textField(result.stderr, 3e3),
         stdout: textField(result.stdout, 3e3)
       };
-    })
+    }),
+    reviewPacket: {
+      currentTurn: {
+        id: trigger.turnId,
+        status: turn?.status ?? null,
+        error: turn?.error ? redactAndBoundRefinerText(turn.error, 2e3) : null,
+        prompt: turn?.prompt ? redactAndBoundRefinerText(turn.prompt, 8e3) : null,
+        assistantOutput,
+        assistantOutputLinkCount: countAbsoluteLinks(assistantOutput)
+      },
+      priorConversation,
+      timeline,
+      artifacts: fileOutputInventory(events, trigger.turnId),
+      artifactDiagnostics,
+      executionProfile,
+      priorIncidents,
+      truncation: {
+        timelineEventCount: timelineCandidates.length,
+        includedTimelineEventCount: timeline.length,
+        timelineTruncated: timeline.length < timelineCandidates.length
+      }
+    }
+  };
+}
+function conversationTurn(turn, events) {
+  return {
+    turnId: turn.id,
+    status: turn.status,
+    prompt: turn.prompt ? redactAndBoundRefinerText(turn.prompt, 3e3) : null,
+    assistantOutput: assistantOutputForTurn(events, turn.id, 3e3)
   };
 }
+function boundedReviewTimeline(events) {
+  const mapped = events.map(reviewTimelineEntry);
+  if (mapped.length <= MAX_REVIEW_TIMELINE_EVENTS) {
+    return fitTimelineToCharacterBudget(mapped);
+  }
+  const important = mapped.filter(
+    (entry) => entry.status === "failed" || entry.name === "turn.completed" || entry.name === "turn.failed" || entry.name === "turn.interrupted" || entry.name === "skill.loaded" || entry.name === "validation.completed" || entry.name === "diagnostic"
+  );
+  const retainedKeys = new Set(important.map(timelineEntryKey));
+  const remaining = mapped.filter((entry) => !retainedKeys.has(timelineEntryKey(entry))).slice(-(MAX_REVIEW_TIMELINE_EVENTS - Math.min(important.length, MAX_REVIEW_TIMELINE_EVENTS)));
+  return fitTimelineToCharacterBudget(
+    [...important.slice(-MAX_REVIEW_TIMELINE_EVENTS), ...remaining].sort((left, right) => Number(left.sequence ?? 0) - Number(right.sequence ?? 0))
+  );
+}
+function fitTimelineToCharacterBudget(entries) {
+  const retained = [];
+  let used = 0;
+  for (const entry of entries) {
+    const size = JSON.stringify(entry).length;
+    if (used + size > MAX_REVIEW_TIMELINE_CHARS) continue;
+    retained.push(entry);
+    used += size;
+  }
+  return retained;
+}
+function reviewTimelineEntry(runtimeEvent) {
+  const data = asRecord(runtimeEvent.data);
+  const result = asRecord(data.result);
+  return {
+    sequence: runtimeEvent.sequence ?? null,
+    timestamp: runtimeEvent.timestamp,
+    name: runtimeEvent.name,
+    action: runtimeEvent.action ?? (typeof data.tool === "string" ? data.tool : null),
+    status: runtimeEvent.status ?? null,
+    args: boundedUnknown(runtimeEvent.args, 1500),
+    command: textField(result.command, 2e3),
+    error: textField(runtimeEvent.error, 2e3),
+    output: textField(result.output, 2e3) ?? textField(runtimeEvent.output, 2e3),
+    exitCode: typeof result.exitCode === "number" ? result.exitCode : null,
+    timedOut: result.timedOut === true,
+    stderr: textField(result.stderr, 2e3),
+    stdout: textField(result.stdout, 2e3)
+  };
+}
+function timelineEntryKey(entry) {
+  return `${entry.sequence ?? "none"}:${entry.name ?? "unknown"}:${entry.action ?? "none"}`;
+}
+function fileOutputInventory(events, turnId) {
+  const byRevision = /* @__PURE__ */ new Map();
+  for (const runtimeEvent of events) {
+    if (runtimeEvent.turnId !== turnId) continue;
+    for (const output of findFileOutputRefs(runtimeEvent.data)) {
+      byRevision.set(`${output.id}:${output.revision}`, output);
+    }
+  }
+  return [...byRevision.values()].sort((left, right) => left.title.localeCompare(right.title) || left.revision - right.revision).slice(0, 30).map((output) => ({
+    id: output.id,
+    title: output.title,
+    revision: output.revision,
+    contentType: output.contentType,
+    sizeBytes: output.sizeBytes,
+    sha256: output.sha256,
+    locationKind: output.location.kind,
+    validation: output.validation.map((validation) => ({
+      kind: validation.kind,
+      status: validation.status,
+      label: validation.label,
+      detail: validation.detail ?? null
+    }))
+  }));
+}
+function findFileOutputRefs(value, depth = 0) {
+  if (depth > 8) return [];
+  const parsed = FileOutputRefSchema.safeParse(value);
+  if (parsed.success) return [parsed.data];
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => findFileOutputRefs(item, depth + 1));
+  }
+  if (!value || typeof value !== "object") return [];
+  return Object.values(value).flatMap(
+    (item) => findFileOutputRefs(item, depth + 1)
+  );
+}
+async function loadRelevantPriorIncidentPackets(input) {
+  const currentClasses = new Set(
+    input.observations.flatMap(
+      (observation) => observation.deterministicClass ? [observation.deterministicClass] : []
+    )
+  );
+  const currentTools = new Set(
+    input.observations.flatMap((observation) => observation.tool ? [observation.tool.name] : [])
+  );
+  if (currentClasses.size === 0 && currentTools.size === 0) return [];
+  const available = (await input.store.listHarnessImprovementArtifacts(
+    input.workspaceId,
+    "observation",
+    200
+  )).filter(
+    (observation) => observation.runRef !== input.trigger.runRef && observation.turnId !== input.trigger.turnId && (observation.deterministicClass !== null && currentClasses.has(observation.deterministicClass) || observation.tool !== null && currentTools.has(observation.tool.name))
+  ).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+  const byTurn = /* @__PURE__ */ new Map();
+  for (const observation of available) {
+    const key = `${observation.runRef}:${observation.turnId}`;
+    const list = byTurn.get(key) ?? [];
+    list.push(observation);
+    byTurn.set(key, list);
+  }
+  const packets = [];
+  for (const group of byTurn.values()) {
+    if (packets.length >= MAX_PRIOR_INCIDENTS) break;
+    const first = group[0];
+    const [turn, events] = await Promise.all([
+      input.store.getTurn(first.turnId),
+      input.store.runtimeEventsForSession(first.runRef, { limit: 1e3 })
+    ]);
+    if (!turn) continue;
+    const matchingClasses = [...new Set(group.flatMap(
+      (observation) => observation.deterministicClass && currentClasses.has(observation.deterministicClass) ? [observation.deterministicClass] : []
+    ))];
+    const matchingTools = [...new Set(group.flatMap(
+      (observation) => observation.tool && currentTools.has(observation.tool.name) ? [observation.tool.name] : []
+    ))];
+    const timeline = priorIncidentTimeline(
+      events.filter((runtimeEvent) => runtimeEvent.turnId === turn.id)
+    );
+    packets.push({
+      runRef: first.runRef,
+      turnId: first.turnId,
+      createdAt: first.createdAt,
+      matchedBy: {
+        deterministicClasses: matchingClasses,
+        tools: matchingTools
+      },
+      observations: group.slice(0, 4).map((observation) => ({
+        kind: observation.kind,
+        state: observation.state,
+        deterministicClass: observation.deterministicClass,
+        summary: observation.summary
+      })),
+      prompt: turn.prompt ? redactAndBoundRefinerText(turn.prompt, 1200) : null,
+      assistantOutput: assistantOutputForTurn(events, turn.id, 1200),
+      timeline,
+      artifacts: fileOutputInventory(events, turn.id).slice(0, 5)
+    });
+  }
+  return packets;
+}
+function priorIncidentTimeline(events) {
+  const terminalNames = /* @__PURE__ */ new Set(["turn.completed", "turn.failed", "turn.interrupted"]);
+  const candidates = events.filter((runtimeEvent) => {
+    if (terminalNames.has(runtimeEvent.name)) return true;
+    const serialized = JSON.stringify({
+      error: runtimeEvent.error,
+      output: runtimeEvent.output,
+      data: runtimeEvent.data
+    });
+    return runtimeEvent.status === "failed" || /"ok"\s*:\s*false|failed|denied|unavailable|timed?\s*out|exception|traceback/i.test(serialized);
+  }).sort(compareRuntimeEvents).map((runtimeEvent) => {
+    const entry = reviewTimelineEntry(runtimeEvent);
+    return {
+      sequence: entry.sequence,
+      name: entry.name,
+      action: entry.action,
+      status: entry.status,
+      error: textField(entry.error, 800),
+      output: textField(entry.output, 800),
+      exitCode: entry.exitCode,
+      timedOut: entry.timedOut
+    };
+  });
+  const unique2 = /* @__PURE__ */ new Map();
+  for (const entry of candidates) {
+    const signature = JSON.stringify({
+      name: entry.name,
+      action: entry.action,
+      status: entry.status,
+      error: entry.error,
+      output: entry.output,
+      exitCode: entry.exitCode,
+      timedOut: entry.timedOut
+    });
+    const existing = unique2.get(signature);
+    if (existing) {
+      existing.occurrenceCount += 1;
+      continue;
+    }
+    unique2.set(signature, { ...entry, occurrenceCount: 1 });
+  }
+  const compact = [...unique2.values()];
+  if (compact.length <= MAX_PRIOR_INCIDENT_TIMELINE_EVENTS) return compact;
+  return [
+    ...compact.slice(0, MAX_PRIOR_INCIDENT_TIMELINE_EVENTS - 2),
+    ...compact.slice(-2)
+  ];
+}
+function boundedUnknown(value, maxLength) {
+  if (value === void 0) return null;
+  try {
+    const text = redactAndBoundRefinerText(JSON.stringify(value), maxLength);
+    return JSON.parse(text.endsWith("\n[truncated]") ? JSON.stringify(text) : text);
+  } catch {
+    return redactAndBoundRefinerText(String(value), maxLength);
+  }
+}
 function tasksetGradeExecutionProfile(events, turnId) {
   const fallback = {
     modelRequestCount: 0,
@@ -8074,11 +8325,11 @@ function countAbsoluteLinks(value) {
   if (!value) return 0;
   return value.match(/https?:\/\/[^\s<>)\]}"']+/gi)?.length ?? 0;
 }
-function assistantOutputForTurn(events, turnId) {
+function assistantOutputForTurn(events, turnId, maxLength = 8e3) {
   const output = events.filter(
     (runtimeEvent) => runtimeEvent.turnId === turnId && runtimeEvent.name === "assistant.delta" && typeof runtimeEvent.output === "string"
   ).sort(compareRuntimeEvents).map((runtimeEvent) => runtimeEvent.output).join("");
-  return output ? redactAndBoundRefinerText(output, 8e3) : null;
+  return output ? redactAndBoundRefinerText(output, maxLength) : null;
 }
 async function loadExactObservations(store, workspaceId, trigger) {
   const available = await store.listHarnessImprovementArtifacts(
@@ -8115,7 +8366,14 @@ async function readBoundedRefinerSource(bundlePath, trigger) {
     kind: file.kind,
     loaded: file.kind === "skill" && loadedSkillNames.has(skillNameFromPath(file.path))
   }));
-  for (const file of manifest.files) {
+  const rankedFiles = manifest.files.slice().sort((left, right) => {
+    const leftLoaded = left.kind === "skill" && loadedSkillNames.has(skillNameFromPath(left.path));
+    const rightLoaded = right.kind === "skill" && loadedSkillNames.has(skillNameFromPath(right.path));
+    if (leftLoaded !== rightLoaded) return leftLoaded ? -1 : 1;
+    const rank = (kind) => kind === "instruction" ? 0 : kind === "skill" ? 1 : 2;
+    return rank(left.kind) - rank(right.kind) || left.path.localeCompare(right.path);
+  });
+  for (const file of rankedFiles) {
     if (!["instruction", "skill", "agent"].includes(file.kind) || file.visibility !== "policy" || !["text/markdown", "text/plain", "text/javascript"].includes(file.mediaType)) {
       continue;
     }
@@ -8156,6 +8414,18 @@ function isRefinerEvidenceEvent(runtimeEvent) {
     "diagnostic"
   ].includes(runtimeEvent.name);
 }
+function isRefinerReviewTimelineEvent(runtimeEvent) {
+  return [
+    "turn.completed",
+    "turn.failed",
+    "turn.interrupted",
+    "tool.completed",
+    "workspace_action_result",
+    "skill.loaded",
+    "validation.completed",
+    "diagnostic"
+  ].includes(runtimeEvent.name);
+}
 function compareRuntimeEvents(left, right) {
   return (left.sequence ?? Number.MAX_SAFE_INTEGER) - (right.sequence ?? Number.MAX_SAFE_INTEGER);
 }
@@ -9693,6 +9963,11 @@ async function refreshOpenAiSubscriptionToken(refreshToken) {
       client_id: OPENAI_OAUTH_CLIENT_ID
     }).toString()
   });
+  if (response.status === 401) {
+    throw new Error(
+      "Your OpenAI ChatGPT sign-in has expired or was invalidated. Reconnect it in Settings > Providers > OpenAI > Subscription by selecting Connect ChatGPT. This is an authentication issue, not a billing or model-access error."
+    );
+  }
   if (!response.ok) throw new Error(`OpenAI token refresh failed: ${response.status}`);
   return await response.json();
 }
@@ -11078,41 +11353,13 @@ async function runLocalHarnessRefinerWorker(input) {
   const boundedContext = await loadBoundedRefinerContext(
     input.store,
     trigger,
-    observations
-  );
-  const currentObservationHashes = new Set(
-    observations.map((observation) => observation.contentHash)
+    observations,
+    workspace.id
   );
-  const recentObservations = (await input.store.listHarnessImprovementArtifacts(
-    workspace.id,
-    "observation",
-    100
-  )).filter((observation) => !currentObservationHashes.has(observation.contentHash)).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 20).map((observation) => ({
-    ...boundedObservationEvidence(observation),
-    runRef: observation.runRef,
-    turnId: observation.turnId,
-    createdAt: observation.createdAt
-  }));
-  const recentOutcomes = (await input.store.listHarnessImprovementArtifacts(
-    workspace.id,
-    "refiner_outcome",
-    100
-  )).filter((outcome) => outcome.trigger.contentHash !== trigger.contentHash).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 8).map((outcome) => ({
-    id: outcome.id,
-    decision: outcome.decision,
-    reason: outcome.reason,
-    createdAt: outcome.createdAt,
-    triggerId: outcome.trigger.id
-  }));
   const refinerEvidence = {
     trigger: boundedTriggerEvidence(trigger),
     observations: observations.map(boundedObservationEvidence),
-    task: boundedContext.task,
-    eventExcerpts: boundedContext.eventExcerpts,
-    artifactDiagnostics: boundedContext.artifactDiagnostics,
-    executionProfile: boundedContext.executionProfile,
-    recentObservations,
-    recentOutcomes,
+    reviewPacket: boundedContext.reviewPacket,
     sourceFiles: source.files,
     sourceCatalog: source.catalog,
     additionalEvidence: input.additionalEvidence ?? null
@@ -26537,6 +26784,66 @@ function collectJsonStrings(value, output, depth = 0) {
   }
 }
 
+// ../server/src/project-actions/hosted-project-action-model-tool.ts
+async function executeHostedProjectActionModelTool(input) {
+  const { action, context, implementation, resultToolName } = input;
+  if (!input.executeProjectAction) {
+    return failedResult(context.callId, resultToolName, `Action ${action.id} is a hosted Project Action, but hosted action execution is not configured.`);
+  }
+  const projectId = stringValue7(implementation.projectId);
+  const teamId = stringValue7(implementation.teamId);
+  const releaseId = stringValue7(implementation.releaseId);
+  const projectActionId = stringValue7(implementation.actionId) ?? action.id;
+  if (!projectId || !teamId || !releaseId) {
+    return failedResult(context.callId, resultToolName, `Action ${action.id} is missing its hosted Project Action release binding.`);
+  }
+  if (input.requestedProjectId && input.requestedProjectId !== projectId) {
+    return failedResult(context.callId, resultToolName, `Project ${input.requestedProjectId} is not authorized for action ${action.id}.`);
+  }
+  const result = await input.executeProjectAction({
+    action: projectActionId,
+    input: input.actionInput,
+    metadata: {
+      source: "openpond_hosted_project_action",
+      execution: "hosted",
+      projectId,
+      teamId,
+      releaseId,
+      selectedActionId: projectActionId,
+      selectedActionLabel: action.label ?? action.name ?? projectActionId,
+      selectedBy: "native_model_tool",
+      displayPrompt: context.userPrompt,
+      sessionId: context.session.id,
+      turnId: context.turnId,
+      toolCallId: context.callId
+    }
+  });
+  return {
+    toolCallId: context.callId,
+    name: resultToolName,
+    ok: true,
+    contentText: JSON.stringify({
+      ok: true,
+      action: resultToolName,
+      output: `Ran hosted Project Action ${projectActionId}.`,
+      data: { result }
+    }, null, 2),
+    data: { result }
+  };
+}
+function failedResult(callId, name, error) {
+  return {
+    toolCallId: callId,
+    name,
+    ok: false,
+    contentText: JSON.stringify({ ok: false, action: name, error }, null, 2),
+    data: { error }
+  };
+}
+function stringValue7(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
 // ../server/src/openpond/model-tool-registry.ts
 function enabledModelToolDefinitions(definitions, context) {
   return definitions.filter((definition) => definition.enabled?.(context) ?? true);
@@ -27491,8 +27798,8 @@ function createOpenPondActionModelToolDefinitions(deps) {
           resultToolName: "openpond_action_run",
           compactProfileResultForModel: true,
           input: asRecord7(context.args.input) ?? {},
-          requestedProjectId: stringValue7(context.args.projectId) ?? void 0,
-          requestedAgentId: stringValue7(context.args.agentId) ?? void 0
+          requestedProjectId: stringValue8(context.args.projectId) ?? void 0,
+          requestedAgentId: stringValue8(context.args.agentId) ?? void 0
         });
       }
     }
@@ -27505,7 +27812,7 @@ function directOpenPondActionToolName(action) {
   return `agent_${slug}_${suffix}`;
 }
 function directOpenPondActionAliasName(action) {
-  const name = stringValue7(asRecord7(action.implementation)?.actionId) ?? action.sourceActionId ?? action.name ?? action.id;
+  const name = stringValue8(asRecord7(action.implementation)?.actionId) ?? action.sourceActionId ?? action.name ?? action.id;
   return /^[A-Za-z0-9_-]{1,64}$/.test(name) ? name : null;
 }
 function actionInputSchema(action) {
@@ -27536,8 +27843,8 @@ async function executeScopedOpenPondAction(input) {
         `Action ${action.id} is a profile action, but profile action execution is not configured.`
       );
     }
-    const profileActionId = stringValue7(implementation.actionId) ?? action.id;
-    const prompt = stringValue7(input.input.prompt) ?? stringValue7(input.input.message) ?? context.userPrompt;
+    const profileActionId = stringValue8(implementation.actionId) ?? action.id;
+    const prompt = stringValue8(input.input.prompt) ?? stringValue8(input.input.message) ?? context.userPrompt;
     const result2 = await deps.executeProfileAction({
       action: profileActionId,
       input: {
@@ -27573,11 +27880,88 @@ async function executeScopedOpenPondAction(input) {
       data: { result: result2 }
     };
   }
+  if (implementation?.type === "openpond-project-action") {
+    const executionTarget = resolveWorkspaceExecutionTarget({ session: context.session });
+    if (isSandboxExecutionTarget(executionTarget)) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is a local Project Action and cannot run while Working in Hybrid or sandbox. Switch Working in to Local.`
+      );
+    }
+    if (!deps.executeProjectAction) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is a local Project Action, but local action execution is not configured.`
+      );
+    }
+    const projectRoot = stringValue8(implementation.projectRoot) ?? action.sourcePath;
+    const projectId = stringValue8(implementation.projectId);
+    const projectActionId = stringValue8(implementation.actionId) ?? action.id;
+    if (!projectRoot) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is missing its local Project root.`
+      );
+    }
+    if (!projectId || projectId !== context.session.localProjectId) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is not authorized for the selected local Project.`
+      );
+    }
+    const result2 = await deps.executeProjectAction({
+      action: projectActionId,
+      input: input.input,
+      metadata: {
+        source: "openpond_project_action",
+        projectRoot,
+        projectId,
+        selectedActionId: projectActionId,
+        selectedActionLabel: action.label ?? action.name ?? projectActionId,
+        selectedBy: "native_model_tool",
+        displayPrompt: context.userPrompt,
+        sessionId: context.session.id,
+        turnId: context.turnId,
+        toolCallId: context.callId
+      }
+    });
+    return {
+      toolCallId: context.callId,
+      name: resultToolName,
+      ok: true,
+      contentText: JSON.stringify(
+        {
+          ok: true,
+          action: resultToolName,
+          output: `Ran Project Action ${projectActionId}.`,
+          data: { result: result2 }
+        },
+        null,
+        2
+      ),
+      data: { result: result2 }
+    };
+  }
+  if (implementation?.type === "openpond-hosted-project-action") {
+    return executeHostedProjectActionModelTool({
+      action,
+      context,
+      implementation,
+      actionInput: input.input,
+      requestedProjectId: input.requestedProjectId,
+      resultToolName,
+      executeProjectAction: deps.executeProjectAction
+    });
+  }
   const payloadArgs = {
     actionName: action.sourceActionId ?? action.name ?? action.id,
     input: input.input
   };
-  const allowedProjectId = stringValue7(implementation?.projectId);
+  const allowedProjectId = stringValue8(implementation?.projectId);
   if (input.requestedProjectId) {
     if (!allowedProjectId || input.requestedProjectId !== allowedProjectId) {
       return failedActionToolResult(
@@ -27590,7 +27974,7 @@ async function executeScopedOpenPondAction(input) {
   } else if (allowedProjectId) {
     payloadArgs.projectId = allowedProjectId;
   }
-  const allowedAgentId = action.agentId ?? stringValue7(implementation?.agentId);
+  const allowedAgentId = action.agentId ?? stringValue8(implementation?.agentId);
   if (input.requestedAgentId) {
     if (!allowedAgentId || input.requestedAgentId !== allowedAgentId) {
       return failedActionToolResult(
@@ -27619,7 +28003,7 @@ async function executeScopedOpenPondAction(input) {
 }
 function compactProfileActionResult(value) {
   const execution = asRecord7(value);
-  const stdout = stringValue7(execution?.stdout);
+  const stdout = stringValue8(execution?.stdout);
   if (!stdout) return value;
   let payload;
   try {
@@ -27633,7 +28017,7 @@ function compactProfileActionResult(value) {
   for (const key of ["snapshot", "decision", "submission", "receipt"]) {
     if (metadata && Object.hasOwn(metadata, key)) return metadata[key];
   }
-  const text = stringValue7(actionResultRecord?.text);
+  const text = stringValue8(actionResultRecord?.text);
   if (text) {
     try {
       return JSON.parse(text);
@@ -27895,23 +28279,23 @@ function gitChangedFileRefs(value, sandboxMode = false) {
   const record9 = asRecord7(value);
   const status = asRecord7(record9?.status);
   const files = Array.isArray(record9?.files) ? record9.files : Array.isArray(status?.files) ? status.files : [];
-  return files.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)).map((item) => stringValue7(item.path)).filter((item) => Boolean(item)).map((filePath) => `${sandboxMode ? "sandbox" : "workspace"}:file:${filePath}`);
+  return files.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)).map((item) => stringValue8(item.path)).filter((item) => Boolean(item)).map((filePath) => `${sandboxMode ? "sandbox" : "workspace"}:file:${filePath}`);
 }
 function gitDiffText(value) {
   const record9 = asRecord7(value);
-  return stringValue7(record9?.diff) ?? stringValue7(asRecord7(record9?.result)?.diff);
+  return stringValue8(record9?.diff) ?? stringValue8(asRecord7(record9?.result)?.diff);
 }
 function sandboxPathItems(value) {
   const records = nestedArraysForKeys(value, ["matches", "files", "entries"]);
   const items = [];
   for (const record9 of records) {
-    const path48 = stringValue7(record9.path) ?? stringValue7(record9.name);
+    const path48 = stringValue8(record9.path) ?? stringValue8(record9.name);
     if (!path48) continue;
     items.push({
       path: path48,
-      snippet: stringValue7(record9.text) ?? stringValue7(record9.snippet) ?? stringValue7(record9.content) ?? void 0,
+      snippet: stringValue8(record9.text) ?? stringValue8(record9.snippet) ?? stringValue8(record9.content) ?? void 0,
       line: typeof record9.line === "number" ? record9.line : null,
-      kind: stringValue7(record9.kind) ?? stringValue7(record9.type)
+      kind: stringValue8(record9.kind) ?? stringValue8(record9.type)
     });
   }
   return items;
@@ -27936,15 +28320,15 @@ function nestedArraysForKeys(value, keys) {
 function sandboxFileContent(value) {
   const record9 = asRecord7(value);
   const file = sandboxFileRecord(value);
-  const encoded = stringValue7(file?.contentsBase64) ?? stringValue7(record9?.contentsBase64);
-  if (encoded && !sandboxFileMetadata(value, stringValue7(file?.path) ?? "").binary) {
+  const encoded = stringValue8(file?.contentsBase64) ?? stringValue8(record9?.contentsBase64);
+  if (encoded && !sandboxFileMetadata(value, stringValue8(file?.path) ?? "").binary) {
     try {
       return Buffer.from(encoded, "base64").toString("utf8");
     } catch {
       return null;
     }
   }
-  return stringValue7(record9?.content) ?? stringValue7(record9?.text) ?? stringValue7(record9?.contents) ?? stringValue7(file?.content) ?? stringValue7(file?.text);
+  return stringValue8(record9?.content) ?? stringValue8(record9?.text) ?? stringValue8(record9?.contents) ?? stringValue8(file?.content) ?? stringValue8(file?.text);
 }
 function contentTypeForResourcePath(value) {
   const lower = value.toLowerCase();
@@ -27959,7 +28343,7 @@ function sandboxFileRecord(value) {
 }
 function sandboxFileMetadata(value, resourcePath) {
   const file = sandboxFileRecord(value);
-  const contentType = stringValue7(file?.contentType) ?? stringValue7(file?.mimeType) ?? contentTypeForResourcePath(resourcePath);
+  const contentType = stringValue8(file?.contentType) ?? stringValue8(file?.mimeType) ?? contentTypeForResourcePath(resourcePath);
   const sizeBytes = numberValue3(file?.sizeBytes) ?? numberValue3(file?.size);
   const binary = file?.binary === true || file?.isBinary === true || (contentType ? isBinaryContentType(contentType) : isLikelyBinaryResourcePath(resourcePath));
   return { binary, contentType, ...sizeBytes !== null ? { sizeBytes } : {} };
@@ -28045,8 +28429,8 @@ function actionCatalogItemForModel(action) {
     directRunAllowed,
     inputSchema: action.inputSchema ?? null,
     outputSchema: action.outputSchema ?? null,
-    agentId: action.agentId ?? stringValue7(implementation?.agentId),
-    projectId: stringValue7(implementation?.projectId),
+    agentId: action.agentId ?? stringValue8(implementation?.agentId),
+    projectId: stringValue8(implementation?.projectId),
     sourceActionId: action.sourceActionId ?? null
   };
 }
@@ -28069,7 +28453,7 @@ function failedActionToolResult(callId, name, message) {
 function asRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function stringValue7(value) {
+function stringValue8(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function numberValue3(value) {
@@ -33236,7 +33620,7 @@ function redactConnectedAppToolArguments(toolName, args) {
   return redacted && typeof redacted === "object" && !Array.isArray(redacted) ? redacted : {};
 }
 async function executeConnectedAppToolDefinition(input) {
-  const provider = normalizeConnectedAppProviderFamilyId(stringValue8(input.context.args.provider));
+  const provider = normalizeConnectedAppProviderFamilyId(stringValue9(input.context.args.provider));
   if (!provider) {
     return connectedAppToolFailure(input.context.callId, input.toolName, "Connected app provider is required.");
   }
@@ -33276,7 +33660,7 @@ async function executeConnectedAppToolDefinition(input) {
       }
     );
   }
-  if (input.operation === "write" && !stringValue8(input.context.args.explicitUserIntent)) {
+  if (input.operation === "write" && !stringValue9(input.context.args.explicitUserIntent)) {
     return connectedAppToolFailure(
       input.context.callId,
       input.toolName,
@@ -33368,7 +33752,7 @@ async function executeConnectedAppToolDefinition(input) {
 function inferredProviderOperationCapabilityIds(input) {
   const providerOperation = connectedAppProviderOperationById(
     input.provider,
-    stringValue8(input.args.operation)
+    stringValue9(input.args.operation)
   );
   if (!providerOperation || providerOperation.operation !== input.operation) return null;
   return providerOperation.capabilityIds;
@@ -33385,8 +33769,8 @@ function connectedAppProviderErrorSummary(data) {
   const result = isRecord5(record9.result) ? record9.result : null;
   const metadata = isRecord5(record9.metadata) ? record9.metadata : null;
   const httpStatus = numberValue4(metadata?.httpStatus) ?? numberValue4(result?.status);
-  const title = stringValue8(result?.title);
-  const detail = stringValue8(result?.detail);
+  const title = stringValue9(result?.title);
+  const detail = stringValue9(result?.detail);
   if (!httpStatus && !title && !detail) return null;
   const statusText = httpStatus ? `Provider returned HTTP ${httpStatus}` : "Provider returned an error";
   const titleText = title ? ` ${title}` : "";
@@ -33464,7 +33848,7 @@ function dedupeContexts(contexts) {
   }
   return [...byProvider.values()];
 }
-function stringValue8(value) {
+function stringValue9(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function numberValue4(value) {
@@ -37887,6 +38271,7 @@ function createCapabilityCatalogRuntime(deps) {
         actionCatalog: openPondActionCatalog,
         executeWorkspaceTool: deps.executeWorkspaceTool,
         executeProfileAction: deps.executeProfileAction,
+        executeProjectAction: deps.executeProjectAction,
         trainingHarness: options.trainingHarness
       });
     }
@@ -37976,7 +38361,8 @@ function createCapabilityCatalogRuntime(deps) {
         ...createOpenPondActionModelToolDefinitions({
           actionCatalog: openPondActionCatalog,
           executeWorkspaceTool: deps.executeWorkspaceTool,
-          executeProfileAction: deps.executeProfileAction
+          executeProfileAction: deps.executeProfileAction,
+          executeProjectAction: deps.executeProjectAction
         })
       );
     }
@@ -38887,7 +39273,7 @@ async function assertGeneratedSdkArtifacts(target, requireEvalPass = true) {
     );
   }
   const missingMetadata = actions.filter(
-    (action) => typeof action.id === "string" && (!stringValue9(action.label) || !stringValue9(action.description) || typeof action.timeoutSeconds !== "number")
+    (action) => typeof action.id === "string" && (!stringValue10(action.label) || !stringValue10(action.description) || typeof action.timeoutSeconds !== "number")
   );
   if (missingMetadata.length > 0) {
     throw new Error(
@@ -38897,7 +39283,7 @@ async function assertGeneratedSdkArtifacts(target, requireEvalPass = true) {
   const setupGate = buildOpenPondProfileSetupGate({
     actionCatalog: actions.filter((action) => typeof action.id === "string").map((action) => ({
       id: action.id,
-      name: stringValue9(action.name),
+      name: stringValue10(action.name),
       setupRequirements: recordArray(action.setupRequirements) ?? []
     })),
     actionId: target.defaultAction
@@ -38939,7 +39325,7 @@ function recordArray(value) {
 }
 function traceRefFromCommandResult(value) {
   const record9 = asRecord13(value);
-  const ref = stringValue9(record9?.traceArtifactRef);
+  const ref = stringValue10(record9?.traceArtifactRef);
   return ref?.startsWith(".openpond/") ? ref : null;
 }
 function summaryFromCommandResult(commandName, value) {
@@ -38970,7 +39356,7 @@ function summaryFromCommandResult(commandName, value) {
   }
   return null;
 }
-function stringValue9(value) {
+function stringValue10(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
@@ -39762,7 +40148,7 @@ async function executeAgentTasksetEvaluation(input) {
       task.id,
       0
     ]).slice(0, 24)}`;
-    const traceRef = stringValue10(parsed?.traceArtifactRef);
+    const traceRef = stringValue11(parsed?.traceArtifactRef);
     const attempt = TaskAttemptResultSchema.parse({
       schemaVersion: "openpond.taskAttempt.v1",
       id: attemptId,
@@ -39832,7 +40218,7 @@ function parseAgentRunPayload(stdout) {
 function recordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue10(value) {
+function stringValue11(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
@@ -39850,12 +40236,12 @@ async function runNormalizedAgentEvaluation(input) {
   const failed = numberValue6(payload.summary?.failed) ?? Math.max(0, total - passed);
   const publishGate = payload.publishGate?.status === "passed" ? "passed" : "failed";
   const results = Array.isArray(payload.results) ? payload.results : [];
-  const sdkEvalRefs = results.map((evaluation) => stringValue11(evaluation.name)).filter((value) => Boolean(value));
+  const sdkEvalRefs = results.map((evaluation) => stringValue12(evaluation.name)).filter((value) => Boolean(value));
   const artifactRefs = /* @__PURE__ */ new Set([
     path40.posix.join(input.sourceRef, ".openpond/eval-results.json")
   ]);
   for (const evaluation of results) {
-    const trace = stringValue11(evaluation.traceArtifactRef);
+    const trace = stringValue12(evaluation.traceArtifactRef);
     if (trace)
       artifactRefs.add(path40.posix.join(input.sourceRef, normalizeRef(trace)));
     for (const artifact of stringArray4(evaluation.artifacts)) {
@@ -39909,15 +40295,15 @@ async function runNormalizedAgentEvaluation(input) {
     summary: `${input.subject === "active" ? "Active" : input.subject === "candidate" ? "Candidate" : "Post-release"} Agent SDK and Taskset Evals: ${combinedPassed}/${combinedTotal} passed${combinedPublishGate === "failed" ? "; publish gate failed" : ""}.`,
     createdAt: timestamp,
     metadata: {
-      schemaVersion: stringValue11(payload.schemaVersion),
-      schema: stringValue11(payload.schema),
+      schemaVersion: stringValue12(payload.schemaVersion),
+      schema: stringValue12(payload.schema),
       project: {
-        name: stringValue11(payload.project?.name),
-        version: stringValue11(payload.project?.version)
+        name: stringValue12(payload.project?.name),
+        version: stringValue12(payload.project?.version)
       },
       source: {
-        configPath: stringValue11(payload.source?.configPath),
-        configHash: stringValue11(payload.source?.configHash)
+        configPath: stringValue12(payload.source?.configPath),
+        configHash: stringValue12(payload.source?.configHash)
       },
       publishGate: {
         total: numberValue6(payload.publishGate?.total),
@@ -39935,10 +40321,10 @@ async function runNormalizedAgentEvaluation(input) {
       executionContractHash: tasksetExecution?.executionContractHash ?? null,
       gradeRefs: tasksetExecution?.gradeRefs ?? [],
       results: results.map((evaluation) => ({
-        name: stringValue11(evaluation.name),
-        status: stringValue11(evaluation.status),
-        error: stringValue11(evaluation.error),
-        traceArtifactRef: stringValue11(evaluation.traceArtifactRef)
+        name: stringValue12(evaluation.name),
+        status: stringValue12(evaluation.status),
+        error: stringValue12(evaluation.error),
+        traceArtifactRef: stringValue12(evaluation.traceArtifactRef)
       }))
     }
   };
@@ -39977,14 +40363,14 @@ function parseAgentEvalPayload(stdout) {
 function normalizeRef(value) {
   return value.replace(/^\.\//, "").replaceAll("\\", "/");
 }
-function stringValue11(value) {
+function stringValue12(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function numberValue6(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function stringArray4(value) {
-  return Array.isArray(value) ? value.map(stringValue11).filter((item) => Boolean(item)) : [];
+  return Array.isArray(value) ? value.map(stringValue12).filter((item) => Boolean(item)) : [];
 }
 
 // ../server/src/runtime/create-pipeline/agent-improvement-git.ts
@@ -40207,13 +40593,13 @@ async function listPullRequestsForBranch(command, cwd, branch) {
 function normalizePullRequest(raw, openedAt = (/* @__PURE__ */ new Date()).toISOString(), updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
   const number = typeof raw.number === "number" ? raw.number : Number(raw.number);
   const stateValue = typeof raw.state === "string" ? raw.state.toLowerCase() : "";
-  const mergedAt = stringValue12(raw.mergedAt);
+  const mergedAt = stringValue13(raw.mergedAt);
   const state = mergedAt || stateValue === "merged" ? "merged" : stateValue === "open" ? "open" : "closed";
   const mergeCommitRecord = raw.mergeCommit && typeof raw.mergeCommit === "object" ? raw.mergeCommit : null;
-  const mergeCommit = stringValue12(mergeCommitRecord?.oid) ?? stringValue12(raw.mergeCommit);
-  const url = stringValue12(raw.url);
-  const baseBranch = stringValue12(raw.baseRefName);
-  const headBranch = stringValue12(raw.headRefName);
+  const mergeCommit = stringValue13(mergeCommitRecord?.oid) ?? stringValue13(raw.mergeCommit);
+  const url = stringValue13(raw.url);
+  const baseBranch = stringValue13(raw.baseRefName);
+  const headBranch = stringValue13(raw.headRefName);
   if (!Number.isInteger(number) || number <= 0 || !url || !baseBranch || !headBranch) {
     throw new Error("GitHub returned an incomplete pull request payload.");
   }
@@ -40265,7 +40651,7 @@ function assertCommand(result, message) {
   if (result.code === 0) return;
   throw new Error(result.stderr.trim() || result.stdout.trim() || message);
 }
-function stringValue12(value) {
+function stringValue13(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function defaultCommandRunner(command, args, cwd, env = {}) {
@@ -40838,8 +41224,8 @@ async function readAgentPackageOrigin(agentRootPath, manifestHash) {
     "agent-package-origin.json"
   );
   const origin = await fs20.readFile(originPath, "utf8").then((raw) => asRecord15(JSON.parse(raw))).catch(() => ({}));
-  const versionId = stringValue13(origin.versionId);
-  const digest = stringValue13(origin.digest);
+  const versionId = stringValue14(origin.versionId);
+  const digest = stringValue14(origin.digest);
   if (versionId && digest && /^[a-f0-9]{64}$/.test(digest) && versionId === `agent-${digest.slice(0, 20)}`) {
     return {
       versionId,
@@ -40858,7 +41244,7 @@ async function readAgentPackageOrigin(agentRootPath, manifestHash) {
 function asRecord15(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue13(value) {
+function stringValue14(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function stringArray5(value) {
@@ -41932,7 +42318,7 @@ function uniqueEvidence(run, evidence) {
 }
 async function verifyAppliedProfileCommit(input) {
   const command = input.command ?? (async (name, args, cwd, env) => {
-    const { runWorkspaceCommand } = await import("./workspaces-4A2OR2OP.js");
+    const { runWorkspaceCommand } = await import("./workspaces-N2WWI77O.js");
     return runWorkspaceCommand(name, args, cwd, env);
   });
   const result = await command("git", ["rev-parse", "HEAD"], input.repoPath);
@@ -46242,6 +46628,7 @@ function createTurnRunner(deps) {
     workInputsForSession,
     executeOpenPondCommand,
     executeProfileAction,
+    executeProjectAction,
     executeDatasetBuilderAction,
     loadOpenPondProfileState: loadOpenPondProfileState2,
     loadOpenPondProfileStateForRef: loadOpenPondProfileStateForRef2,
@@ -46682,6 +47069,7 @@ function createTurnRunner(deps) {
     executeWebSearch,
     createScheduledWork,
     executeProfileAction,
+    executeProjectAction,
     loadOpenPondProfileStateForRef: loadOpenPondProfileStateForRef2
   });
   function createNativeModelToolDefinitions(openPondActionCatalog, runtimeEvents, profileSkillRuntime, connectedApps, options = {}) {