deepline 0.3.43 → 0.3.45

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/runtime-step-receipts-adapter.ts

@@ -0,0 +1,522 @@
+import {
+  COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
+  RuntimeReceiptWaitTimeoutError,
+  type DurableReceiptExecutionStore,
+} from '../durable-receipt-execution';
+import {
+  deserializeToolExecuteResult,
+  isSerializedToolExecuteResult,
+  isToolExecuteResult,
+  serializeToolExecuteResult,
+  type ToolExecuteResult,
+} from '../tool-result';
+import type { RuntimeStepReceipt } from '../ctx-types';
+import type {
+  ToolCallReceiptLease,
+  ToolCallReceiptRecoverySource,
+  ToolResultReceipts,
+} from './contract';
+import { ToolCallReceiptLeaseLostError } from './contract';
+
+const DEFAULT_LOCK_TTL_MS = 300_000;
+const DEFAULT_LOCK_WAIT_MS = 15_000;
+const DEFAULT_LOCK_POLL_MS = 250;
+
+/**
+ * The already-provisioned RuntimeStepReceipt storage contract, bound to one
+ * Play Run by this adapter. It intentionally reuses the existing durable
+ * store instead of giving Tool Call another receipt table or lifecycle.
+ */
+export type RuntimeStepToolResultReceiptStore = Pick<
+  DurableReceiptExecutionStore,
+  | 'enabled'
+  | 'get'
+  | 'complete'
+  | 'acquireExecutionLock'
+  | 'releaseExecutionLock'
+>;
+
+export type RuntimeStepToolResultReceiptsInput = {
+  store: RuntimeStepToolResultReceiptStore;
+  owner: {
+    runId: string;
+  };
+  /**
+   * A completed-cache-only result has no in-flight receipt row. Non-idempotent
+   * provider operations therefore retain the historical, separate execution
+   * lock while dispatch is in progress.
+   */
+  executionLock?: {
+    required?: boolean;
+    ttlMs?: number;
+    waitMs?: number;
+    pollMs?: number;
+  };
+  /**
+   * Some runtime gateways require receipt reads/writes to share a hydration
+   * turn. Keep that transport concern at the Adapter boundary; ToolCall stays
+   * unaware of gateway sessions.
+   */
+  withCompletedReceiptHydration?: <Result>(
+    hydrate: () => Promise<Result>,
+  ) => Promise<Result>;
+  /**
+   * A caller that already performed the first hydrated cache read may pass it
+   * here. It is consumed once, preserving one read/turn for the normal cache
+   * path while still allowing a compatibility reader to inspect old rows.
+   */
+  initialReceipt?: {
+    key: string;
+    receipt: RuntimeStepReceipt | null;
+  };
+  /**
+   * The portable Tool Call job deals in a complete result. The runner Adapter
+   * alone knows how its public result metadata distinguishes a cache replay
+   * from an in-flight follower. Keep that presentation concern at this seam.
+   */
+  recover?: (input: {
+    result: ToolExecuteResult;
+    resultReceiptKey: string;
+    source: ToolCallReceiptRecoverySource | 'owner';
+  }) => ToolExecuteResult;
+  /** Injectable only for deterministic adapter conformance tests. */
+  sleep?: (milliseconds: number) => Promise<void>;
+};
+
+type OwnedReceipt = {
+  resultReceiptKey: string;
+  ownerRunId: string;
+  force: boolean;
+  executionLockOwnerId: string | null;
+  lockLost: boolean;
+  completedByAnotherOwner: ToolExecuteResult | null;
+  heartbeatTimer: ReturnType<typeof setTimeout> | null;
+  heartbeatInFlight: Promise<void> | null;
+};
+
+/**
+ * Adapts the durable RuntimeStepReceipt store to the Tool Result Receipt port.
+ *
+ * Tool results deliberately use the store's immutable completed-cache mode:
+ * a cache hit is reused, execution does not publish a `running` row, and the
+ * winner inserts one serialized ToolExecuteResult. That is what lets a V2
+ * receipt key be distinct from a legacy one without creating another provider
+ * invocation fence. The provider fence remains the dispatcher's Operation.
+ */
+export function createRuntimeStepToolResultReceipts(
+  input: RuntimeStepToolResultReceiptsInput,
+): ToolResultReceipts {
+  const ownerRunId = required(input.owner.runId, 'owner run id');
+  const sleep = input.sleep ?? defaultSleep;
+  const lock = normalizeExecutionLock(input.executionLock);
+  const owned = new Map<string, OwnedReceipt>();
+  let initialReceipt = input.initialReceipt;
+  const hydrate = async <Result>(
+    read: () => Promise<Result>,
+  ): Promise<Result> =>
+    input.withCompletedReceiptHydration
+      ? await input.withCompletedReceiptHydration(read)
+      : await read();
+
+  const assertOwner = (candidate: {
+    resultReceiptKey: string;
+    ownerRunId?: string;
+    lease?: ToolCallReceiptLease;
+  }): OwnedReceipt => {
+    if (candidate.ownerRunId && candidate.ownerRunId !== ownerRunId) {
+      throw new ToolCallReceiptLeaseLostError(candidate.resultReceiptKey);
+    }
+    const lease = candidate.lease;
+    if (!lease || lease.ownerRunId !== ownerRunId) {
+      throw new ToolCallReceiptLeaseLostError(candidate.resultReceiptKey);
+    }
+    const record = owned.get(lease.leaseId);
+    if (
+      !record ||
+      record.resultReceiptKey !== candidate.resultReceiptKey ||
+      record.ownerRunId !== ownerRunId
+    ) {
+      throw new ToolCallReceiptLeaseLostError(candidate.resultReceiptKey);
+    }
+    return record;
+  };
+
+  const readCompleted = async (
+    resultReceiptKey: string,
+    source: ToolCallReceiptRecoverySource | 'owner' = 'cache',
+  ): Promise<ToolExecuteResult | null> => {
+    const receipt =
+      initialReceipt?.key === resultReceiptKey
+        ? (() => {
+            const value = initialReceipt!.receipt;
+            initialReceipt = undefined;
+            return value;
+          })()
+        : await hydrate(() => input.store.get(resultReceiptKey));
+    const result = completedResult(receipt, resultReceiptKey);
+    return result
+      ? (input.recover?.({ result, resultReceiptKey, source }) ?? result)
+      : null;
+  };
+
+  const releaseExecutionLock = async (record: OwnedReceipt): Promise<void> => {
+    if (!record.executionLockOwnerId || !input.store.releaseExecutionLock) {
+      return;
+    }
+    await input.store.releaseExecutionLock({
+      receiptKey: record.resultReceiptKey,
+      ownerExecutionId: record.executionLockOwnerId,
+    });
+    record.executionLockOwnerId = null;
+  };
+
+  const renewExecutionLock = async (
+    record: OwnedReceipt,
+  ): Promise<'active' | 'completed' | 'lost'> => {
+    if (!record.executionLockOwnerId || !input.store.acquireExecutionLock) {
+      return 'active';
+    }
+    const renewed = await input.store.acquireExecutionLock({
+      receiptKey: record.resultReceiptKey,
+      ownerExecutionId: record.executionLockOwnerId,
+      ttlMs: lock.ttlMs,
+    });
+    if (renewed?.ownerExecutionId === record.executionLockOwnerId) {
+      return 'active';
+    }
+    if (!record.force && input.store.enabled) {
+      const completed = await readCompleted(
+        record.resultReceiptKey,
+        'in_flight',
+      );
+      if (completed) {
+        record.completedByAnotherOwner = completed;
+        return 'completed';
+      }
+    }
+    record.lockLost = true;
+    return 'lost';
+  };
+
+  const startHeartbeat = (record: OwnedReceipt): void => {
+    if (!record.executionLockOwnerId || record.heartbeatTimer) return;
+    // Keep renewal comfortably inside the ownership TTL. The store permits
+    // short test/development TTLs too, so a one-second floor would silently
+    // let such a lease expire before its first renewal.
+    const intervalMs = Math.max(1, Math.floor(lock.ttlMs / 3));
+    const schedule = (): void => {
+      record.heartbeatTimer = setTimeout(() => {
+        record.heartbeatTimer = null;
+        record.heartbeatInFlight = renewExecutionLock(record)
+          .catch(() => {
+            record.lockLost = true;
+          })
+          .then(() => undefined)
+          .finally(() => {
+            record.heartbeatInFlight = null;
+            if (
+              !record.lockLost &&
+              !record.completedByAnotherOwner &&
+              record.executionLockOwnerId
+            ) {
+              schedule();
+            }
+          });
+      }, intervalMs);
+    };
+    schedule();
+  };
+
+  const stopHeartbeat = async (record: OwnedReceipt): Promise<void> => {
+    if (record.heartbeatTimer) {
+      clearTimeout(record.heartbeatTimer);
+      record.heartbeatTimer = null;
+    }
+    await record.heartbeatInFlight;
+  };
+
+  const acquireExecutionLock = async (
+    resultReceiptKey: string,
+    force: boolean,
+  ): Promise<string | null> => {
+    if (!lock.required || !input.store.enabled) return null;
+    if (
+      !input.store.acquireExecutionLock ||
+      !input.store.releaseExecutionLock
+    ) {
+      throw new Error(
+        'Tool Result Receipt requires the RuntimeStepReceipt execution-lock backend.',
+      );
+    }
+
+    const ownerExecutionId = `tool-result:${crypto.randomUUID()}`;
+    const deadline = Date.now() + lock.waitMs;
+    while (true) {
+      const acquired = await input.store.acquireExecutionLock({
+        receiptKey: resultReceiptKey,
+        ownerExecutionId,
+        ttlMs: lock.ttlMs,
+      });
+      if (acquired?.ownerExecutionId === ownerExecutionId) {
+        // Recheck after acquiring: a prior holder may have completed between
+        // our cache read and lock acquisition. A forced call intentionally
+        // bypasses that immutable completed fact, matching the legacy path.
+        if (!force) {
+          const cached = await readCompleted(resultReceiptKey, 'in_flight');
+          if (cached) {
+            await input.store.releaseExecutionLock({
+              receiptKey: resultReceiptKey,
+              ownerExecutionId,
+            });
+            return null;
+          }
+        }
+        return ownerExecutionId;
+      }
+
+      if (!force) {
+        const cached = await readCompleted(resultReceiptKey, 'in_flight');
+        if (cached) return null;
+      }
+      if (Date.now() >= deadline) {
+        throw new RuntimeReceiptWaitTimeoutError(resultReceiptKey);
+      }
+      await sleep(lock.pollMs);
+    }
+  };
+
+  return {
+    async claim(candidate) {
+      const resultReceiptKey = required(
+        candidate.resultReceiptKey,
+        'result receipt key',
+      );
+      if (candidate.ownerRunId !== ownerRunId) {
+        throw new ToolCallReceiptLeaseLostError(resultReceiptKey);
+      }
+      if (input.store.enabled && !candidate.force) {
+        const cached = await readCompleted(resultReceiptKey, 'cache');
+        if (cached) return { kind: 'completed', result: cached };
+      }
+
+      const executionLockOwnerId = await acquireExecutionLock(
+        resultReceiptKey,
+        candidate.force,
+      );
+      if (input.store.enabled && !candidate.force && !executionLockOwnerId) {
+        const cached = await readCompleted(resultReceiptKey, 'cache');
+        if (cached) return { kind: 'completed', result: cached };
+        // The only non-lock reason to get here is a store without a lock
+        // requirement. In that case this caller is still the cache publisher.
+      }
+
+      const leaseId =
+        executionLockOwnerId ?? `tool-result:${crypto.randomUUID()}`;
+      owned.set(leaseId, {
+        resultReceiptKey,
+        ownerRunId,
+        force: candidate.force,
+        executionLockOwnerId,
+        lockLost: false,
+        completedByAnotherOwner: null,
+        heartbeatTimer: null,
+        heartbeatInFlight: null,
+      });
+      return {
+        kind: 'owned',
+        lease: { leaseId, ownerRunId },
+      };
+    },
+
+    async recover(candidate) {
+      const resultReceiptKey = required(
+        candidate.resultReceiptKey,
+        'result receipt key',
+      );
+      if (candidate.ownerRunId !== ownerRunId) {
+        throw new ToolCallReceiptLeaseLostError(resultReceiptKey);
+      }
+      const maxWaitMs = candidate.source === 'in_flight' ? lock.waitMs : 0;
+      const deadline = Date.now() + maxWaitMs;
+      while (true) {
+        const receipt = await hydrate(() => input.store.get(resultReceiptKey));
+        const completed = completedResult(receipt, resultReceiptKey);
+        if (completed) {
+          return (
+            input.recover?.({
+              result: completed,
+              resultReceiptKey,
+              source: candidate.source,
+            }) ?? completed
+          );
+        }
+        if (receipt?.status === 'failed') {
+          throw new Error(
+            `Tool Result Receipt ${resultReceiptKey} failed: ${receipt.error ?? 'unknown error'}.`,
+          );
+        }
+        if (Date.now() >= deadline) {
+          throw new RuntimeReceiptWaitTimeoutError(resultReceiptKey);
+        }
+        await sleep(lock.pollMs);
+      }
+    },
+
+    async heartbeat(candidate) {
+      const record = assertOwner({
+        resultReceiptKey: candidate.resultReceiptKey,
+        lease: candidate.lease,
+      });
+      if (!record.force && input.store.enabled) {
+        const cached = await readCompleted(
+          record.resultReceiptKey,
+          'in_flight',
+        );
+        if (cached) return 'completed';
+      }
+      if (!record.executionLockOwnerId) return 'active';
+      if (record.lockLost) return 'lost';
+      const renewal = await renewExecutionLock(record);
+      if (renewal === 'active') {
+        // ToolCall has one synchronous heartbeat seam before dispatch. Keep
+        // the existing lease policy alive for a long provider invocation by
+        // renewing in the Adapter until its terminal call stops the loop.
+        startHeartbeat(record);
+        return 'active';
+      }
+      if (renewal === 'completed') return 'completed';
+      if (!record.force && input.store.enabled) {
+        const cached = await readCompleted(record.resultReceiptKey);
+        if (cached) return 'completed';
+      }
+      return 'lost';
+    },
+
+    async complete(candidate) {
+      const record = assertOwner({
+        resultReceiptKey: candidate.resultReceiptKey,
+        lease: candidate.lease,
+      });
+      try {
+        await stopHeartbeat(record);
+        if (record.completedByAnotherOwner) {
+          return { kind: 'existing', result: record.completedByAnotherOwner };
+        }
+        if (record.lockLost) {
+          throw new ToolCallReceiptLeaseLostError(record.resultReceiptKey);
+        }
+        // A refresh executes under the provider fence but cannot replace the
+        // immutable receipt. Its fresh result is returned to this caller only.
+        if (record.force || !input.store.enabled) {
+          return { kind: 'stored', result: candidate.result };
+        }
+        const persisted = await hydrate(
+          async () =>
+            await input.store.complete(
+              record.resultReceiptKey,
+              ownerRunId,
+              serializeToolExecuteResult(candidate.result),
+              COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
+            ),
+        );
+        // Completion transports may acknowledge only status/ownership. The
+        // durable row already has the full serialized result, so read it back
+        // below instead of mistaking an intentionally compact reply for a
+        // malformed completed receipt.
+        const result =
+          persisted?.output === undefined
+            ? null
+            : completedResult(persisted, record.resultReceiptKey);
+        if (result) {
+          return {
+            // The legacy storage operation returns the converged completed row
+            // for both an insert and a concurrent winner. The exact distinction
+            // is intentionally unobservable; the public invariant is the
+            // converged immutable ToolExecuteResult.
+            kind: 'stored',
+            result,
+          };
+        }
+        const converged = await readCompleted(record.resultReceiptKey, 'owner');
+        if (converged) return { kind: 'existing', result: converged };
+        throw new Error(
+          `Tool Result Receipt ${record.resultReceiptKey} could not publish a completed result.`,
+        );
+      } finally {
+        await stopHeartbeat(record);
+        await releaseExecutionLock(record);
+        owned.delete(candidate.lease.leaseId);
+      }
+    },
+
+    async fail(candidate) {
+      const record = assertOwner({
+        resultReceiptKey: candidate.resultReceiptKey,
+        lease: candidate.lease,
+      });
+      try {
+        // Completed-cache-only mode has no owned in-flight row to mark failed.
+        // Recording a terminal failure would let an old owner overwrite a
+        // concurrent successful publisher. Releasing just our lock is safe;
+        // the original provider error remains the caller-visible fact.
+      } finally {
+        await stopHeartbeat(record);
+        await releaseExecutionLock(record);
+        owned.delete(candidate.lease.leaseId);
+      }
+    },
+  };
+}
+
+function completedResult(
+  receipt: RuntimeStepReceipt | null,
+  resultReceiptKey: string,
+): ToolExecuteResult | null {
+  if (receipt?.status !== 'completed' && receipt?.status !== 'skipped') {
+    return null;
+  }
+  if (isSerializedToolExecuteResult(receipt.output)) {
+    return deserializeToolExecuteResult(receipt.output);
+  }
+  if (isToolExecuteResult(receipt.output)) {
+    return receipt.output;
+  }
+  throw new Error(
+    `Completed Tool Result Receipt ${resultReceiptKey} has no valid serialized ToolExecuteResult.`,
+  );
+}
+
+function normalizeExecutionLock(
+  input: RuntimeStepToolResultReceiptsInput['executionLock'],
+): Required<NonNullable<RuntimeStepToolResultReceiptsInput['executionLock']>> {
+  const ttlMs = input?.ttlMs ?? DEFAULT_LOCK_TTL_MS;
+  const waitMs = input?.waitMs ?? DEFAULT_LOCK_WAIT_MS;
+  const pollMs = input?.pollMs ?? DEFAULT_LOCK_POLL_MS;
+  for (const [name, value] of [
+    ['ttlMs', ttlMs],
+    ['waitMs', waitMs],
+    ['pollMs', pollMs],
+  ] as const) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(
+        `Tool Result Receipt execution lock ${name} must be positive.`,
+      );
+    }
+  }
+  return {
+    required: input?.required === true,
+    ttlMs: Math.floor(ttlMs),
+    waitMs: Math.floor(waitMs),
+    pollMs: Math.floor(pollMs),
+  };
+}
+
+function required(value: string, name: string): string {
+  const normalized = value?.trim();
+  if (!normalized) throw new Error(`Tool Result Receipt requires a ${name}.`);
+  return normalized;
+}
+
+async function defaultSleep(milliseconds: number): Promise<void> {
+  await new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/testkit.ts

@@ -0,0 +1,165 @@
+import type { ToolExecuteResult } from '../tool-result';
+import type {
+  ToolCallDispatcher,
+  ToolCallReceiptLease,
+  ToolResultReceipts,
+} from './contract';
+
+type ReceiptState =
+  | {
+      kind: 'running';
+      lease: ToolCallReceiptLease;
+      settled: Promise<ToolExecuteResult>;
+      resolve(result: ToolExecuteResult): void;
+      reject(error: unknown): void;
+    }
+  | { kind: 'completed'; result: ToolExecuteResult }
+  | { kind: 'failed'; error: unknown };
+
+/** Test-only adapters that model the public lifecycle seams. */
+export function createMemoryToolResultReceipts(): ToolResultReceipts & {
+  entries(): ReadonlyMap<string, ToolExecuteResult>;
+  heartbeats(): readonly { resultReceiptKey: string; leaseId: string }[];
+  failures(): readonly { resultReceiptKey: string; error: unknown }[];
+} {
+  const states = new Map<string, ReceiptState>();
+  const completed = new Map<string, ToolExecuteResult>();
+  const heartbeats: Array<{ resultReceiptKey: string; leaseId: string }> = [];
+  const failures: Array<{ resultReceiptKey: string; error: unknown }> = [];
+  let nextLease = 0;
+
+  return {
+    async claim({ resultReceiptKey, ownerRunId, force }) {
+      const existing = states.get(resultReceiptKey);
+      if (!force && existing?.kind === 'completed') {
+        return { kind: 'completed', result: existing.result };
+      }
+      if (existing?.kind === 'running') return { kind: 'following' };
+      let resolve!: (result: ToolExecuteResult) => void;
+      let reject!: (error: unknown) => void;
+      const settled = new Promise<ToolExecuteResult>(
+        (resolvePromise, rejectPromise) => {
+          resolve = resolvePromise;
+          reject = rejectPromise;
+        },
+      );
+      // A receipt may fail before a follower attaches. Keep that durable
+      // failure from becoming an unhandled process rejection; recover() still
+      // returns the same rejected promise to a real follower.
+      void settled.catch(() => undefined);
+      const lease = { leaseId: `lease-${++nextLease}`, ownerRunId };
+      states.set(resultReceiptKey, {
+        kind: 'running',
+        lease,
+        settled,
+        resolve,
+        reject,
+      });
+      return { kind: 'owned', lease };
+    },
+    async recover({ resultReceiptKey }) {
+      const state = states.get(resultReceiptKey);
+      if (state?.kind === 'completed') return state.result;
+      if (state?.kind === 'failed') throw state.error;
+      if (state?.kind === 'running') return await state.settled;
+      throw new Error(`No Tool Result Receipt exists for ${resultReceiptKey}.`);
+    },
+    async heartbeat({ resultReceiptKey, lease }) {
+      heartbeats.push({ resultReceiptKey, leaseId: lease.leaseId });
+      const state = states.get(resultReceiptKey);
+      if (state?.kind === 'completed') return 'completed';
+      if (
+        state?.kind !== 'running' ||
+        state.lease.leaseId !== lease.leaseId ||
+        state.lease.ownerRunId !== lease.ownerRunId
+      ) {
+        return 'lost';
+      }
+      return 'active';
+    },
+    async complete({ resultReceiptKey, lease, result }) {
+      const state = states.get(resultReceiptKey);
+      if (state?.kind === 'completed') {
+        return { kind: 'existing', result: state.result };
+      }
+      if (
+        state?.kind !== 'running' ||
+        state.lease.leaseId !== lease.leaseId ||
+        state.lease.ownerRunId !== lease.ownerRunId
+      ) {
+        throw new Error(`Cannot complete unowned receipt ${resultReceiptKey}.`);
+      }
+      states.set(resultReceiptKey, { kind: 'completed', result });
+      completed.set(resultReceiptKey, result);
+      state.resolve(result);
+      return { kind: 'stored', result };
+    },
+    async fail({ resultReceiptKey, lease, error }) {
+      const state = states.get(resultReceiptKey);
+      if (
+        state?.kind === 'running' &&
+        state.lease.leaseId === lease.leaseId &&
+        state.lease.ownerRunId === lease.ownerRunId
+      ) {
+        states.set(resultReceiptKey, { kind: 'failed', error });
+        state.reject(error);
+      }
+      failures.push({ resultReceiptKey, error });
+    },
+    entries() {
+      return completed;
+    },
+    heartbeats() {
+      return heartbeats;
+    },
+    failures() {
+      return failures;
+    },
+  };
+}
+
+/**
+ * Models the server-side operation fence: multiple receipt representations
+ * may share one provider operation key while keeping separate result receipts.
+ */
+export function createSingleFlightToolCallDispatcher(input: {
+  dispatch(
+    input: Parameters<ToolCallDispatcher['dispatch']>[0],
+  ): Promise<ToolExecuteResult>;
+}): ToolCallDispatcher & {
+  dispatches(): readonly Parameters<ToolCallDispatcher['dispatch']>[0][];
+} {
+  const completed = new Map<string, ToolExecuteResult>();
+  const inFlight = new Map<string, Promise<ToolExecuteResult>>();
+  const dispatches: Parameters<ToolCallDispatcher['dispatch']>[0][] = [];
+  return {
+    async dispatch(call) {
+      // Receiptless calls are intentionally not single-flighted: they make no
+      // provider-operation claim and every invocation reaches the adapter.
+      if (!call.providerOperationKey) {
+        dispatches.push(call);
+        return await input.dispatch(call);
+      }
+      const providerOperationKey = call.providerOperationKey;
+      const cached = completed.get(providerOperationKey);
+      if (cached) return cached;
+      const owned = inFlight.get(providerOperationKey);
+      if (owned) return await owned;
+      dispatches.push(call);
+      const work = input
+        .dispatch(call)
+        .then((result) => {
+          completed.set(providerOperationKey, result);
+          return result;
+        })
+        .finally(() => {
+          inFlight.delete(providerOperationKey);
+        });
+      inFlight.set(providerOperationKey, work);
+      return await work;
+    },
+    dispatches() {
+      return dispatches;
+    },
+  };
+}

package/dist/cli/index.js

@@ -1043,7 +1043,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.43",
+  version: "0.3.45",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1

package/dist/cli/index.mjs

@@ -1029,7 +1029,7 @@ var SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: "0.3.43",
+  version: "0.3.45",
   updateSummary: "Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.",
   packageCapabilities: {
     updatePreferences: 1