agent-embassy 1.6.0 → 1.6.1

package/dist/src/gateway/providers.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { chmod, lstat, mkdir, mkdtemp, readdir, realpath, rmdir, } from "node:fs/promises";
 import { BridgeError } from "../errors.js";
 import { CLAUDE_PEER_COMPATIBILITY, ClaudePeerAdapter, } from "./claude-peer.js";
-import { certifiedCompatibilityVersions, compatibilityProbeNames, evaluateCompatibilityAttestation, isCompatibilityAttestation, isCompatibilityVersion, sharesCompatibilityMajor, UNKNOWN_COMPATIBILITY_VERSION, } from "./compatibility.js";
+import { certifiedCompatibilityVersions, compatibilityCoversWrites, compatibilityProbeNames, evaluateCompatibilityAttestation, isCompatibilityAttestation, isCompatibilityVersion, sharesCompatibilityMajor, UNKNOWN_COMPATIBILITY_VERSION, } from "./compatibility.js";
 import { CODEX_APP_SERVER_WRITABLE_VERSIONS, CodexAppServerConnector, CodexConnectorError, codexWriteProbeFailure, } from "./codex-app-server.js";
 import { LocalCodexTransportError } from "./codex-local-transport.js";
 import { ClaudeNativeHelperSupervisor, } from "./claude-helper-supervisor.js";
@@ -1940,6 +1940,16 @@ function validateCodexFactory(factory, options = {}) {
         throw new BridgeError("CODEX_FACTORY_ATTESTATION_INVALID", "The local Codex provider requires exact schema and write attestations.");
     }
 }
