@opengeni/runtime 4.3.0-canary.36855269964001 → 4.3.0

package/src/lazy-tool-transport.ts

@@ -12,11 +12,7 @@ import {
 } from "@openai/agents";
 import { isSearchableMcpFunctionTool, searchToolPool } from "./codex-tool-search";
 import { MCP_MAX_TOOL_SEARCH_DISCLOSURE_BYTES } from "./mcp-network";
-import {
-  beforeModelRequest,
-  modelResponseSettlement,
-  notifyModelRequestCapture,
-} from "./model-request-capture";
+import { notifyModelRequestCapture } from "./model-request-capture";
 
 /** Provider-contained progressive-disclosure strategy for one resolved turn. */
 export type LazyToolTransport = "codex_native" | "openai_native" | "generic_dispatch";
@@ -833,7 +829,6 @@ class LazyToolModel implements Model {
   ) {}
 
   async getResponse(request: ModelRequest): Promise<ModelResponse> {
-    await beforeModelRequest();
     const prepared = prepareLazyToolRequest(request, this.runtime);
     rememberPreparedModelRequest(prepared);
     void notifyModelRequestCapture(prepared);
@@ -847,7 +842,6 @@ class LazyToolModel implements Model {
   }
 
   async *getStreamedResponse(request: ModelRequest): AsyncIterable<StreamEvent> {
-    await beforeModelRequest();
     const prepared = prepareLazyToolRequest(request, this.runtime);
     rememberPreparedModelRequest(prepared);
     void notifyModelRequestCapture(prepared);
@@ -857,21 +851,19 @@ class LazyToolModel implements Model {
           await this.runtime.ensurePrepared();
         }
       }
-      const delivered =
-        this.runtime.transport === "generic_dispatch" && event.type === "response_done"
-          ? ({
-              ...event,
-              response: {
-                ...event.response,
-                output: event.response.output.flatMap((item) =>
-                  transformGenericDispatchCall(item, this.runtime),
-                ) as typeof event.response.output,
-              },
-            } as StreamEvent)
-          : event;
-      const settlement = modelResponseSettlement(delivered);
-      void settlement?.catch(() => undefined);
-      yield delivered;
+      if (this.runtime.transport === "generic_dispatch" && event.type === "response_done") {
+        yield {
+          ...event,
+          response: {
+            ...event.response,
+            output: event.response.output.flatMap((item) =>
+              transformGenericDispatchCall(item, this.runtime),
+            ) as typeof event.response.output,
+          },
+        } as StreamEvent;
+      } else {
+        yield event;
+      }
     }
   }
 

package/src/mcp-run-credentials.ts

@@ -1,14 +1,9 @@
 import {
   CredentialProviderMcpMaterial,
   normalizeCredentialProviderMcpUrl,
-  type McpServerConnectionRef,
 } from "@opengeni/contracts";
 
