@yielded/agent 0.1.0-beta.175 → 0.1.0-beta.177

package/src/durable/RunStorage.ts

@@ -113,6 +113,8 @@ export interface RunWriter {
 
 export interface RunStorageSession extends RunWriter, RunOwnership {
   readonly claim: Claim;
+  /** Atomic original input/context plus the ledger marker, when the adapter supports it. */
+  readonly appendInput?: RunWriter["append"];
   /** Library-only initialization, before application/model IO. Hold progress before mutation
    * so the captured controls and this owner's acknowledged input remain one read view. */
   readonly withInitialization?: <A, E, R>(
@@ -176,69 +178,75 @@ const makeWriter = Effect.fnUntraced(function* (threadId: ThreadId) {
     }),
   );
 
-  const append: RunWriter["append"] = Effect.fnUntraced(function* (batch, executions) {
-    const captured = yield* PreparedAppend.capture(
-      AppendRequest.make({
-        threadId,
-        expectedTailSequence: tail.sequence,
-        batch,
-        ...(executions === undefined ? {} : { executions }),
-      }),
-    ).pipe(
-      Effect.mapError((cause) =>
-        ThreadStoreError.make({
-          operation: "capture append",
-          message: cause.message,
-          cause,
+  const makeAppend = Effect.gen(function* () {
+    const publisher = yield* ThreadStore;
+
+    const append: RunWriter["append"] = Effect.fnUntraced(function* (batch, executions) {
+      const captured = yield* PreparedAppend.capture(
+        AppendRequest.make({
+          threadId,
+          expectedTailSequence: tail.sequence,
+          batch,
+          ...(executions === undefined ? {} : { executions }),
         }),
-      ),
-    );
+      ).pipe(
+        Effect.mapError((cause) =>
+          ThreadStoreError.make({
+            operation: "capture append",
+            message: cause.message,
+            cause,
+          }),
+        ),
+      );
 
-    return yield* owner.withProgress(
-      threadId,
-      owner.withMutation(
-        Effect.gen(function* () {
-          yield* checkActive;
-          for (let retries = 0; ; retries++) {
-            const result = yield* store
-              .append(
-                captured.expectedTailSequence === tail.sequence
-                  ? captured
-                  : AppendRequest.make({
-                      ...captured,
-                      expectedTailSequence: tail.sequence,
-                    }),
-              )
-              .pipe(
-                Effect.catchTag("AppendConflict", (conflict) => {
-                  if (
-                    conflict.reason !== "tail" ||
-                    conflict.actualTailSequence === undefined ||
-                    retries >= 8
-                  )
-                    return Effect.fail(conflict);
-                  tail = { sequence: conflict.actualTailSequence };
-                  if (captured.executions !== undefined) return Effect.fail(conflict);
-
-                  return Effect.succeed(undefined);
-                }),
-              );
-
-            if (result === undefined) continue;
-            // A historical replay returns its original coordinates, not today's canonical tail.
-            if (result.replayed) yield* refresh;
-            else tail = { sequence: result.lastSequence };
-
-            return result;
-          }
-        }).pipe(
-          // Revoke uncertain writes before releasing the writer's mutation gate.
-          Effect.onError((cause) =>
-            isDefiniteWriteFailure(cause) ? Effect.void : ownership.release,
+      return yield* owner.withProgress(
+        threadId,
+        owner.withMutation(
+          Effect.gen(function* () {
+            yield* checkActive;
+            for (let retries = 0; ; retries++) {
+              const result = yield* publisher
+                .append(
+                  captured.expectedTailSequence === tail.sequence
+                    ? captured
+                    : AppendRequest.make({
+                        ...captured,
+                        expectedTailSequence: tail.sequence,
+                      }),
+                )
+                .pipe(
+                  Effect.catchTag("AppendConflict", (conflict) => {
+                    if (
+                      conflict.reason !== "tail" ||
+                      conflict.actualTailSequence === undefined ||
+                      retries >= 8
+                    )
+                      return Effect.fail(conflict);
+                    tail = { sequence: conflict.actualTailSequence };
+                    if (captured.executions !== undefined) return Effect.fail(conflict);
+
+                    return Effect.succeed(undefined);
+                  }),
+                );
+
+              if (result === undefined) continue;
+              // A historical replay returns its original coordinates, not today's canonical tail.
+              if (result.replayed) yield* refresh;
+              else tail = { sequence: result.lastSequence };
+
+              return result;
+            }
+          }).pipe(
+            // Revoke uncertain writes before releasing the writer's mutation gate.
+            Effect.onError((cause) =>
+              isDefiniteWriteFailure(cause) ? Effect.void : ownership.release,
+            ),
           ),
         ),
-      ),
-    );
+      );
+    });
+
+    return append;
   });
 
   const writer = {
@@ -247,13 +255,14 @@ const makeWriter = Effect.fnUntraced(function* (threadId: ThreadId) {
     withProgress: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
       owner.withProgress(threadId, Effect.andThen(checkActive, effect)),
     tail: Effect.sync(() => tail),
-    append,
+    append: yield* makeAppend,
     checkActive: owner.withMutation(checkActive),
     refresh,
   };
 
   return {
     writer,
+    makeAppend,
     adoptTail: (sequence: CanonicalSequence) => {
       tail = { sequence };
     },
@@ -310,7 +319,7 @@ export const make = Effect.gen(function* () {
               });
             yield* store.materialize(ThreadMaterialization.make({ threadId: request.threadId }));
 
-            const { writer, adoptTail } = yield* makeWriter(request.threadId).pipe(
+            const { writer, makeAppend, adoptTail } = yield* makeWriter(request.threadId).pipe(
               Effect.provideService(WriterOwnership, generation),
               Effect.provideService(ThreadStore, store),
               Effect.provideService(StorageOwner, owner),
@@ -318,9 +327,22 @@ export const make = Effect.gen(function* () {
 
             const owned = <A, E>(effect: Effect.Effect<A, E>) => generation.use(effect);
 
+            const inputPublisher = ledger.appendInput;
+
+            const appendInput =
+              inputPublisher === undefined
+                ? undefined
+                : yield* makeAppend.pipe(
+                    Effect.provideService(ThreadStore, {
+                      ...store,
+                      append: (request) => inputPublisher(claimed.submissionId, request),
+                    }),
+                  );
+
             const session: RunStorageSession = {
               ...writer,
               claim: claimed,
+              ...(appendInput === undefined ? {} : { appendInput }),
               withInitialization: (effect) =>
                 owner.withProgress(request.threadId, generation.use(effect)),
               release: generation.release,

package/src/durable/SubmissionLedger.ts

@@ -36,6 +36,7 @@ import {
   ToolCallUnknown,
   WorkerAdmission,
 } from "./Records.ts";
+import type { AppendRequest, AppendResult, ThreadStoreFailure } from "./ThreadStore.ts";
 
 export { IdempotencyKey, JoinedToHost, QueueSequence, Principal } from "../core/Receipt.ts";
 
@@ -1113,6 +1114,13 @@ export class SubmissionLedger extends Context.Service<
     readonly selectHead: (
       request: ClaimRequest,
     ) => Effect.Effect<Option.Option<Claim>, LedgerError>;
+    /** Atomically publish a captured original input, active context and applied marker.
+     * Optional adapters retain the ordinary append-then-repair protocol. The captured input
+     * must be this owner's deterministic admission; a moved context boundary is refused. */
+    readonly appendInput?: (
+      submissionId: SubmissionId,
+      request: AppendRequest,
+    ) => Effect.Effect<AppendResult, ThreadStoreFailure>;
     readonly markInputApplied: (
       request: MarkInputAppliedRequest,
     ) => Effect.Effect<void, OwnershipLost | LedgerError>;

package/src/durable/ThreadStore.ts

@@ -343,19 +343,20 @@ export class AppendRequest extends Schema.Class<AppendRequest>(
   expectedTailSequence: CanonicalSequence,
 }) {}
 
+const RecordCount = Schema.Array(Schema.Unknown).check(Schema.isMaxLength(256));
+const ExecutionRecordCount = Schema.Array(Schema.Unknown).check(Schema.isMaxLength(8));
+
 const AppendHeader = Schema.Struct({
   threadId: ThreadId,
   expectedTailSequence: CanonicalSequence,
   batchId: BatchId,
   producerId: ProducerId,
+  records: RecordCount,
+  executions: RecordCount,
 });
 
 const validateHeader = Schema.decodeUnknownSync(AppendHeader);
 
-const validateRecordCount = Schema.decodeUnknownSync(
-  Schema.Array(Schema.Unknown).check(Schema.isMaxLength(256)),
-);
-
 const validateExecutionHeader = Schema.decodeUnknownSync(
   Schema.Struct({
     previousRevision: ExecutionUpdate.fields.previousRevision,
@@ -366,24 +367,36 @@ const validateExecutionHeader = Schema.decodeUnknownSync(
       originalSequence: ExecutionCheckpoint.fields.originalSequence,
       throughSequence: ExecutionCheckpoint.fields.throughSequence,
       batchId: ExecutionCheckpoint.fields.batchId,
+      operational: ExecutionRecordCount,
     }),
+    facts: ExecutionRecordCount,
   }),
 );
 
-const validateExecutionRecordCount = Schema.decodeUnknownSync(
-  Schema.Array(Schema.Unknown).check(Schema.isMaxLength(8)),
-);
-
 /** Capture records once; wrapper fields retain their owning Schema's constraints. */
 const captureExecution = (input: ExecutionUpdate) => {
-  const header = validateExecutionHeader(input);
-  const operationalInput = input.checkpoint.operational;
+  const checkpointInput = input.checkpoint;
+  const operationalInput = checkpointInput.operational;
   const factsInput = input.facts;
 
-  const operationalLength = validateExecutionRecordCount(operationalInput).length;
-  const factsLength = validateExecutionRecordCount(factsInput).length;
+  const header = validateExecutionHeader({
+    previousRevision: input.previousRevision,
+    retire: input.retire,
+    checkpoint: {
+      version: checkpointInput.version,
+      canonicalRecords: checkpointInput.canonicalRecords,
+      originalSequence: checkpointInput.originalSequence,
+      throughSequence: checkpointInput.throughSequence,
+      batchId: checkpointInput.batchId,
+      operational: operationalInput,
+    },
+    facts: factsInput,
+  });
+
+  const operationalLength = header.checkpoint.operational.length;
+  const factsLength = header.facts.length;
 
-  const progress = captureRecord(input.checkpoint.progressRecord);
+  const progress = captureRecord(checkpointInput.progressRecord);
 
   if (Result.isFailure(progress)) return Result.fail(progress.failure);
   const progressRecord = progress.success.canonical;
@@ -530,15 +543,19 @@ export const PreparedAppend = {
       return Effect.try({
         try: () =>
           Result.gen(function* () {
+            const executions = input.executions ?? [];
+            const recordInputs = input.batch.records;
+
             const header = validateHeader({
               ...input,
               batchId: input.batch.batchId,
               producerId: input.batch.producerId,
+              records: recordInputs,
+              executions,
             });
 
-            validateRecordCount(input.batch.records);
-            const executions = input.executions ?? [];
-            const executionLength = validateRecordCount(executions).length;
+            const recordLength = header.records.length;
+            const executionLength = header.executions.length;
 
             const executionWrites: Array<PreparedAppend["executionWrites"][number]> = [];
 
@@ -546,7 +563,7 @@ export const PreparedAppend = {
               executionWrites.push(yield* captureExecution(executions[index]!));
             Object.freeze(executionWrites);
 
-            if (input.batch.records.length === 0 && executionWrites.length === 0)
+            if (recordLength === 0 && executionWrites.length === 0)
               return yield* Result.fail(
                 ThreadStoreError.make({
                   operation: "prepare durable commit",
@@ -560,8 +577,11 @@ export const PreparedAppend = {
                   message: "Active state exceeds its bounded transfer representation",
                 }),
               );
-            // Visit sparse slots too: capture owns each record's validation boundary.
-            const encodings = yield* Result.all(Array.from(input.batch.records, captureRecord));
+            // Visit Schema-validated indexed slots, including sparse ones, never a caller's iterator.
+            const encodings = [];
+
+            for (let index = 0; index < recordLength; index++)
+              encodings.push(yield* captureRecord(recordInputs[index]!));
             const prefix = `{"batchId":${JSON.stringify(header.batchId)},"producerId":${JSON.stringify(header.producerId)},"records":[`;
             const batchJson = `${prefix}${encodings.map(({ json }) => json).join(",")}]}`;
 

package/src/durable/internal/agent-updates.ts

@@ -2,6 +2,7 @@ import { Clock, Crypto, DateTime, Effect, Option, Schema, Stream } from "effect"
 
 import { Update, UpdateError } from "../../core/AgentUpdates.ts";
 import type { RunId, SubmissionId, ThreadId } from "../../core/Identifiers.ts";
+import { nativeUpdateId } from "../../core/internal/agent-updates.ts";
 import { utf8ByteLength } from "../../core/internal/utf8.ts";
 import { IdempotencyKey } from "../../core/Receipt.ts";
 import { digestJson } from "../Digest.ts";
@@ -16,6 +17,8 @@ import {
   BatchId,
   CanonicalBatch,
   DefinitionDigests,
+  type CanonicalRecordEnvelope,
+  type DeclaredToolCall,
   type DeploymentId,
   PersistedJson,
   type ProducerId,
@@ -26,7 +29,7 @@ import { CurrentRunWriter, readRunEvidenceSnapshot } from "../RunContinuation.ts
 import { runIdForSubmission } from "../RunJournal.ts";
 import { LedgerError, type SubmissionSnapshot } from "../SubmissionLedger.ts";
 import { PreparedInput } from "../Subscription.ts";
-import { ThreadReader, ThreadStore, ThreadTailRequest } from "../ThreadStore.ts";
+import { getRecord, ThreadReader, ThreadStore, ThreadTailRequest } from "../ThreadStore.ts";
 import {
   deliveryPredecessor,
   decodeWorkCursor,
@@ -44,6 +47,37 @@ const storage = () =>
 
 const rejected = (reason: UpdateError["reason"]) => UpdateError.make({ reason });
 
+const updateDigest = (threadId: ThreadId, runId: RunId, updateId: string) =>
+  digestJson([threadId, runId, updateId]);
+
+const nativeParameters = Schema.Struct({ value: Schema.Json });
+const isNativeParameters = Schema.is(nativeParameters);
+const definitionDigestsEqual = Schema.toEquivalence(DefinitionDigests);
+const updateValuesEqual = Schema.toEquivalence(Schema.Json);
+
+/** Canonical native acceptance proves only this exact update call, never an external effect.
+ * Its frozen delivery remains independently recoverable even when its Tool acknowledgement is lost.
+ */
+export const nativeUpdateAccepted = (
+  submission: SubmissionSnapshot,
+  call: DeclaredToolCall,
+  records: ReadonlyArray<CanonicalRecordEnvelope>,
+): boolean => {
+  if (call.toolName !== "emit_update" || !isNativeParameters(call.parameters)) return false;
+  const value = call.parameters.value;
+
+  return records.some(
+    ({ record: { payload } }) =>
+      payload._tag === "AgentUpdateEmitted" &&
+      payload.update.threadId === submission.threadId &&
+      payload.update.agentId === submission.agentId &&
+      payload.update.runId === call.runId &&
+      payload.update.updateId === nativeUpdateId(call.runId, call.toolCallId) &&
+      definitionDigestsEqual(payload.definitions, submission.agentDigests) &&
+      updateValuesEqual(payload.update.value, value),
+  );
+};
+
 /** Acceptance is fenced by the actual emitting Attempt; recovery only recreates frozen outbox rows. */
 export const makeAgentUpdateRuntime = Effect.fnUntraced(function* (options: {
   readonly deploymentId: DeploymentId;
@@ -58,6 +92,28 @@ export const makeAgentUpdateRuntime = Effect.fnUntraced(function* (options: {
 
   const reader = ThreadReader.fromStore(store);
 
+  // Terminal operation evidence excludes updates; fetch the original acceptance by its
+  // stable identity instead of expanding every operation's recovery history.
+  const accepted = Effect.fnUntraced(function* (
+    submission: SubmissionSnapshot,
+    call: DeclaredToolCall,
+  ) {
+    if (call.toolName !== "emit_update") return false;
+
+    const digest = yield* updateDigest(
+      submission.threadId,
+      call.runId,
+      nativeUpdateId(call.runId, call.toolCallId),
+    ).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError(storage));
+
+    const record = yield* getRecord({
+      threadId: submission.threadId,
+      recordId: RecordId.make(`agent-update:${digest}`),
+    }).pipe(Effect.provideService(ThreadReader, reader), Effect.mapError(storage));
+
+    return Option.isSome(record) && nativeUpdateAccepted(submission, call, [record.value]);
+  });
+
   const readRun = Effect.fnUntraced(function* (threadId: ThreadId, submissionId: SubmissionId) {
     const tail = yield* store
       .inspectTail(ThreadTailRequest.make({ threadId }))
@@ -194,7 +250,7 @@ export const makeAgentUpdateRuntime = Effect.fnUntraced(function* (options: {
         Effect.mapError(() => rejected("validation")),
       );
 
-      const digest = yield* digestJson([request.submission.threadId, request.runId, updateId]).pipe(
+      const digest = yield* updateDigest(request.submission.threadId, request.runId, updateId).pipe(
         Effect.provideService(Crypto.Crypto, crypto),
         Effect.mapError(storage),
       );
@@ -367,5 +423,5 @@ export const makeAgentUpdateRuntime = Effect.fnUntraced(function* (options: {
       ),
   );
 
-  return { emit, repair: insert, repairRun };
+  return { emit, accepted, repair: insert, repairRun };
 });

package/src/durable/internal/initial-context.ts

@@ -1,17 +1,32 @@
 import { Effect, Option, Schema, Stream } from "effect";
 import { Prompt } from "effect/ai";
 
-import { CanonicalSequence, type CanonicalRecordEnvelope } from "../Records.ts";
+import {
+  CanonicalSequence,
+  type CanonicalRecordEnvelope,
+  type RecordEnvelope,
+  type UserInputRecorded,
+} from "../Records.ts";
 import { RunJournalError, toolCallSettledRecordId } from "../RunJournal.ts";
 import { submissionSettlementRecordId } from "../SubmissionLedger.ts";
 import { getRecord, getRunInput, PROMPT_EVIDENCE_TAGS, ThreadReader } from "../ThreadStore.ts";
 import type { JournalRecordEnvelope } from "./journal-metadata.ts";
 
+/** A captured original input can prepare context before its atomic publication. It carries
+ * an expected position, never a committed observation cursor or dispatch authority. */
+export type InitialContextInput =
+  | CanonicalRecordEnvelope
+  | {
+      readonly threadId: CanonicalRecordEnvelope["threadId"];
+      readonly sequence: CanonicalRecordEnvelope["sequence"];
+      readonly record: RecordEnvelope & { readonly payload: UserInputRecorded };
+    };
+
 const invalid = (message: string) => RunJournalError.make({ message });
 const promptTag = new Set<string>(PROMPT_EVIDENCE_TAGS);
 
 /** Fresh admission trusts validated immutable history; recovery verifies its saved Prompt digest. */
-export const initialContext = Effect.fnUntraced(function* (original: CanonicalRecordEnvelope) {
+export const initialContext = Effect.fnUntraced(function* (original: InitialContextInput) {
   const reader = yield* ThreadReader;
   const threadId = original.threadId;
   const through = CanonicalSequence.make(original.sequence - 1);

package/src/durable/internal/prompt-history-cache.ts

@@ -6,9 +6,9 @@ import { boundedValueFootprint } from "../../engine/internal/bounded-value.ts";
 import { canonicalJson, digestCanonicalJson, utf8ByteLength } from "../Digest.ts";
 import {
   CanonicalSequence,
+  type CanonicalRecordEnvelope,
   CURRENT_RECORD_FORMAT,
   PromptRecord,
-  type CanonicalRecordEnvelope,
   type Digest,
   type PromptRecordEnvelope,
   type RecordEnvelope,
@@ -23,6 +23,7 @@ import {
   ThreadStore,
   ThreadTailRequest,
 } from "../ThreadStore.ts";
+import type { InitialContextInput } from "./initial-context.ts";
 import type { JournalRecordEnvelope } from "./journal-metadata.ts";
 import { promptJsonFootprint } from "./prompt-footprint.ts";
 import { captureRecord } from "./record-encoding.ts";
@@ -149,12 +150,14 @@ const retainedBytes = (value: unknown, json: string, allowance: number) => {
   return footprint === undefined ? undefined : encodedBytes + 2 * footprint;
 };
 
-const encodeHistory = Effect.fnUntraced(function* (prompt: Prompt.Prompt, allowance: number) {
-  const value = yield* encodePrompt(prompt);
-  const encoded = canonicalJson(value);
+const encodeHistory = (prompt: Prompt.Prompt, allowance: number) =>
+  Effect.suspend(() =>
+    Effect.mapEager(encodePrompt(prompt), (value) => {
+      const encoded = canonicalJson(value);
 
-  return { encoded, bytes: retainedBytes(value, encoded, allowance) };
-});
+      return { encoded, bytes: retainedBytes(value, encoded, allowance) };
+    }),
+  );
 
 // Finish parsing/decoding before suspending for suffix reads. Only the native prefix and its
 // canonical string leave this Effect; it does not keep a second parsed root in the outer Run.
@@ -252,7 +255,9 @@ const suffixRecordFootprint = (entry: PromptRecordEnvelope, allowance: number) =
  * acknowledged, consecutive appends. Never authority for writes or recovery; any uncertainty
  * discards this derivative and completion rereads canonical history.
  */
-export const makeCommittedPromptSuffix = (original: CanonicalRecordEnvelope) => {
+export const makeCommittedPromptSuffix = (
+  original: Pick<CanonicalRecordEnvelope, "threadId" | "sequence" | "record">,
+) => {
   const records: Array<PromptRecordEnvelope> = [];
 
   const runId =
@@ -558,7 +563,7 @@ export const makePromptHistoryCache = Effect.fnUntraced(function* () {
   const complete = Effect.fnUntraced(
     function* (
       writer: WriterIdentity,
-      original: CanonicalRecordEnvelope,
+      original: InitialContextInput,
       history: PromptHistory,
       committed?: CommittedPromptSuffix,
     ) {

package/src/durable/internal/worker-host.ts

@@ -3083,7 +3083,9 @@ export const makeWorkerRuntime = Effect.fnUntraced(function* (options: WorkerRun
                 ? "stopped"
                 : "stopping"
               : control.active !== null
-                ? "active"
+                ? control.active.state === "unknown"
+                  ? "unknown"
+                  : "active"
                 : delivery !== undefined
                   ? "starting"
                   : "idle"),

package/src/engine/DurableStep.ts

@@ -1,40 +1,14 @@
 import type { Effect, Option } from "effect";
-import type { Tool } from "effect/ai";
 import * as Context from "effect/Context";
 import * as Schema from "effect/Schema";
 
 import { ToolCallId } from "../core/Identifiers.ts";
 
-/**
- * Declared external execution class of one Tool, used by the durable runtime
- * to decide which Tool Calls need the prepared/settled uncertainty protocol:
- *
- * - `"readonly"`: the handler performs no external mutation. A crash between
- *   start and settlement is a free re-run; no prepared record is written.
- * - `"idempotent"`: the handler declares an external idempotency contract
- *   (it owns key derivation). Prepared/settled records are written and
- *   recovery may re-execute without reconciliation proof.
- * - `"uncertain"`: no external contract is declared. Prepared/settled records
- *   are written and recovery must reconcile or record an Unknown Outcome.
- */
-export type ToolExecutionClassValue = "readonly" | "idempotent" | "uncertain";
-
-/**
- * Effect AI Tool annotation key declaring a Tool's execution class, applied
- * with `Tool.annotate(ToolExecutionClass, "...")`.
- *
- * Unannotated Tools default to `"uncertain"`: security and durability
- * decisions are fail-closed, so the framework never infers a safer class
- * from a Tool's shape.
- */
-export const ToolExecutionClass = Context.Reference<ToolExecutionClassValue>(
-  "@effect-agent/engine/ToolExecutionClass",
-  { defaultValue: () => "uncertain" },
-);
-
-/** Read a Tool's declared execution class, falling back to the fail-closed `"uncertain"` default. */
-export const getToolExecutionClass = (tool: Tool.Any): ToolExecutionClassValue =>
-  Context.get(tool.annotations, ToolExecutionClass);
+export {
+  ToolExecutionClass,
+  getToolExecutionClass,
+  type ToolExecutionClassValue,
+} from "../core/internal/tool-execution.ts";
 
 /** Stable identity of one Step within one Tool Call: `(toolCallId, stepName)`. */
 export interface RunStepKey {

package/src/engine/internal/agent-runtime.ts

@@ -71,6 +71,7 @@ import {
   type TurnId,
 } from "../../core/Identifiers.ts";
 import { IdGenerator } from "../../core/IdGenerator.ts";
+import { nativeUpdateId } from "../../core/internal/agent-updates.ts";
 import { copyJson } from "../../core/internal/json.ts";
 import { utf8ByteLength } from "../../core/internal/utf8.ts";
 import { IdempotencyKey } from "../../core/Receipt.ts";
@@ -9126,7 +9127,7 @@ function executeWithCompletion<
                     );
 
                     const updateId = yield* Schema.decodeEffect(IdempotencyKey)(
-                      `tool:${context.runId}:${call.toolCallId}`,
+                      nativeUpdateId(context.runId, call.toolCallId),
                     ).pipe(Effect.mapError(() => UpdateError.make({ reason: "validation" })));
 
                     const emitter = yield* Emitter;