@opengeni/runtime 4.3.0-canary.36844267522001 → 4.3.0

package/dist/claude-subscription-usage.d.ts

@@ -1,7 +1,5 @@
 type Observer = (providerId: string, response: Response) => void;
-type Prepare = (providerId: string, headers: Headers) => Promise<Headers>;
 /** Like Codex usage headers: free observations within this turn's provider context. */
-export declare function withClaudeUsageObserver<T>(observer: Observer, run: () => Promise<T>, prepare?: Prepare): Promise<T>;
-export declare function prepareClaudeSubscriptionRequest(providerId: string, input: Parameters<typeof fetch>[0], init?: RequestInit): Promise<RequestInit | undefined>;
+export declare function withClaudeUsageObserver<T>(observer: Observer, run: () => Promise<T>): Promise<T>;
 export declare function observeClaudeUsageResponse(providerId: string, response: Response): void;
 export {};

package/dist/index.d.ts

@@ -35,8 +35,6 @@ import { type WorkspaceSkillSearchPath } from "./workspace-skills.js";
 import { type EffectiveSkillSelection, type RuntimeSkillActivation, type RuntimeSkillIndexEntry } from "./runtime-skills.js";
 export { composeRuntimeSkills, loadNativeToolSkillArtifacts, readRuntimeSkill, skillCatalogFromComposition, type EffectiveSkillSelection, type InstalledSkillActivation, type NativeToolSkillSet, type RuntimeSkillActivation, type RuntimeSkillArtifact, type RuntimeSkillArtifactFile, type RuntimeSkillComposition, type RuntimeSkillDescriptor, type RuntimeSkillIndexEntry, type SessionSkillActivation, } from "./runtime-skills.js";
 import { type PersistentAgentInstructionInspection } from "./model-context-inspector.js";
-import { type ModelCallLifecycle } from "./model-request-capture.js";
-export { beforeModelRequest as awaitModelCallAdmission } from "./model-request-capture.js";
 import { type ModelPreparationMeasurement } from "./model-preparation-diagnostics.js";
 import type { ModelResponseUsage, NormalizedRuntimeEvent, SerializedHumanInputInterruption, SerializedInteractionInterventionInterruption } from "./run-events.js";
 export { buildPortableSkillArtifact, getSkillLibraryEntry, isSkillLibraryEntryId, listSkillLibraryEntries, loadSkillLibrarySkill, PORTABLE_SKILL_MAX_FILE_BYTES, PORTABLE_SKILL_MAX_FILES, PORTABLE_SKILL_MAX_TOTAL_BYTES, parsePortableSkillFrontmatter, skillLibraryRepositoryUrl, skillArtifactContentSha256, type PortableSkillArtifact, type SkillLibraryEntry, type SkillLibraryFile, type SkillLibrarySkill, } from "./skill-library.js";