+function codexFactoryWritesEnabled(factory, attestation, writeProbePassed = false) {
+    return ((attestation.tier === "certified" &&
+        CODEX_APP_SERVER_WRITABLE_VERSIONS.includes(attestation.version) &&
+        factory.writableReady &&
+        factory.writeCompatibility !== null) ||
+        (!factory.writableReady &&
+            factory.writeCompatibility === null &&
+            writeProbePassed &&
+            compatibilityCoversWrites(attestation)));
+}
 function codexRouteState(observation) {
     if (observation.connection !== "ready")
         return "stale";
@@ -1999,6 +2009,7 @@ export class LocalCodexGatewayProvider {
     callbackDrainFrozen = false;
     writeProbeObservationsByGeneration = new Map();
     writeProbeResults = new Map();
+    writeProbeDecline;
     writeProbeOverflow;
     compatibilityAttested;
     compatibilityFailureCode;
@@ -2014,7 +2025,9 @@ export class LocalCodexGatewayProvider {
         this.factory = options.factory;
         this.refreshFactory = options.refreshFactory;
         exactLocalHost(options.factory.hostId);
-        this.compatibilityAttested = CODEX_APP_SERVER_WRITABLE_VERSIONS.includes(options.factory.appServerVersion);
+        this.compatibilityAttested =
+            options.factory.writableReady &&
+                options.factory.writeCompatibility !== null;
         this.maxCallbacks = positiveBounded(options.maxCallbackEvents, MAX_CODEX_CALLBACKS, 4_096);
         this.maxRoutes = positiveBounded(options.maxRoutes, MAX_CODEX_ROUTES, 256);
         this.maxReplyBytes = positiveBounded(options.maxReplyBytes, MAX_TRANSIENT_REPLY_BYTES, 1024 * 1024);
@@ -2073,14 +2086,11 @@ export class LocalCodexGatewayProvider {
                 attestation.safeErrorCode ?? "CODEX_COMPATIBILITY_CHECK_FAILED";
             return;
         }
-        const writableCertified = attestation.tier === "certified" &&
-            CODEX_APP_SERVER_WRITABLE_VERSIONS.includes(attestation.version) &&
-            this.factory.writableReady &&
-            this.factory.writeCompatibility !== null;
+        const writesEnabled = codexFactoryWritesEnabled(this.factory, attestation, this.latestWriteCompatibilityProbeObservation(this.factory.endpointGeneration)?.outcome === "pass");
         const schemaObserved = attestation.tier === "schema_attested" &&
             !this.factory.writableReady &&
             this.factory.writeCompatibility === null;
-        if ((!writableCertified && !schemaObserved) ||
+        if ((!writesEnabled && !schemaObserved) ||
             (this.endpointUnavailable && pending === undefined) ||
             !pendingMatches) {
             throw new BridgeError("CODEX_COMPATIBILITY_ATTESTATION_MISMATCH", "The Codex compatibility attestation does not match this endpoint.");
@@ -2089,8 +2099,8 @@ export class LocalCodexGatewayProvider {
         this.pendingEndpointRefreshEvent = undefined;
         this.pendingEndpointRefreshSelectorClaimed = false;
         this.clearEndpointActivationRetry();
-        this.compatibilityAttested = writableCertified;
-        this.endpointUnavailable = !writableCertified;
+        this.compatibilityAttested = writesEnabled;
+        this.endpointUnavailable = !writesEnabled;
         this.compatibilityFailureCode = undefined;
     }
     releaseEndpointRefreshSelectorClaim(endpointGeneration) {
@@ -2113,6 +2123,9 @@ export class LocalCodexGatewayProvider {
         return (this.writeProbeObservationsByGeneration.get(endpointGeneration) ??
             (this.writeProbeOverflow?.endpointGeneration === endpointGeneration
                 ? this.writeProbeOverflow.observation
+                : undefined) ??
+            (this.writeProbeDecline?.endpointGeneration === endpointGeneration
+                ? this.writeProbeDecline.observation
                 : undefined));
     }
     async runCompatibilityProbes(context) {
@@ -2217,10 +2230,13 @@ export class LocalCodexGatewayProvider {
         if (cached !== undefined)
             return await cached;
         if (this.writeProbeOverflow?.key === key) {
-            return this.writeProbeOverflow.observation;
+            if (this.writeProbeResults.size >= MAX_CODEX_WRITE_PROBE_ATTEMPTS) {
+                return this.writeProbeOverflow.observation;
+            }
+            this.writeProbeOverflow = undefined;
         }
         if (this.writeProbeResults.size >= MAX_CODEX_WRITE_PROBE_ATTEMPTS) {
-            const observation = Object.freeze(codexWriteProbeFailure("CODEX_WRITE_PROBE_THREAD_SETUP_FAILED"));
+            const observation = Object.freeze(codexWriteProbeFailure("CODEX_WRITE_PROBE_CAPACITY_EXHAUSTED"));
             this.writeProbeOverflow = Object.freeze({
                 endpointGeneration: factory.endpointGeneration,
                 key,
@@ -2235,7 +2251,20 @@ export class LocalCodexGatewayProvider {
         }
         const pending = this.executeCodexWriteProbe(connector, context).then((result) => {
             const observation = Object.freeze({ ...result });
-            this.writeProbeObservationsByGeneration.set(factory.endpointGeneration, observation);
+            if (observation.outcome === "fail" &&
+                (observation.safeErrorCode ===
+                    "CODEX_WRITE_PROBE_MODEL_PIN_UNAVAILABLE" ||
+                    observation.safeErrorCode ===
+                        "CODEX_WRITE_PROBE_RATE_LIMIT_CONSTRAINED")) {
+                this.writeProbeResults.delete(key);
+                this.writeProbeDecline = Object.freeze({
+                    endpointGeneration: factory.endpointGeneration,
+                    observation,
+                });
+            }
+            else {
+                this.writeProbeObservationsByGeneration.set(factory.endpointGeneration, observation);
+            }
             if (observation.outcome === "fail" && this.callbacks !== undefined) {
                 invokeCallback(() => this.callbacks?.onProtocolNotice?.({
                     code: observation.safeErrorCode,
@@ -2366,7 +2395,7 @@ export class LocalCodexGatewayProvider {
                 safeErrorCode: this.compatibilityFailureCode,
             };
         }
-        return this.factory.writeCompatibility === null
+        return !this.compatibilityAttested
             ? {
                 health: "degraded",
                 compatibility: "compatible",
@@ -2550,10 +2579,6 @@ export class LocalCodexGatewayProvider {
             route.endpointGeneration !== this.factory.endpointGeneration) {
             return { state: "failed", safeErrorCode: "CODEX_ROUTE_UNAVAILABLE" };
         }
-        if (!this.factory.writableReady ||
-            this.factory.writeCompatibility === null) {
-            return { state: "failed", safeErrorCode: "CODEX_WRITES_DISABLED" };
-        }
         const guard = route.connector.guard();
         if (!guard.writableReady) {
             return { state: "failed", safeErrorCode: "CODEX_WRITES_DISABLED" };
@@ -2755,7 +2780,9 @@ export class LocalCodexGatewayProvider {
         }
         const admittedFactory = this.factory;
         const creation = (async () => {
-            const route = await this.createRoute(threadId, admittedFactory, queueInitialObservation);
+            const route = await this.createRoute(threadId, admittedFactory, queueInitialObservation, this.pendingEndpointAttestation === undefined
+                ? this.compatibilityAttested
+                : codexFactoryWritesEnabled(admittedFactory, this.pendingEndpointAttestation, this.latestWriteCompatibilityProbeObservation(admittedFactory.endpointGeneration)?.outcome === "pass"));
             if (this.closing || this.closed) {
                 await this.closeRoute(route);
                 throw new BridgeError("CODEX_PROVIDER_UNAVAILABLE", "The local Codex provider closed during route creation.");
@@ -2779,13 +2806,12 @@ export class LocalCodexGatewayProvider {
             this.routeCreations.delete(threadId);
         }
     }
-    async createRoute(threadId, factory, queueInitialObservation) {
+    async createRoute(threadId, factory, queueInitialObservation, writesEnabled) {
         let transport;
         let connector;
         const generation = Symbol(threadId);
         try {
             transport = await factory.connectTransport();
-            const writesEnabled = factory.writableReady && factory.writeCompatibility !== null;
             connector = await CodexAppServerConnector.connect({
                 compatibility: factory.writeCompatibility ?? factory.schemaCompatibility,
                 writesEnabled,
@@ -3053,7 +3079,7 @@ export class LocalCodexGatewayProvider {
                 if (this.closing || this.closed)
                     break;
                 try {
-                    const route = await this.createRoute(routeHandle, replacementFactory, false);
+                    const route = await this.createRoute(routeHandle, replacementFactory, false, codexFactoryWritesEnabled(replacementFactory, attestation, this.latestWriteCompatibilityProbeObservation(replacementFactory.endpointGeneration)?.outcome === "pass"));
                     if (this.closing || this.closed) {
                         await this.closeRoute(route);
                         break;