@dudousxd/nestjs-agent-core 0.33.0 → 0.34.0

package/README.md

@@ -35,7 +35,9 @@ import type { ModelProvider, AgentStore, ToolSpec, RolesPolicy } from '@dudousxd
 - `MemoryRecord` / `MemoryProvider` / `offerMemories` / `writeMemory` — what the assistant concluded about a person or an organisation, carried across turns and threads. Scoped by the SAME opaque tokens and the same `ScopeResolver` skills use, so a deployment has one answer to "which scopes does this actor have". A memory is a keyed fact: `{ key, text, scope, origin, updatedAt }`, and the key is what makes a conflict mechanically detectable — two memories sharing a key at different scopes are one question answered twice, and `resolveMemoryDigest` lets the narrower win. Where it does, the entry's `overrides` carries the beaten **text** and its **author**, not merely its scope (a skill's `shadows`): the model is following one procedure either way, but a memory is a VALUE, and an agent that knew only that a wider one existed could tell the user nothing except which it picked. **Not retrieval:** a passage is a document someone authored and can fix at its source, a memory is the agent's own inference about someone who never saw it written — hence `MemoryOrigin` on every record, a block that tells the model these are its own fallible notes, and `forget` being REQUIRED on the provider while `write` is optional. Every provider method and every multi-argument export here takes ONE named object (`ListMemoriesInput`, `StoreMemoryInput`, `ResolveMemoryDigestInput`, …): `key`, `text` and `scope` are all strings, and transposed positional arguments would compile clean and write a fact whose key is its value. `memoryWriteVerdict` carries the same four rules as `skillWriteVerdict`; rule three (nothing but a human may write above its own scope, whatever elevation a host grants) is enforced by SHAPE as well as by check, since `rememberToolDefinition()` takes no scope parameter. `memoryForgetVerdict` is narrower still and takes no `elevated` flag: deleting what the assistant believes about YOU needs nobody's permission. What enters the system prompt is one line per memory bounded by `maxMemories` (`DEFAULT_MAX_MEMORIES`), each capped at `maxFactChars` (`DEFAULT_MAX_FACT_CHARS`) when it is WRITTEN — so the block's ceiling is the product of two numbers an operator set, and there is no body/catalog split because a fact that cannot be stated in a line is a document. **The prompt budget is bounded; the store is not.** Once the applicable set outgrows the block, WHICH memories it carries is a decision, and making it by scope starves the widest scopes first — one person's twentieth note would end every chance their organisation's facts had, leaving only a non-zero `omitted` behind. So a provider MAY implement `search({ scopes, query, limit, ctx })` and the block is filled by relevance to the turn instead; omit it and every turn is served by `list`, selecting narrowest-then-newest as before. Scope remains a hard FILTER that gates before ranking (a record returned outside `scopes` is dropped, so a host's filter bug costs throughput rather than privacy), and `search` must return every record sharing a returned key or precedence inverts. `MemoryRecord.pinned` is the categorical always-on marker — present whatever the turn is about, spending the same budget, never set by the agent (`StoreMemoryInput` has no such field, and the `remember` tool has no such parameter), with `MemoryDigest.pinnedOmitted` naming the one omission that is a misconfiguration rather than a budget. `buildMemoryBlock` frames entries by `origin.author`: what the agent CONCLUDED is hedged ("your own notes … prefer what the user says now"), what a person STATED is not, because telling a model to prefer the user over an organisation's published policy hands any user an override of it by assertion. A `partial` block says so, so the model does not read an absence as evidence. The loop spends ONE checkpoint (`memory:digest`) holding the whole digest — the search included, since a ranking is the most re-derivable decision here — which is both what the block is rendered from and what a later `remember` call is authorized against; the write itself happens inside the ordinary `tool:<callId>` checkpoint, which is what makes it idempotent under replay. The query is the user's own turn text and nothing else: the only thing available before the first model call, already a journaled input to the run, and it fails at a turn with no topic — which is what `pinned` is for.
 - `AgentStore.setMessageToolResults(messageId, results)` — a message's tool CALLS are known when it is appended and their outputs are not, so the loop settles them afterwards with one write of the turn's complete result list (its synthetic `retrieve` / `structured_output` calls included). Both halves live on the message because that is where a thread reader pairs them; a call whose output only ever reaches the `agent_tool_call` table renders as a tool still running. Required, not optional — a store that silently declines it breaks a client with nothing logged.
 - `AttachmentStagingStore.list(input)` / `AgentStore.referencedMediaIds(actorRef, mediaIds)` — the two halves of attachment housekeeping, split the way ownership is. `stage()` writes bytes before any message exists, so an upload the user never sent leaves media nothing points at; the HOST can enumerate that media (it stored it) but cannot see a transcript, and this library sees every transcript but never holds bytes. `list` returns `StagedAttachment` metadata (`mediaId`, `name`, `contentType`, `sizeBytes`, `createdAt` — no `url`, since `resolve` mints those per turn precisely so they can be short-lived); `referencedMediaIds` answers which of a set of ids a message that still exists carries, scoped to one actor. The answer is DERIVED from the surviving message rows on every call, never latched: `truncateFrom` deletes messages — regenerating a turn does exactly that — so a reference disappears, and a flag set at send time would pin the bytes for ever. Both are optional; a caller that cannot get an answer must collect nothing rather than read silence as "unreferenced". `AgentService.collectableAttachments` composes them, and deletes nothing.