@@ -1041,10 +1039,6 @@ export declare function restoreInterruptedRunState(agent: Agent<any, any>, seria
 export declare const TURN_OPERATIONAL_NOTICE_PREFIX = "[OpenGeni turn-scoped operational notice]\n";
 export declare function prepareRunInput(agent: Agent<any, any>, input: AgentSegmentInput, options?: PrepareInputOptions): Promise<PreparedAgentInput>;
 export type RunAgentStreamOptions = {
-    /** Producer-side gate before calling any resolved model/provider. */
-    beforeModelRequest?: ModelCallLifecycle["beforeModelRequest"];
-    /** Register terminal response settlement before the next producer model request. */
-    onModelResponse?: ModelCallLifecycle["onModelResponse"];
     /** Abort the provider/tool loop when the owning activity is cancelled. */
     signal?: AbortSignal;
     /** Nonblocking phase measurements for request preparation before provider I/O. */

package/dist/index.js

@@ -87,7 +87,6 @@ import {
   attemptToolCallMeta,
   azureCliLoginCommand,
   azureOpenAIDefaultQuery,
-  beforeModelRequest,
   boundModelToolOutputsFilterForSettings,
   buildAgentCapabilities,
   buildCompactionPromptInput,
@@ -284,7 +283,7 @@ import {
   workspaceEnvironmentInstructions,
   wrapAttemptToolDefinitions,
   wrapAttemptToolExecute
-} from "./chunk-XFDVXBB7.js";
+} from "./chunk-22M75RJF.js";
 import {
   ActiveBackendUnresolvableError,
   BROWSER_CONTROL_ADMIN_TOKEN_FILE,
@@ -791,7 +790,6 @@ export {
   assertProviderRegistryInvariants,
   assertSafeRelPath,
   attemptToolCallMeta,
-  beforeModelRequest as awaitModelCallAdmission,
   azureCliLoginCommand,
   azureOpenAIDefaultQuery,
   backendSupportsOs,

package/dist/mcp-run-credentials.d.ts

@@ -1,8 +1,7 @@
-import { CredentialProviderMcpMaterial, type McpServerConnectionRef } from "@opengeni/contracts";
+import { CredentialProviderMcpMaterial } from "@opengeni/contracts";
 export type RunMcpCredentialTarget = {
     id: string;
     url: string;
-    connectionRef?: McpServerConnectionRef | undefined;
 };
 export type RunMcpCredentialMaterial = {
     mcp?: CredentialProviderMcpMaterial;
@@ -27,7 +26,7 @@ export declare class RunMcpCredentials {
     /** Validate a complete replacement before changing any live request headers. */
     prepare(material: RunMcpCredentialMaterial | null): () => void;
     replace(material: RunMcpCredentialMaterial | null): void;
-    /** Refuse credentials for native, omitted, local, or rewritten server routes. */
+    /** Refuse credentials for omitted, local, or rewritten server routes. */
     assertRemoteTargets(targets: readonly RunMcpCredentialTarget[]): void;
     excludeLocalTarget(id: string): void;
     has(id: string): boolean;

package/dist/model-preparation-diagnostics.d.ts

@@ -6,21 +6,12 @@ export type ModelPreparationMeasurement = {
     count?: number;
 };
 type ModelPreparationObserver = (measurement: ModelPreparationMeasurement) => void;
-type ModelTransportFetch = (...args: Parameters<typeof fetch>) => ReturnType<typeof fetch>;
 export declare function withModelPreparationObserver<T>(observer: ModelPreparationObserver | undefined, callback: () => T): T;
 /** Bind one attempt-local durable checkpoint immediately before generic model
  * transport enters fetch. Cached provider clients are process-global, so this
  * authority must be async-local rather than stored on the client instance. */
 export declare function withModelTransportStartedObserver<T>(observer: (() => Promise<void> | void) | undefined, callback: () => T): T;
 export declare function recordModelTransportStarted(): Promise<void>;
-/** 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 declare function sdkModelTransportAdmissionFetch(inner: ModelTransportFetch): ModelTransportFetch;
-/** Restore the exact host-owned error after the SDK has suppressed retries. */
-export declare function rethrowModelTransportAdmissionRefusal(headers: Headers): void;
 /** Record the first routed sandbox operation boundary without publishing an
  * overlapping parent duration. The observer receives only exclusive leaf
  * buckets; this boundary exists solely to split the surrounding SDK work. */

package/dist/model-request-capture.d.ts

@@ -3,15 +3,6 @@ export type ModelRequestCapture = ((request: ModelRequest) => void | Promise<voi
     nextProviderRequestIndex?: () => number;
     onProviderRequest?: (provider: string, body: string | null, reason?: string, index?: number) => void | Promise<void>;
 };
-/** 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>;
-};
-export declare function withModelCallLifecycle<T>(lifecycle: ModelCallLifecycle, fn: () => T): T;
-export declare function beforeModelRequest(): Promise<void>;
-export declare function modelResponseSettlement(event: StreamEvent): Promise<void> | undefined;
 /** The same agent can re-enter runAgentStream after in-activity compaction. */
 export declare function nextModelContextCaptureIndex(agent: object): number;
 export declare function withModelRequestCapture<T>(capture: ModelRequestCapture | undefined, fn: () => T): T;

package/dist/replayable-json-body.d.ts

@@ -1,4 +1,4 @@
-import OpenAI, { type APIError } from "openai";
+import OpenAI from "openai";
 import type { APIPromise } from "openai/core/api-promise";
 /** Internal fetch-init hook used only when a transport performs its own retry. */
 export declare const REPLAYABLE_REQUEST_BODY_FACTORY: unique symbol;
@@ -46,7 +46,6 @@ export declare function requestBodyText(body: BodyInit | null | undefined): Prom
 export declare class ReplayableJsonOpenAI extends OpenAI {
     private readonly modelRequestPolicy;
     constructor(options: OpenAIOptions, hooks?: ReplayableJsonOpenAIHooks);
-    protected makeStatusError(status: number, error: NonNullable<Parameters<typeof APIError.generate>[1]>, message: string | undefined, headers: Headers): APIError;
     post<Rsp>(path: string, opts?: OpenAIPostOptions): APIPromise<Rsp>;
     buildRequest(inputOptions: OpenAIBuildOptions, context?: OpenAIBuildContext): Promise<OpenAIBuildResult>;
 }

package/dist/workspace-tool-gateway.js

@@ -1,6 +1,6 @@
 import {
   prepareAgentTools
-} from "./chunk-XFDVXBB7.js";
+} from "./chunk-22M75RJF.js";
 import "./chunk-JUFVYQCY.js";
 import "./chunk-7KVMU7O3.js";
 import "./chunk-4A4XTKKX.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/runtime",
-  "version": "4.3.0-canary.36844267522001",
+  "version": "4.3.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -63,17 +63,17 @@
     "@openai/agents": "0.14.3",
     "@openai/agents-core": "0.14.3",
     "@openai/agents-extensions": "0.14.3",
-    "@opengeni/agent-proto": "^0.6.0-canary.36844267522001",
-    "@opengeni/capabilities": "^0.3.4-canary.36844267522001",
-    "@opengeni/codemode": "^0.6.5-canary.36844267522001",
-    "@opengeni/codex": "^0.2.29-canary.36844267522001",
-    "@opengeni/config": "^3.1.1-canary.36844267522001",
-    "@opengeni/contracts": "^5.4.0-canary.36844267522001",
-    "@opengeni/network": "^0.3.1-canary.36844267522001",
-    "@opengeni/observability": "^0.8.35-canary.36844267522001",
-    "@opengeni/sdk": "^7.4.0-canary.36844267522001",
-    "@opengeni/tool-gateway": "^0.1.16-canary.36844267522001",
-    "@opengeni/xai-subscription": "^0.1.4-canary.36844267522001",
+    "@opengeni/agent-proto": "^0.6.0",
+    "@opengeni/capabilities": "^0.3.4",
+    "@opengeni/codemode": "^0.6.5",
+    "@opengeni/codex": "^0.2.29",
+    "@opengeni/config": "^3.1.1",
+    "@opengeni/contracts": "^5.4.0",
+    "@opengeni/network": "^0.3.1",
+    "@opengeni/observability": "^0.8.35",
+    "@opengeni/sdk": "^7.4.0",
+    "@opengeni/tool-gateway": "^0.1.16",
+    "@opengeni/xai-subscription": "^0.1.4",
     "debug": "4.4.3",
     "modal": "0.9.0",
     "openai": "6.47.0",

package/src/bundled_default_skills/opengeni-client/SKILL.md

@@ -184,11 +184,6 @@ Read selectively: [Product integration shapes](references/product-integration-sh
 [Data tools and credentials](references/data-tools-and-credentials.md), and
 [External users and embedded connection setup](references/external-users-and-connect.md).
 
-For per-seat included usage, administrator splits, top-ups, team budgets, or
-browser progress meters, read [Usage allowances](references/usage-allowances.md).
-Keep organization-budget writes on the backend; the conversation proxy exposes
-only own usage. These are post-call ceilings, not prepaid reservations.
-
 ## Build Gotchas
 
 - Always pass `baseUrl` (`process.env.OPENGENI_API_BASE_URL`); the chat facade

package/src/bundled_default_skills/opengeni-client/references/api-workflows.md

@@ -25,8 +25,6 @@ Only add `x-opengeni-access-key` when the operator says the deployment
 shared-key boundary is enabled. It is not a replacement for organization API
 keys in managed SaaS.
 
-A full organization API key can provision workspaces, members and asUser sessions; /v1/access/me reports this as credential.effectiveWorkspacePermissions.
-
 ## Minimal Server-Side Session Client
 
 ```ts
@@ -249,12 +247,6 @@ Never distribute an OpenGeni credential to a Connected Machine or try to inject
 
 ## Billing And Limits
 
-For per-seat plans, team budgets, administrator splits, and top-ups, read
-[Usage allowances](usage-allowances.md). Amounts are integer USD micros,
-configuration/member writes are versioned, grants are operation-keyed, and
-the conversation proxy exposes only `/usage/me`. Verify actual debit/reset
-and webhook behavior before promising enforcement or notifications.
-
 Managed SaaS uses prepaid Stripe credits and local usage/cost accounting. Client behavior should be simple:
 
 - Show billing/credit status from `/v1/billing` when the user has billing permission.

package/src/bundled_default_skills/opengeni-client/references/product-shapes-and-ui.md

@@ -31,22 +31,9 @@ console routes and 404 on the product origin. Never pass them to a raw `<a>`.
   proxy `sandboxFiles: true` (default off) plus `files:read`; they are confined
   to the selected working directory, including on Connected Machines, and
   refuse symlinked paths. Disabled sandbox links render unavailable.
-- Artifacts and Sites: reuse the OpenGeni surfaces, do not rebuild them.
-  `opengeni-site` fences render the inline Site preview automatically. Mount
-  `SessionArtifactViewer` (`@opengeni/react/artifacts`) in a host container
-  (for example the main area beside an assistant panel, a full-screen sheet on
-  phones) and pass `onOpenArtifact` to `SessionConversation` (or
-  `viewerLinkResolver` to `MessageTimeline`). Enable the proxy's
-  `artifacts: true`; editors also need the document, spreadsheet, and
-  presentation runtimes (`@opengeni/artifact-kernel-wasm-document`,
-  `@opengeni/artifact-kernel-wasm-spreadsheet`,
-  `@opengeni/artifact-kernel-wasm-presentation`) plus the SDK Worker URL
-  (`editableRuntimes`). A custom host proxy reports the viewer capability with
-  `artifactViewerCapability` from `@opengeni/sdk`. Close the viewer when the session changes.
-  Translate its copy with `labels` (partial `ArtifactLabels`) or
-  `ArtifactLabelsProvider`.
-- Other routing: `resolveLink={(target) => ... ({ href } | { open } | null)}`
-  on `SessionConversation` or `MessageTimeline`, or `OpenGeniLinkProvider` for a
+- Route editable artifacts and Sites to the product's own UI with
+  `resolveLink={(target) => ... ({ href } | { open } | null)}` on
+  `SessionConversation` or `MessageTimeline`, or `OpenGeniLinkProvider` for a
   subtree; it also covers `Markdown` inside a custom `renderMessageText`.
   Unresolved targets render as unavailable text, not broken links.
 - `MessageTimeline` alone has no defaults; add

package/src/claude-subscription-usage.ts

@@ -1,34 +1,15 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
 type Observer = (providerId: string, response: Response) => void;
-type Prepare = (providerId: string, headers: Headers) => Promise<Headers>;
-const observers = new AsyncLocalStorage<{
-  observe: Observer;
-  prepare?: Prepare;
-}>();
+const observers = new AsyncLocalStorage<Observer>();
 
 /** Like Codex usage headers: free observations within this turn's provider context. */
-export function withClaudeUsageObserver<T>(
-  observer: Observer,
-  run: () => Promise<T>,
-  prepare?: Prepare,
-): Promise<T> {
-  return observers.run({ observe: observer, ...(prepare ? { prepare } : {}) }, run);
-}
-export async function prepareClaudeSubscriptionRequest(
-  providerId: string,
-  input: Parameters<typeof fetch>[0],
-  init?: RequestInit,
-) {
-  const prepare = observers.getStore()?.prepare;
-  if (!prepare) return init;
-  const headers = new Headers(input instanceof Request ? input.headers : undefined);
-  new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
-  return { ...init, headers: await prepare(providerId, headers) };
+export function withClaudeUsageObserver<T>(observer: Observer, run: () => Promise<T>): Promise<T> {
+  return observers.run(observer, run);
 }
 export function observeClaudeUsageResponse(providerId: string, response: Response): void {
   try {
-    observers.getStore()?.observe(providerId, response);
+    observers.getStore()?.(providerId, response);
   } catch {
     // Usage telemetry must never change or consume a model response.
   }

package/src/index.ts

@@ -369,13 +369,10 @@ import {
   ModelRequestCaptureProvider,
   notifyModelRequestCapture,
   withModelRequestCapture,
-  withModelCallLifecycle,
-  type ModelCallLifecycle,
   type ModelRequestCapture,
   nextModelContextCaptureIndex,
 } from "./model-request-capture";
 import { decodeValidatedViewImageDataUrl } from "./view-image-validation";
-export { beforeModelRequest as awaitModelCallAdmission } from "./model-request-capture";
 import {
   baseModelInputFilterForSettings,
   boundModelToolOutputsFilterForSettings,
@@ -4381,7 +4378,6 @@ export async function prepareAgentTools(
     settings.mcpServers.filter(
       (config) =>
         tools.some((tool) => tool.id === config.id) &&
-        !config.connectionRef &&
         !localRegistry.has(config.id) &&
         !isFirstPartyMcpServer(settings, config) &&
         !isCodexAppsMcpServer(config),
@@ -5005,7 +5001,6 @@ export function selectedSessionRemoteMcpTargets(
     if (configs.length !== 1) return [];
     const config = configs[0]!;
     if (
-      config.connectionRef ||
       isFirstPartyMcpServer(settings, config) ||
       isCodexAppsMcpServer(config) ||
       BUILT_IN_MCP_BRIDGE_ADAPTERS.some((adapter) =>
@@ -8055,10 +8050,6 @@ export async function prepareRunInput(
 }
 
 export type RunAgentStreamOptions = {
-  /** Producer-side gate before calling any resolved model/provider. */
-  beforeModelRequest?: ModelCallLifecycle["beforeModelRequest"];
-  /** Register terminal response settlement before the next producer model request. */
-  onModelResponse?: ModelCallLifecycle["onModelResponse"];
   /** Abort the provider/tool loop when the owning activity is cancelled. */
   signal?: AbortSignal;
   /** Nonblocking phase measurements for request preparation before provider I/O. */
@@ -8302,17 +8293,8 @@ export async function runAgentStream(
   const scope = gate?.beginStream(overrides.signal);
   try {
     if (scope) agent.toolUseBehavior = scope.toolUseBehavior;
-    const stream = await withModelCallLifecycle(
-      {
-        ...(overrides.beforeModelRequest
-          ? { beforeModelRequest: overrides.beforeModelRequest }
-          : {}),
-        ...(overrides.onModelResponse ? { onModelResponse: overrides.onModelResponse } : {}),
-      },
-      () =>
-        withPreparedCompactionRequest(agent, () =>
-          runAgentStreamInternal(agent, input, settings, overrides, scope),
-        ),
+    const stream = await withPreparedCompactionRequest(agent, () =>
+      runAgentStreamInternal(agent, input, settings, overrides, scope),
     );
     // Observe the SDK's own settlement promise before exposing the stream. Do
     // not wrap/replace SDK history, errors, cancellation, or stream iteration.

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-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/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);