-export type RunMcpCredentialTarget = {
-  id: string;
-  url: string;
-  connectionRef?: McpServerConnectionRef | undefined;
-};
+export type RunMcpCredentialTarget = { id: string; url: string };
 export type RunMcpCredentialMaterial = {
   mcp?: CredentialProviderMcpMaterial;
   expiresAt: Date | null;
@@ -48,9 +43,7 @@ export class RunMcpCredentials {
     targets: readonly RunMcpCredentialTarget[],
     options: { signal?: AbortSignal; now?: () => number } = {},
   ) {
-    this.#targets = targets
-      .filter((target) => !target.connectionRef)
-      .map(({ id, url }) => ({ id, url }));
+    this.#targets = targets.map(({ id, url }) => ({ id, url }));
     this.#signal = options.signal;
     this.#now = options.now ?? Date.now;
     this.#signal?.addEventListener("abort", this.#onAbort, { once: true });
@@ -142,12 +135,11 @@ export class RunMcpCredentials {
     this.prepare(material)();
   }
 
-  /** Refuse credentials for native, omitted, local, or rewritten server routes. */
+  /** Refuse credentials for omitted, local, or rewritten server routes. */
   assertRemoteTargets(targets: readonly RunMcpCredentialTarget[]): void {
     this.#remoteTargets = this.#targets.filter((original) =>
       targets.some(
         (target) =>
-          !target.connectionRef &&
           target.id === original.id &&
           normalizedUrl(target.url) !== null &&
           normalizedUrl(target.url) === normalizedUrl(original.url),
@@ -203,13 +195,6 @@ export class RunMcpCredentials {
     init?: RequestInit,
   ): RequestInit | undefined {
     this.#assertOpen();
-    // Native connection authority and attribution own all authentication on
-    // this route. Even a stale or manually supplied provider grant must never
-    // replace its bearer or inject alternate authentication headers.
-    if (target.connectionRef) {
-      this.excludeLocalTarget(target.id);
-      return init;
-    }
     this.assertAvailable(target.id);
     const entry = this.#entries.get(target.id);
     if (!entry) return init;

package/src/model-preparation-diagnostics.ts

@@ -1,6 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { setTraceProcessors, type Span, type Trace, type TracingProcessor } from "@openai/agents";
-import { beforeModelRequest } from "./model-request-capture";
 
 export type ModelPreparationPhase =
   | "sandbox_agent_preparation"
@@ -65,10 +64,6 @@ type ModelPreparationObservation = {
 
 const modelPreparationObserver = new AsyncLocalStorage<ModelPreparationObservation>();
 const modelTransportStartedObserver = new AsyncLocalStorage<() => Promise<void> | void>();
-type ModelTransportAdmission = { refusal?: { error: unknown } };
-type ModelTransportFetch = (...args: Parameters<typeof fetch>) => ReturnType<typeof fetch>;
-const modelTransportAdmission = new AsyncLocalStorage<ModelTransportAdmission>();
-const modelTransportRefusals = new WeakMap<Headers, { error: unknown }>();
 
 class ModelPreparationTraceProcessor implements TracingProcessor {
   async onTraceStart(_trace: Trace): Promise<void> {}
@@ -132,49 +127,7 @@ export function withModelTransportStartedObserver<T>(
 }
 
 export async function recordModelTransportStarted(): Promise<void> {
-  try {
-    await beforeModelRequest();
-    await modelTransportStartedObserver.getStore()?.();
-  } catch (error) {
-    const admission = modelTransportAdmission.getStore();
-    if (admission) admission.refusal = { error };
-    throw error;
-  }
-}
-
-/** The OpenAI SDK retries thrown fetch errors and replaces their identity with
- * APIConnectionError. Carry only our pre-wire refusal through its HTTP-error
- * path, which honors the retry veto. Native transports keep the original throw.
- * Each fetch owns its context even when concurrent turns share a cached client.
- */
-export function sdkModelTransportAdmissionFetch(inner: ModelTransportFetch): ModelTransportFetch {
-  return async (input, init) => {
-    const admission: ModelTransportAdmission = {};
-    return modelTransportAdmission.run(admission, async () => {
-      try {
-        return await inner(input, init);
-      } catch (error) {
-        if (!admission.refusal || admission.refusal.error !== error) throw error;
-        // This is a local SDK handoff, not a provider or public API response.
-        // Identity, not response bytes/headers supplied by a provider, grants
-        // access to the original error at the SDK's status-error boundary.
-        const response = new Response(null, {
-          status: 400,
-          headers: { "x-should-retry": "false" },
-        });
-        modelTransportRefusals.set(response.headers, admission.refusal);
-        return response;
-      }
-    });
-  };
-}
-
-/** Restore the exact host-owned error after the SDK has suppressed retries. */
-export function rethrowModelTransportAdmissionRefusal(headers: Headers): void {
-  const refusal = modelTransportRefusals.get(headers);
-  if (!refusal) return;
-  modelTransportRefusals.delete(headers);
-  throw refusal.error;
+  await modelTransportStartedObserver.getStore()?.();
 }
 
 /** Record the first routed sandbox operation boundary without publishing an

package/src/model-provider-client.ts

@@ -29,10 +29,7 @@ import { ReplayableJsonOpenAI } from "./replayable-json-body";
 import { recordModelTransportStarted } from "./model-preparation-diagnostics";
 import { captureProviderRequestBody } from "./model-request-capture";
 import { withoutQuotaExhaustedRetries } from "./provider-quota";
-import {
-  observeClaudeUsageResponse,
-  prepareClaudeSubscriptionRequest,
-} from "./claude-subscription-usage";
+import { observeClaudeUsageResponse } from "./claude-subscription-usage";
 
 let runtimeMetricsHooks: RuntimeMetricsHooks | null = null;
 
@@ -403,7 +400,6 @@ export function instrumentedModelFetch(provider: string, inner: typeof fetch): t
     if (!isModelCallFetch(input)) {
       return await inner(input, init);
     }
-    init = await prepareClaudeSubscriptionRequest(provider, input, init);
     // The attempt-local observer durably checkpoints provider dispatch before
     // this process can place request bytes on the network.
     await recordModelTransportStarted();

package/src/model-provider-routing.ts

@@ -8,7 +8,7 @@ import {
   type ModelRequest,
   type ResponseStreamEvent,
 } from "@openai/agents";
-import OpenAI, { APIError } from "openai";
+import OpenAI from "openai";
 import { AnthropicMessagesModel } from "./anthropic-messages";
 import { instrumentedModelFetch } from "./model-provider-client";
 import { CODEX_MODEL_ID_PREFIX } from "@opengeni/codex";
@@ -16,10 +16,6 @@ import { XAI_SUBSCRIPTION_MODEL_ID_PREFIX } from "@opengeni/xai-subscription";
 
 import { AppendOnlyOpenAIResponsesModel } from "./append-only-responses-model";
 import { recordModelPreparationMeasurement } from "./model-preparation-diagnostics";
-import {
-  ResponsesStreamingTerminalError,
-  responsesStreamingTerminalError,
-} from "./responses-terminal-error";
 import { buildProviderClient } from "./model-provider-client";
 import {
   CodexSubscriptionUnavailableError,
@@ -85,96 +81,6 @@ export class OpenGeniResponsesModel extends AppendOnlyOpenAIResponsesModel {
     super(client, model);
   }
 
-  protected override _fetchResponse(
-    request: ModelRequest,
-    stream: false,
-  ): Promise<OpenAI.Responses.Response>;
-  protected _fetchResponse(
-    request: ModelRequest,
-    stream: true,
-  ): Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>;
-  protected async _fetchResponse(
-    request: ModelRequest,
-    stream: boolean,
-  ): Promise<OpenAI.Responses.Response | AsyncIterable<OpenAI.Responses.ResponseStreamEvent>> {
-    if (!stream || !this.ownsResponsesTerminalClassification()) {
-      // Subscription transports retain the SDK's request-id and error handling.
-      return await super._fetchResponse(request, stream as false);
-    }
-    // Reuse the SDK's full request conversion, but retain its HTTP receipt
-    // before the SDK's stream wrapper discards the response headers.
-    const built = this._buildResponsesCreateRequest(request, true);
-    const internal = (request as ModelRequest & { _internal?: { runnerManagedRetry?: boolean } })
-      ._internal;
-    const pending = this._client.responses.create(
-      built.requestData as OpenAI.Responses.ResponseCreateParamsStreaming,
-      {
-        headers: built.sdkRequestHeaders,
-        signal: built.signal,
-        ...(built.transportExtraQuery ? { query: built.transportExtraQuery } : {}),
-        ...(internal?.runnerManagedRetry === true ? { maxRetries: 0 } : {}),
-      },
-    );
-    if (typeof pending.withResponse !== "function") {
-      // The SDK also permits custom clients returning only the stream promise.
-      // Such clients cannot supply HTTP evidence, but must remain usable.
-      return this.classifiedResponseStream(await pending, new Headers(), null);
-    }
-    const receipt = await pending.withResponse();
-    return this.classifiedResponseStream(
-      receipt.data,
-      receipt.response.headers,
-      receipt.request_id,
-    );
-  }
-
-  private async *classifiedResponseStream(
-    stream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>,
-    headers: Headers,
-    requestId: string | null,
-  ): AsyncIterable<OpenAI.Responses.ResponseStreamEvent> {
-    try {
-      for await (const event of stream) {
-        const failure = responsesStreamingTerminalError(event, headers);
-        if (failure) throw failure;
-        // response.done is supported by the pinned terminal reducer but absent
-        // from the OpenAI wire declaration.
-        const eventType: string = event.type;
-        if (
-          requestId &&
-          (eventType === "response.completed" || eventType === "response.done") &&
-          "response" in event &&
-          event.response &&
-          !("_request_id" in event.response)
-        ) {
-          // Match the SDK's successful-terminal request-id attachment without
-          // making transport metadata enumerable in provider/model data.
-          try {
-            Object.defineProperty(event.response, "_request_id", {
-              value: requestId,
-              enumerable: false,
-            });
-          } catch {
-            // Frozen custom response objects remain usable, as in the SDK.
-          }
-        }
-        yield event;
-      }
-    } catch (error) {
-      // The OpenAI parser can throw a top-level `error` before yielding it.
-      // Convert inside the stream, before the Agents SDK's span error handler,
-      // so even enabled model tracing receives only the structural message.
-      if (error instanceof APIError && error.status === undefined && error.error) {
-        throw new ResponsesStreamingTerminalError("response.error", error.error, headers);
-      }
-      throw error;
-    }
-  }
-
-  private ownsResponsesTerminalClassification(): boolean {
-    return this.provider.kind !== "codex-subscription" && this.provider.kind !== "xai-subscription";
-  }
-
   protected override _buildResponsesCreateRequest(request: ModelRequest, stream: boolean) {
     const startedAt = performance.now();
     let outcome: "completed" | "failed" = "completed";

package/src/model-provider.ts

@@ -10,7 +10,6 @@ import {
 import { buildOpenAIClientFromSettings } from "./model-provider-client";
 import { MultiProviderModelProvider } from "./model-provider-routing";
 
-export { ResponsesStreamingTerminalError } from "./responses-terminal-error";
 export {
   CodexSubscriptionUnavailableError,
   OrganizationGatewayUnavailableError,

package/src/model-request-capture.ts

@@ -14,27 +14,6 @@ export type ModelRequestCapture = ((request: ModelRequest) => void | Promise<voi
 const modelRequestCapture = new AsyncLocalStorage<ModelRequestCapture>();
 const captureIndices = new WeakMap<object, number>();
 
-/** Awaited producer-side authority, separate from observational request capture. */
-export type ModelCallLifecycle = {
-  beforeModelRequest?: () => Promise<void>;
-  /** Register before yielding so the next model entry waits for consumer settlement. */
-  onModelResponse?: (event: StreamEvent) => Promise<void>;
-};
-const modelCallLifecycle = new AsyncLocalStorage<ModelCallLifecycle>();
-
-export function withModelCallLifecycle<T>(lifecycle: ModelCallLifecycle, fn: () => T): T {
-  return modelCallLifecycle.run(lifecycle, fn);
-}
-
-export async function beforeModelRequest(): Promise<void> {
-  await modelCallLifecycle.getStore()?.beforeModelRequest?.();
-}
-
-export function modelResponseSettlement(event: StreamEvent): Promise<void> | undefined {
-  if (event.type !== "response_done") return undefined;
-  return modelCallLifecycle.getStore()?.onModelResponse?.(event);
-}
-
 /** The same agent can re-enter runAgentStream after in-activity compaction. */
 export function nextModelContextCaptureIndex(agent: object): number {
   const index = (captureIndices.get(agent) ?? 0) + 1;
@@ -154,21 +133,15 @@ export class ModelRequestCaptureModel implements Model {
   constructor(private readonly inner: Model) {}
 
   async getResponse(request: ModelRequest) {
-    await beforeModelRequest();
     rememberPreparedModelRequest(request);
     void notifyModelRequestCapture(request);
     return this.inner.getResponse(request);
   }
 
   async *getStreamedResponse(request: ModelRequest): AsyncIterable<StreamEvent> {
-    await beforeModelRequest();
     rememberPreparedModelRequest(request);
     void notifyModelRequestCapture(request);
-    for await (const event of this.inner.getStreamedResponse(request)) {
-      const settlement = modelResponseSettlement(event);
-      void settlement?.catch(() => undefined);
-      yield event;
-    }
+    yield* this.inner.getStreamedResponse(request);
   }
 
   getRetryAdvice(args: Parameters<NonNullable<Model["getRetryAdvice"]>>[0]) {

package/src/provider-history-adapter.ts

@@ -71,24 +71,6 @@ function isChatIncompatibleHostedToolCall(item: Record<string, unknown>): boolea
   return item.type === "hosted_tool_call" && item.name !== "file_search_call";
 }
 
-/** The Chat SDK passes system content through instead of converting Responses
- * text parts. Normalize only text-only content; preserve canonical input.
- */
-function chatSystemContent(content: unknown): unknown {
-  if (
-    !Array.isArray(content) ||
-    !content.every(
-      (part) =>
-        part !== null &&
-        typeof part === "object" &&
-        (part.type === "input_text" || part.type === "output_text" || part.type === "text") &&
-        typeof part.text === "string",
-    )
-  )
-    return content;
-  return content.map((part) => part.text).join("\n");
-}
-
 /**
  * Build the one attempt-local history view required by the target wire API.
  * Canonical history remains untouched. SDK-unsupported developer messages use
@@ -132,12 +114,9 @@ export function projectHistoryForProvider(
 
   let changed = false;
   const projected = items.map((item) => {
-    if (item.type === "message" && (item.role === "developer" || item.role === "system")) {
-      const content = chatSystemContent(item.content);
-      if (item.role === "developer" || content !== item.content) {
-        changed = true;
-        return { ...item, role: "system", content };
-      }
+    if (item.type === "message" && item.role === "developer") {
+      changed = true;
+      return { ...item, role: "system" };
     }
     const resultId = item.type === "function_call_result" ? callId(item) : null;
     if (

package/src/replayable-json-body.ts

@@ -1,10 +1,6 @@
-import OpenAI, { type APIError } from "openai";
+import OpenAI from "openai";
 import type { APIPromise } from "openai/core/api-promise";
 import { types as utilTypes } from "node:util";
-import {
-  rethrowModelTransportAdmissionRefusal,
-  sdkModelTransportAdmissionFetch,
-} from "./model-preparation-diagnostics";
 
 const TARGET_CHUNK_CHARS = 64 * 1024;
 const LARGE_STRING_SOURCE_CHARS = 32 * 1024;
@@ -103,23 +99,10 @@ export class ReplayableJsonOpenAI extends OpenAI {
   private readonly modelRequestPolicy: ModelJsonRequestPolicy | undefined;
 
   constructor(options: OpenAIOptions, hooks: ReplayableJsonOpenAIHooks = {}) {
-    super({
-      ...options,
-      fetch: sdkModelTransportAdmissionFetch(options?.fetch ?? globalThis.fetch),
-    });
+    super(options);
     this.modelRequestPolicy = hooks.modelRequestPolicy;
   }
 
-  protected override makeStatusError(
-    status: number,
-    error: NonNullable<Parameters<typeof APIError.generate>[1]>,
-    message: string | undefined,
-    headers: Headers,
-  ): APIError {
-    rethrowModelTransportAdmissionRefusal(headers);
-    return super.makeStatusError(status, error, message, headers);
-  }
-
   override post<Rsp>(path: string, opts?: OpenAIPostOptions): APIPromise<Rsp> {
     if (!isModelRequestPath(path) || opts === undefined) {
       return super.post<Rsp>(path, opts);

package/src/sandbox/index.ts

@@ -592,7 +592,6 @@ export {
   isRoutingMutationOutcomeUnknownError,
   RoutingBackendRecoveryRequiredError,
   RoutingMutationOutcomeUnknownError,
-  renderRoutingMutationOutcomeUnknownToolResult,
   RoutingRetainedProcessNotFoundError,
   RoutingSandboxSession,
   RoutingWorkspaceRootChangedError,

package/src/sandbox/provider-command-session.ts

@@ -42,18 +42,6 @@ export class ProviderCommandStartRejectedError extends Error {
   }
 }
 
-/** Start was attempted exactly once, but its acknowledgement is unavailable.
- * The client-chosen locator is reconciliation authority, never replay authority. */
-export class ProviderCommandStartOutcomeUnknownError extends Error {
-  constructor(
-    readonly command: ModalRouterProviderCommand,
-    cause: unknown,
-  ) {
-    super("Provider command Start outcome is unknown; the invocation was not replayed", { cause });
-    this.name = "ProviderCommandStartOutcomeUnknownError";
-  }
-}
-
 export type ProviderCommandSession = {
   verifyCommandSupervisionCapability?(): Promise<{ sandboxId: string; taskId: string }>;
   releaseSupervisedCommand?(handle: number): Promise<void>;

package/src/sandbox/providers/modal-command-control.ts

@@ -12,7 +12,6 @@ import {
   admittedCommandSupervisionReady,
   markPendingCommandSupervised,
   reserveSupervisedLaunch,
-  ProviderCommandStartOutcomeUnknownError,
 } from "../provider-command-session";
 import {
   ModalCommandControl as LegacyControl,
@@ -23,7 +22,6 @@ import {
   ModalCommandRouterWire,
   ModalCommandStartPreDispatchUnavailableError,
   ModalCommandStartRejectedError,
-  ModalCommandStartNotDispatchedError,
 } from "./modal-command-router-wire";
 
 export { modalCommandAbortMiddleware } from "./modal-legacy-command-control";
@@ -210,11 +208,9 @@ export class ModalCommandControl {
       },
     };
     if (supervision) await reserveSupervisedLaunch(command);
-    let startAttempted = false;
     try {
-      await this.withRouter(taskId, signal, async (router) => {
-        startAttempted = true;
-        await router.start(
+      await this.withRouter(taskId, signal, (router) =>
+        router.start(
           {
             taskId,
             execId,
@@ -235,20 +231,18 @@ export class ModalCommandControl {
               : {}),
           },
           signal,
-        );
-      });
+        ),
+      );
     } catch (error) {
-      // A client-chosen router id remains the only possible invocation. Retain
-      // it even for PTY/runAs/unsupervised starts: a rejected acknowledgement
-      // does not prove that the provider rejected the launch.
+      // A client-chosen router id remains the only possible invocation. The
+      // supervisor is idle, so an ambiguous launch never ran user code. Retain
+      // the descriptor and reconcile that id; do not replay the start.
       if (
-        !startAttempted ||
-        error instanceof ModalCommandStartNotDispatchedError ||
+        !supervision ||
         error instanceof ModalCommandStartRejectedError ||
         error instanceof ModalCommandStartPreDispatchUnavailableError
       )
         throw error;
-      throw new ProviderCommandStartOutcomeUnknownError(command, error);
     }
     return command;
   }

package/src/sandbox/providers/modal-command-router-wire.ts

@@ -81,17 +81,6 @@ export class ModalCommandStartPreDispatchUnavailableError extends Error {
   }
 }
 
-/** Local cancellation/closure before Start dispatch. This permits exact
- * never-started reservation settlement, NOT another launch or turn recovery. */
-export class ModalCommandStartNotDispatchedError extends Error {
-  constructor(cause: unknown) {
-    super(cause instanceof Error ? cause.message : "Modal command Start was never dispatched", {
-      cause,
-    });
-    this.name = "ModalCommandStartNotDispatchedError";
-  }
-}
-
 export type ModalRouterIdentity = { taskId: string; execId: string };
 export type ModalRouterAccess = { url: string; jwt: string };
 export type ModalRouterStart = ModalRouterIdentity & {
@@ -181,18 +170,12 @@ export class ModalCommandRouterWire {
   }
 
   async start(request: ModalRouterStart, signal?: AbortSignal): Promise<void> {
+    if (this.closed) throw new Error("Modal command router is closed");
     try {
-      if (this.closed) throw new Error("Modal command router is closed");
       await ModalCommandStartPreDispatchUnavailableError.ensureReady(this.client, signal);
-      signal?.throwIfAborted();
-      if (this.closed) throw new Error("Modal command router is closed");
     } catch (error) {
-      if (this.closed)
-        throw new ModalCommandStartNotDispatchedError(
-          new Error("Modal command router is closed", { cause: error }),
-        );
-      if (error instanceof ModalCommandStartPreDispatchUnavailableError) throw error;
-      throw new ModalCommandStartNotDispatchedError(error);
+      if (this.closed) throw new Error("Modal command router is closed", { cause: error });
+      throw error;
     }
     try {
       await this.unary(

package/src/sandbox/providers/modal-command-session.ts

@@ -10,7 +10,6 @@ import {
   type ProviderCommandPersistence,
   type ProviderCommandSession,
   admittedProviderCommandHandle,
-  ProviderCommandStartOutcomeUnknownError,
 } from "../provider-command-session";
 import type { ModalCommandControl, ModalProviderCommand } from "./modal-command-control";
 import { verifyModalMaterializedPath } from "./modal-materialization-verification";
@@ -247,16 +246,6 @@ export function installModalCommandSession(
           exitCode: null,
         });
       }
-    } catch (error) {
-      if (error instanceof ProviderCommandStartOutcomeUnknownError) {
-        const entry = entries.get(handle);
-        if (entry && !sameExecution(entry.command, error.command))
-          throw new Error("Reserved Modal command changed during failed dispatch", {
-            cause: error,
-          });
-        entries.set(handle, entry ?? { command: error.command });
-      }
-      throw error;
     } finally {
       pendingStarts.delete(cancellation);
     }

package/src/sandbox/providers/modal.ts

@@ -15,10 +15,7 @@ import { CAPABILITY_DESCRIPTORS } from "../capabilities";
 import { SandboxChannelAService, type ChannelASession } from "../channel-a";
 import { installModalCommandSession } from "./modal-command-session";
 import { ModalCommandControl } from "./modal-command-control";
-import {
-  ModalCommandStartPreDispatchUnavailableError,
-  ModalCommandStartNotDispatchedError,
-} from "./modal-command-router-wire";
+import { ModalCommandStartPreDispatchUnavailableError } from "./modal-command-router-wire";
 import { createModalSessionWithLifecycle, type ModalCreateLifecycle } from "./modal-create-session";
 import { isRoutingMutationOutcomeUnknownError } from "../routing/routing-session";
 import type { ModalClient } from "modal";
@@ -266,7 +263,6 @@ export function isModalTaskExecStartPreDispatchUnavailableError(error: unknown):
     try {
       const record = current.value as Record<string, unknown>;
       if (isRoutingMutationOutcomeUnknownError(current.value)) return false;
-      if (current.value instanceof ModalCommandStartNotDispatchedError) return false;
       if (hasContradictoryModalHttpStatus(record)) return false;
 
       // This instance is created only by the client's readiness gate before