-- `agentFailureCode(error)` — the stream error code for a failed run (`cancelled`, `quota_exceeded`, `output_rejected`, `structured_output_invalid`, else `run_failed`), so a control doing its job never reads as the model breaking.
+- `agentFailureCode(error)` — the stream error code for a failed run (`cancelled`, `quota_exceeded`, `output_rejected`, `structured_output_invalid`, `replay_diverged` for the durable runtime refusing a checkpoint position, `model_no_output` for a model call that produced nothing, else `run_failed`), so a control doing its job never reads as the model breaking. `streamFailure(error)` is the `{ code, message }` a runner closes the stream with: for a crash the message is `RUN_FAILED_MESSAGE` in production and the raw text elsewhere (`exposeStreamErrorDetails` decides it outright) — the error itself belongs in the log and on the run row.
+- `settleDanglingToolCalls(messages, outcomes?)` / `danglingToolCallIds(messages)` — give every tool call in a history a result. A turn that dies mid-step leaves an assistant message asking for tools and answered by nothing, which a provider refuses, so every later turn on the thread fails too. The loop settles them inside `load:thread` (no new position; a replay reads the recorded payload) from the calls' own rows where the store implements the optional `AgentStore.toolCallOutcomes` — a tool that DID run hands the model its real output, so it is not run again — and otherwise with `UNFINISHED_TOOL_CALL`. `AgentStore.failUnsettledToolCalls(runId, error)` (optional) is what a failing run calls so no approval card waits on it; `settleDeadRun(store, { runId, threadId?, failure? })` is the same for a caller with no journal left to write to.
+- `AiToolCtx.idempotencyKey` (`<runId>:<toolCallId>`) / `AiToolCtx.toolCallId` — the same for every execution of one call, so a tool re-run after a worker died between its side effect and its checkpoint (or by a transient retry) can be made to land on the first attempt. `toolCallContext(ctx, toolCallId)` builds it for a runner's own dispatched step.
 - `RunCancelledError` / `AgentLoopHooks.cancelled()` — real cancellation. The loop asks `hooks.cancelled()` at the points where stopping is safe and cheap (between steps, before the next model call, before a turn's tools are dispatched), ALWAYS from inside a checkpoint, so the answer is journaled and a cancel arriving between two replays can never change a branch a replayed position already took; the positions themselves sit behind `hooks.patched('agent:cancellation')`, so a run already in flight keeps its recorded shape. A tool already executing is never interrupted — there is no un-executing a side effect, and abandoning a dispatched step leaves a journal holding a dispatch whose result never lands. Observing a cancel throws `RunCancelledError`, which unwinds through the path a suspend already uses; the RUNNER settles it, recording the run `cancelled` (`AgentStore.recordRunEnd`'s third terminal, never `failed`) and ending the stream on a `{ kind: 'cancelled' }` frame rather than failing it, so a user pressing Stop is not in anybody's error rate.
 - `isControlFlowSignal(error)` / `isReplayIntegrityError(error)` — recognize a durable suspend and a checkpoint refusal without importing the durable packages (a `Symbol.for` marker and a class name, respectively). Rethrow both untouched from any `catch` in a workflow body.
 - `settleAll(tasks)` / `SettledTask<T>` — the implementation behind the optional `AgentLoopHooks.parallel`, which is how a turn's `read` tool calls run concurrently. It invokes every task synchronously, in list order, before awaiting any of them (so a runner that takes checkpoint positions on the call keeps them in call order), and resolves only once all of them have settled (so a runner that unwinds a turn by throwing never abandons a sibling mid-dispatch). A runner that assigns positions anywhere else simply omits the hook and the loop stays sequential.

package/dist/genui/index.d.cts

@@ -1,7 +1,7 @@
 import { a as Catalog, J as JsonSchema, G as GenuiValidation, b as GenuiIssue } from '../catalog-CrzetM3_.cjs';
 export { A as AjvLike, c as COMPONENT_NAME, d as CatalogOptions, C as ComponentDefinition, e as JsonSchemaValidator, P as PropsSchema, f as ajvValidator, g as builtinJsonSchemaValidator, h as defineCatalog, i as defineComponent, j as formatIssues, k as isStandardSchema, t as toJsonSchema, l as toSnakeCase, m as toolNameFor, v as validateProps, n as validatePropsSync } from '../catalog-CrzetM3_.cjs';
 import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
-import { A as Actor, T as ToolSpec, a as ToolHandler, b as ToolPresentation } from '../tool-CMTuoJ2v.cjs';
+import { A as Actor, T as ToolSpec, a as ToolHandler, b as ToolPresentation } from '../tool-C128TFWw.cjs';
 
 /**
  * One node of a composed UI: a catalog component, its props, and — for components declared with

package/dist/genui/index.d.ts

@@ -1,7 +1,7 @@
 import { a as Catalog, J as JsonSchema, G as GenuiValidation, b as GenuiIssue } from '../catalog-CrzetM3_.js';
 export { A as AjvLike, c as COMPONENT_NAME, d as CatalogOptions, C as ComponentDefinition, e as JsonSchemaValidator, P as PropsSchema, f as ajvValidator, g as builtinJsonSchemaValidator, h as defineCatalog, i as defineComponent, j as formatIssues, k as isStandardSchema, t as toJsonSchema, l as toSnakeCase, m as toolNameFor, v as validateProps, n as validatePropsSync } from '../catalog-CrzetM3_.js';
 import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
-import { A as Actor, T as ToolSpec, a as ToolHandler, b as ToolPresentation } from '../tool-CMTuoJ2v.js';
+import { A as Actor, T as ToolSpec, a as ToolHandler, b as ToolPresentation } from '../tool-C128TFWw.js';
 
 /**
  * One node of a composed UI: a catalog component, its props, and — for components declared with

package/dist/guardrails/index.d.cts

@@ -1,5 +1,5 @@
-import { I as InputProcessor, O as OutputProcessor } from '../processors-DvZDW5zS.cjs';
-import { A as Actor, a as ToolHandler } from '../tool-CMTuoJ2v.cjs';
+import { I as InputProcessor, O as OutputProcessor } from '../processors-Bm2DniQ8.cjs';
+import { A as Actor, a as ToolHandler } from '../tool-C128TFWw.cjs';
 import '@standard-schema/spec';
 
 /**

package/dist/guardrails/index.d.ts

@@ -1,5 +1,5 @@
-import { I as InputProcessor, O as OutputProcessor } from '../processors-C1jir8eB.js';
-import { A as Actor, a as ToolHandler } from '../tool-CMTuoJ2v.js';
+import { I as InputProcessor, O as OutputProcessor } from '../processors-CtrfAA0B.js';
+import { A as Actor, a as ToolHandler } from '../tool-C128TFWw.js';
 import '@standard-schema/spec';
 
 /**

package/dist/index.cjs

@@ -76,6 +76,11 @@ __export(src_exports, {
   REMEMBER_TOOL_DESCRIPTION: () => REMEMBER_TOOL_DESCRIPTION,
   REMEMBER_TOOL_NAME: () => REMEMBER_TOOL_NAME,
   REQUESTER_APPROVER: () => REQUESTER_APPROVER,
+  RUN_ENDED_BEFORE_TOOL_CALL: () => RUN_ENDED_BEFORE_TOOL_CALL,
+  RUN_FAILED_MESSAGE: () => RUN_FAILED_MESSAGE,
+  RUN_NOT_ACTIVE_CODE: () => RUN_NOT_ACTIVE_CODE,
+  RUN_NOT_ACTIVE_MESSAGE: () => RUN_NOT_ACTIVE_MESSAGE,
+  RUN_NO_LONGER_RUNNING: () => RUN_NO_LONGER_RUNNING,
   RunCancelledError: () => RunCancelledError,
   SKILL_TOOL_DESCRIPTION: () => SKILL_TOOL_DESCRIPTION,
   SKILL_TOOL_NAME: () => SKILL_TOOL_NAME,
@@ -86,6 +91,7 @@ __export(src_exports, {
   ToolInputInvalidError: () => ToolInputInvalidError,
   ToolNotFoundError: () => ToolNotFoundError,
   ToolRegistry: () => ToolRegistry,
+  UNFINISHED_TOOL_CALL: () => UNFINISHED_TOOL_CALL,
   actorScope: () => actorScope,
   agentDiagnosticKey: () => agentDiagnosticKey,
   agentFailureCode: () => agentFailureCode,
@@ -103,6 +109,7 @@ __export(src_exports, {
   createIncrementalGate: () => createIncrementalGate,
   createNoopEmitUi: () => createNoopEmitUi,
   createUiCollector: () => createUiCollector,
+  danglingToolCallIds: () => danglingToolCallIds,
   dayBoundsUtc: () => dayBoundsUtc,
   decodeStreamEvent: () => decodeStreamEvent,
   defaultCanDecide: () => defaultCanDecide,
@@ -114,6 +121,7 @@ __export(src_exports, {
   estimateCost: () => estimateCost,
   estimateMessageTokens: () => estimateMessageTokens,
   exhaustedWindow: () => exhaustedWindow,
+  exposeStreamErrorDetails: () => exposeStreamErrorDetails,
   extractJson: () => extractJson,
   filterToolsByAllowList: () => filterToolsByAllowList,
   filterToolsByCanUse: () => filterToolsByCanUse,
@@ -176,6 +184,8 @@ __export(src_exports, {
   runOutputProcessors: () => runOutputProcessors,
   seedModelPrices: () => seedModelPrices,
   settleAll: () => settleAll,
+  settleDanglingToolCalls: () => settleDanglingToolCalls,
+  settleDeadRun: () => settleDeadRun,
   settleElicitation: () => settleElicitation,
   settleUnsettledDelegation: () => settleUnsettledDelegation,
   skillInputSchema: () => skillInputSchema,
@@ -184,9 +194,11 @@ __export(src_exports, {
   stampToolKinds: () => stampToolKinds,
   staticModelCatalog: () => staticModelCatalog,
   staticSkillProvider: () => staticSkillProvider,
+  streamFailure: () => streamFailure,
   summarizeWithModel: () => summarizeWithModel,
   tenantScope: () => tenantScope,
   toolCallApprovalFromRow: () => toolCallApprovalFromRow,
+  toolCallContext: () => toolCallContext,
   traceLlmTurn: () => traceLlmTurn,
   traceToolExecution: () => traceToolExecution,
   truncateDetailContent: () => truncateDetailContent,
@@ -2553,6 +2565,123 @@ function isControlFlowSignal(error) {
 }
 __name(isControlFlowSignal, "isControlFlowSignal");
 
+// src/dangling-tool-calls.ts
+var UNFINISHED_TOOL_CALL = "This tool call was never completed: the turn it belonged to ended unexpectedly before it was settled. Do not assume it ran, and do not assume it did not \u2014 check the current state with a read tool if one exists, tell the person plainly what is and is not confirmed, and do it again only if they still want it.";
+var RUN_ENDED_BEFORE_TOOL_CALL = "the run ended before this tool call was settled";
+var DECLINED = "The person was asked to approve this action and declined it. Nothing ran and nothing changed.";
+var EXPIRED = "This action needed approval, and the request expired before anyone decided. Nothing ran.";
+function danglingToolCallIds(messages) {
+  const ids = [];
+  for (const message of messages) {
+    const calls = message.toolCalls ?? [];
+    if (message.role !== "assistant" || calls.length === 0) {
+      continue;
+    }
+    const settled = new Set((message.toolResults ?? []).map((result) => result.id));
+    for (const call of calls) {
+      if (!settled.has(call.id)) {
+        ids.push(call.id);
+      }
+    }
+  }
+  return ids;
+}
+__name(danglingToolCallIds, "danglingToolCallIds");
+function resultFor(call, outcome) {
+  const base = {
+    id: call.id,
+    name: call.name
+  };
+  switch (outcome?.status) {
+    case "executed":
+    case "auto_executed":
+      return {
+        ...base,
+        output: outcome.output ?? null
+      };
+    case "failed":
+      return {
+        ...base,
+        output: null,
+        error: outcome.error ?? UNFINISHED_TOOL_CALL
+      };
+    case "rejected":
+      return {
+        ...base,
+        output: {
+          rejected: true
+        },
+        denied: true,
+        error: DECLINED
+      };
+    case "expired":
+      return {
+        ...base,
+        output: {
+          rejected: true,
+          expired: true
+        },
+        denied: true,
+        expired: true,
+        error: EXPIRED
+      };
+    default:
+      return {
+        ...base,
+        output: null,
+        error: UNFINISHED_TOOL_CALL
+      };
+  }
+}
+__name(resultFor, "resultFor");
+function settleDanglingToolCalls(messages, outcomes = []) {
+  const known = new Map(outcomes.map((outcome) => [
+    outcome.id,
+    outcome
+  ]));
+  return messages.map((message) => {
+    const calls = message.toolCalls ?? [];
+    if (message.role !== "assistant" || calls.length === 0) {
+      return message;
+    }
+    const results = message.toolResults ?? [];
+    const settled = new Set(results.map((result) => result.id));
+    const missing = calls.filter((call) => !settled.has(call.id));
+    if (missing.length === 0) {
+      return message;
+    }
+    return {
+      ...message,
+      toolResults: [
+        ...results,
+        ...missing.map((call) => resultFor(call, known.get(call.id)))
+      ]
+    };
+  });
+}
+__name(settleDanglingToolCalls, "settleDanglingToolCalls");
+
+// src/dead-run.ts
+var RUN_NOT_ACTIVE_CODE = "run_not_active";
+var RUN_NOT_ACTIVE_MESSAGE = "This request is no longer waiting for an answer: the turn it belonged to has ended. Send the message again.";
+var RUN_NO_LONGER_RUNNING = "the run is no longer running";
+async function settleDeadRun(store, input) {
+  const failure = input.failure;
+  if (failure !== void 0) {
+    await Promise.resolve(store.recordRunEnd?.({
+      runId: input.runId,
+      status: "failed",
+      errorCode: failure.code,
+      errorMessage: failure.message
+    })).catch(() => void 0);
+  }
+  await Promise.resolve(store.failUnsettledToolCalls?.(input.runId, RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+  if (input.threadId !== void 0) {
+    await releaseThreadRun(store, input.threadId, input.runId).catch(() => void 0);
+  }
+}
+__name(settleDeadRun, "settleDeadRun");
+
 // src/delegation.ts
 function normalizeDelegation(entry) {
   return typeof entry === "string" ? {
@@ -3017,9 +3146,46 @@ function agentFailureCode(error) {
   if (error instanceof StructuredOutputError) {
     return "structured_output_invalid";
   }
-  return "run_failed";
+  if (isReplayIntegrityError(error)) {
+    return "replay_diverged";
+  }
+  return isNoOutputError(error) ? "model_no_output" : "run_failed";
 }
 __name(agentFailureCode, "agentFailureCode");
+function isNoOutputError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.name === "AI_NoOutputGeneratedError" || error.name === "NoOutputGeneratedError" || error.message.startsWith("No output generated");
+}
+__name(isNoOutputError, "isNoOutputError");
+var RUN_FAILED_MESSAGE = "The assistant could not finish this answer. Please try again.";
+var streamErrorDetails;
+function exposeStreamErrorDetails(expose) {
+  streamErrorDetails = expose;
+}
+__name(exposeStreamErrorDetails, "exposeStreamErrorDetails");
+var WORDED_CODES = /* @__PURE__ */ new Set([
+  "quota_exceeded",
+  "output_rejected",
+  "structured_output_invalid"
+]);
+function streamFailure(error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  const code = agentFailureCode(error);
+  if (WORDED_CODES.has(code)) {
+    return {
+      code,
+      message: detail
+    };
+  }
+  const exposed = streamErrorDetails ?? process.env.NODE_ENV !== "production";
+  return {
+    code,
+    message: exposed ? detail : RUN_FAILED_MESSAGE
+  };
+}
+__name(streamFailure, "streamFailure");
 var MAX_DELEGATION_DEPTH = 5;
 var DEFAULT_MAX_AGENT_APPEARANCES = 1;
 function delegationRefusal(args) {
@@ -3211,9 +3377,9 @@ function splitHistory(policy, input, messages) {
 }
 __name(splitHistory, "splitHistory");
 async function loadSelectedHistory(deps, input, hooks) {
-  return hooks.step("load:thread", async () => {
+  const recorded = await hooks.step("load:thread", async () => {
     const thread = await readThreadForTurn(deps, input.threadId);
-    const { keep, drop } = splitHistory(deps.historyPolicy, input, toModelMessages(thread.messages));
+    const { keep, drop } = splitHistory(deps.historyPolicy, input, await settleHistory(deps, toModelMessages(thread.messages)));
     return {
       messages: keep,
       dropped: deps.historyPolicy?.summarize === void 0 ? [] : drop,
@@ -3221,8 +3387,21 @@ async function loadSelectedHistory(deps, input, hooks) {
       hasAssistantMessage: thread.hasAssistantMessage
     };
   });
+  return {
+    ...recorded,
+    messages: settleDanglingToolCalls(recorded.messages)
+  };
 }
 __name(loadSelectedHistory, "loadSelectedHistory");
+async function settleHistory(deps, messages) {
+  const dangling = danglingToolCallIds(messages);
+  if (dangling.length === 0) {
+    return messages;
+  }
+  const outcomes = await Promise.resolve(deps.store.toolCallOutcomes?.(dangling) ?? []).catch(() => []);
+  return settleDanglingToolCalls(messages, outcomes);
+}
+__name(settleHistory, "settleHistory");
 async function readThreadForTurn(deps, threadId) {
   const windowing = deps.store;
   if (typeof windowing.loadThreadForTurn === "function") {
@@ -3262,7 +3441,7 @@ __name(turnMessageLimit, "turnMessageLimit");
 async function loadWholeThread(deps, input, hooks) {
   const thread = await hooks.step("load:thread", () => deps.store.getThread(input.threadId));
   const stored = thread?.messages ?? [];
-  const { keep, drop } = splitHistory(deps.historyPolicy, input, toModelMessages(stored));
+  const { keep, drop } = splitHistory(deps.historyPolicy, input, settleDanglingToolCalls(toModelMessages(stored)));
   return {
     messages: keep,
     dropped: drop,
@@ -3445,6 +3624,14 @@ async function awaitElicitation(hooks, request, ctx) {
   }, ctx));
 }
 __name(awaitElicitation, "awaitElicitation");
+function toolCallContext(ctx, toolCallId) {
+  return {
+    ...ctx,
+    toolCallId,
+    idempotencyKey: `${ctx.runId}:${toolCallId}`
+  };
+}
+__name(toolCallContext, "toolCallContext");
 function toolContext(deps, input, hooks) {
   return {
     actor: input.actor,
@@ -3884,7 +4071,7 @@ async function invokeClaimedTool(turn, claimed) {
         }, () => invokeWithTransientRetry(() => {
           ui2.restart();
           return deps.registry.invoke(call.name, call.input, {
-            ...ctx,
+            ...toolCallContext(ctx, call.id),
             emitUi: ui2.emit
           }, deps.rolesPolicy);
         }, deps.toolTransientRetry ?? {}, {
@@ -5482,6 +5669,36 @@ var InMemoryAgentStore = class {
       } : {}
     });
   }
+  async toolCallOutcomes(toolCallIds) {
+    const outcomes = [];
+    for (const id of toolCallIds) {
+      const row = this.toolCalls.get(id);
+      if (row !== void 0) {
+        outcomes.push({
+          id,
+          status: row.status,
+          ...row.output !== void 0 ? {
+            output: row.output
+          } : {},
+          ...row.error !== void 0 ? {
+            error: row.error
+          } : {}
+        });
+      }
+    }
+    return outcomes;
+  }
+  async failUnsettledToolCalls(runId, error) {
+    let settled = 0;
+    for (const row of this.toolCalls.values()) {
+      if (row.runId === runId && row.status === "pending_approval") {
+        row.status = "failed";
+        row.error = error;
+        settled += 1;
+      }
+    }
+    return settled;
+  }
   async updateToolCall(input) {
     const row = this.toolCalls.get(input.toolCallId);
     if (row === void 0) {
@@ -5809,6 +6026,11 @@ var InMemoryAgentStore = class {
   REMEMBER_TOOL_DESCRIPTION,
   REMEMBER_TOOL_NAME,
   REQUESTER_APPROVER,
+  RUN_ENDED_BEFORE_TOOL_CALL,
+  RUN_FAILED_MESSAGE,
+  RUN_NOT_ACTIVE_CODE,
+  RUN_NOT_ACTIVE_MESSAGE,
+  RUN_NO_LONGER_RUNNING,
   RunCancelledError,
   SKILL_TOOL_DESCRIPTION,
   SKILL_TOOL_NAME,
@@ -5819,6 +6041,7 @@ var InMemoryAgentStore = class {
   ToolInputInvalidError,
   ToolNotFoundError,
   ToolRegistry,
+  UNFINISHED_TOOL_CALL,
   actorScope,
   agentDiagnosticKey,
   agentFailureCode,
@@ -5836,6 +6059,7 @@ var InMemoryAgentStore = class {
   createIncrementalGate,
   createNoopEmitUi,
   createUiCollector,
+  danglingToolCallIds,
   dayBoundsUtc,
   decodeStreamEvent,
   defaultCanDecide,
@@ -5847,6 +6071,7 @@ var InMemoryAgentStore = class {
   estimateCost,
   estimateMessageTokens,
   exhaustedWindow,
+  exposeStreamErrorDetails,
   extractJson,
   filterToolsByAllowList,
   filterToolsByCanUse,
@@ -5909,6 +6134,8 @@ var InMemoryAgentStore = class {
   runOutputProcessors,
   seedModelPrices,
   settleAll,
+  settleDanglingToolCalls,
+  settleDeadRun,
   settleElicitation,
   settleUnsettledDelegation,
   skillInputSchema,
@@ -5917,9 +6144,11 @@ var InMemoryAgentStore = class {
   stampToolKinds,
   staticModelCatalog,
   staticSkillProvider,
+  streamFailure,
   summarizeWithModel,
   tenantScope,
   toolCallApprovalFromRow,
+  toolCallContext,
   traceLlmTurn,
   traceToolExecution,
   truncateDetailContent,