@cursor/july 0.1.105 → 0.1.108

package/dist/internal/hosted-delivery.js

@@ -11,16 +11,17 @@ import { randomBytes } from "node:crypto";
 import { dispatchOutcome } from "./channel-dispatch.js";
 import { consumeHostedBoundSecrets, } from "./cursor/hosted-bound-secrets.js";
 import { createDeferredChannelSession, DeferredChannelSessionError, } from "./deferred-channel-session.js";
-import { formatGuestNetworkServerTiming, GUEST_CONNECT_STALLED, GUEST_NETWORK_UNAVAILABLE, GuestNetworkUnavailableError, isQuietGuestConnectStallMessage, waitForGuestNetworkReady, } from "./guest-network.js";
+import { formatGuestNetworkServerTiming, GUEST_CONNECT_STALLED, GUEST_NETWORK_UNAVAILABLE, GuestNetworkUnavailableError, waitForGuestNetworkReady, } from "./guest-network.js";
 import { getHostedAdmissionAdapter, } from "./hosted-admission-adapter.js";
 import { HostedAdmissionLocalSendError, runDuringHostedAdmission, } from "./hosted-admission-context.js";
-import { HOSTED_ADMISSION_PATH, HOSTED_DELIVERY_HEADER, HOSTED_DELIVERY_PROTOCOL_VERSION, HOSTED_EXECUTION_PATH, parseHostedAdmission, parseHostedExecution, } from "./hosted-delivery-protocol.js";
+import { HOSTED_ADMISSION_PATH, HOSTED_DELIVERY_HEADER, HOSTED_DELIVERY_PROTOCOL_VERSION, HOSTED_EXECUTION_PATH, HOSTED_GUEST_RETRY_TERMINAL, HOSTED_GUEST_RETRY_TRANSIENT, hostedFailureClassification, hostedGuestErrorResponse, isHostedReminderAdmission, parseHostedAdmission, parseHostedExecution, parseHostedReminderFireDescriptorPayload, parseHostedReminderFirePayload, } from "./hosted-delivery-protocol.js";
 import { abortReasonFromTurnStatus, HOSTED_EXECUTION_DIAG_RUNNING_STATUS, hostedExecutionDiagId, } from "./hosted-execution-diag.js";
 import { flushHostedExecutionRecord, } from "./hosted-execution-flush.js";
 import { recordHostedManagedAutomation } from "./hosted-managed-automation.js";
-import { errorResponse, readJsonObject } from "./http-channel.js";
+import { readJsonObject } from "./http-channel.js";
 import { endActiveHttpSpan } from "./otel/http.js";
-import { statusForThrownRequestError } from "./request-error-status.js";
+import { ReminderValidationError, UnknownReminderError, } from "./reminder-runner.js";
+import { mapThrownRequestError, statusForThrownRequestError, } from "./request-error-status.js";
 /**
  * A second `send()` in one delivery is a deterministic authored bug — the
  * wire protocol carries exactly one pending send per delivery — so it must
@@ -44,6 +45,22 @@ function boundedMessage(text) {
         ? `${text.slice(0, MAX_ERROR_MESSAGE_LENGTH)}…`
         : text;
 }
+function terminalHostedError(status, error, message) {
+    return hostedGuestErrorResponse({
+        status,
+        error,
+        retry: HOSTED_GUEST_RETRY_TERMINAL,
+        message,
+    });
+}
+function transientHostedError(status, error, message) {
+    return hostedGuestErrorResponse({
+        status,
+        error,
+        retry: HOSTED_GUEST_RETRY_TRANSIENT,
+        message,
+    });
+}
 /**
  * Classify deterministic authored protocol violations as non-retryable 422
  * admissions. Anything else returns `undefined` so callers fall through to
@@ -61,7 +78,31 @@ function nonRetryableRejection(error) {
         return undefined;
     }
     return {
-        response: errorResponse(422, code, boundedMessage(error.message)),
+        response: terminalHostedError(422, code, boundedMessage(error.message)),
+    };
+}
+/**
+ * Prefer the shared throw → HTTP mapper (guest network / connect stall /
+ * session busy / …) before collapsing into agent_admission_threw or
+ * background_dispatch_failed. Those agent codes otherwise hide typed
+ * transient failures that the outer handleRequest boundary never sees.
+ */
+function mappedAdmissionFailure(error) {
+    const rejected = nonRetryableRejection(error);
+    if (rejected !== undefined) {
+        return rejected;
+    }
+    const mapped = mapThrownRequestError(error);
+    if (mapped === undefined) {
+        return undefined;
+    }
+    return {
+        response: hostedGuestErrorResponse({
+            status: mapped.status,
+            error: mapped.code,
+            retry: mapped.retry,
+            message: boundedMessage(mapped.message),
+        }),
     };
 }
 /**
@@ -79,7 +120,7 @@ export function dispatchHostedAdmission(input) {
         const adapter = getHostedAdmissionAdapter(input.definition);
         if (adapter === undefined || adapter.kind !== input.delivery.channelKind) {
             return {
-                response: Response.json({ ok: false, error: "channel_kind_mismatch" }, { status: 422 }),
+                response: terminalHostedError(422, "channel_kind_mismatch"),
             };
         }
         // The admission window marker follows the async graph into task bodies so
@@ -87,6 +128,66 @@ export function dispatchHostedAdmission(input) {
         return runDuringHostedAdmission(() => runAdmission(input, adapter));
     });
 }
+/**
+ * Reserved reminder admission: parse the compact payload and invoke
+ * ReminderRunner.dispatch. Returns a standard hosted outcome (`task` /
+ * `skip`) and never opens the send-capture / model-session path here —
+ * prompt-form fires still follow up inside the runner.
+ */
+function dispatchHostedReminderAdmission(input, delivery) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const descriptor = parseHostedReminderFireDescriptorPayload(delivery.payload);
+        if (descriptor !== undefined) {
+            if (input.executeReminderDescriptor === undefined) {
+                return transientHostedError(503, "reminder_dispatch_unavailable", "This guest has no reminder CP executor wired for hosted admission.");
+            }
+            try {
+                const result = yield input.executeReminderDescriptor(descriptor);
+                const outcome = result.outcome === "noop" ? "skip" : "task";
+                return Response.json({
+                    ok: true,
+                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                    outcome,
+                });
+            }
+            catch (error) {
+                if (error instanceof UnknownReminderError) {
+                    return terminalHostedError(404, "unknown_reminder", boundedMessage(error.message));
+                }
+                if (error instanceof ReminderValidationError) {
+                    return terminalHostedError(400, "invalid_reminder", boundedMessage(error.message));
+                }
+                // Transient CP apply/fetch failures must remain retryable.
+                throw error;
+            }
+        }
+        if (input.fireReminder === undefined) {
+            return transientHostedError(503, "reminder_dispatch_unavailable", "This guest has no reminder runner wired for hosted admission.");
+        }
+        const payload = parseHostedReminderFirePayload(delivery.payload);
+        if (payload === undefined) {
+            return terminalHostedError(400, "invalid_reminder_payload", "Expected reminder descriptor or legacy payload { reminderId, fireCount }.");
+        }
+        try {
+            const result = yield input.fireReminder(payload.reminderId, payload.fireCount);
+            const outcome = result.outcome === "noop" ? "skip" : "task";
+            return Response.json({
+                ok: true,
+                v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                outcome,
+            });
+        }
+        catch (error) {
+            if (error instanceof UnknownReminderError) {
+                return terminalHostedError(404, "unknown_reminder", boundedMessage(error.message));
+            }
+            if (error instanceof ReminderValidationError) {
+                return terminalHostedError(400, "invalid_reminder", boundedMessage(error.message));
+            }
+            throw error;
+        }
+    });
+}
 function runAdmission(input, adapter) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -106,6 +207,7 @@ function runAdmission(input, adapter) {
         let dispatched;
         try {
             dispatched = yield adapter.dispatch({
+                channelId: input.delivery.channelId,
                 eventType: input.delivery.eventType,
                 payload: input.delivery.payload,
                 deliveryId: input.delivery.deliveryId,
@@ -113,27 +215,29 @@ function runAdmission(input, adapter) {
             });
         }
         catch (error) {
-            const rejected = nonRetryableRejection(error);
-            if (rejected !== undefined) {
-                return rejected;
+            const mapped = mappedAdmissionFailure(error);
+            if (mapped !== undefined) {
+                return mapped;
             }
-            throw error;
+            return {
+                response: terminalHostedError(500, "agent_admission_threw", boundedMessage(error instanceof Error ? error.message : String(error))),
+            };
         }
         if (!dispatched.ok) {
             return {
-                response: Response.json({ ok: false, error: "channel_dispatch_failed" }, { status: dispatched.status >= 400 ? dispatched.status : 502 }),
+                response: terminalHostedError(dispatched.status >= 400 ? dispatched.status : 502, "channel_dispatch_failed"),
             };
         }
         try {
             yield Promise.all(background);
         }
         catch (error) {
-            const rejected = nonRetryableRejection(error);
-            if (rejected !== undefined) {
-                return rejected;
+            const mapped = mappedAdmissionFailure(error);
+            if (mapped !== undefined) {
+                return mapped;
             }
             return {
-                response: errorResponse(503, "background_dispatch_failed", boundedMessage(error instanceof Error ? error.message : String(error))),
+                response: terminalHostedError(503, "background_dispatch_failed", boundedMessage(error instanceof Error ? error.message : String(error))),
             };
         }
         if (captured !== undefined) {
@@ -156,7 +260,7 @@ function runAdmission(input, adapter) {
         const outcome = dispatchOutcome(dispatched);
         if (outcome === undefined || outcome === "send") {
             return {
-                response: Response.json({ ok: false, error: "channel_outcome_missing" }, { status: 502 }),
+                response: terminalHostedError(502, "channel_outcome_missing"),
             };
         }
         return {
@@ -234,7 +338,7 @@ export function registerHostedDeliveryRoute(input) {
         const consumed = consumeBoundSecrets();
         return consumed.ok
             ? undefined
-            : errorResponse(503, consumed.code, boundedMessage(consumed.message));
+            : transientHostedError(503, consumed.code, boundedMessage(consumed.message));
     };
     const finishNetworkWait = (phase) => __awaiter(this, void 0, void 0, function* () {
         try {
@@ -252,7 +356,7 @@ export function registerHostedDeliveryRoute(input) {
                     : "Guest network is not ready for outbound requests.";
             return {
                 timing,
-                response: errorResponse(503, GUEST_NETWORK_UNAVAILABLE, boundedMessage(message)),
+                response: transientHostedError(503, GUEST_NETWORK_UNAVAILABLE, boundedMessage(message)),
             };
         }
     });
@@ -298,13 +402,21 @@ export function registerHostedDeliveryRoute(input) {
                         ? Object.keys(rawAdmission)
                         : [];
                     console.info(`[agent-sdk] hosted admission rejected: envelope failed to parse keys=${JSON.stringify(rawKeys)} hasManagedAutomation=${String(rawKeys.includes("managedAutomation"))}`);
-                    return finish(errorResponse(400, "invalid_hosted_admission", "Expected a supported Agent SDK hosted-admission envelope."));
+                    return finish(terminalHostedError(400, "invalid_hosted_admission", "Expected a supported Agent SDK hosted-admission envelope."));
                 }
                 console.info(`[agent-sdk] hosted admission received deliveryId=${delivery.deliveryId} channelId=${delivery.channelId} channelKind=${delivery.channelKind} eventType=${delivery.eventType} sessionMode=${delivery.sessionMode} managedAutomation=${delivery.managedAutomation === undefined ? "<absent>" : `automationUuid=${delivery.managedAutomation.automationUuid} mcpServerNames=${String(delivery.managedAutomation.mcpServerNames.length)} slackChannels=${delivery.managedAutomation.slackChannels === undefined ? "<absent>" : JSON.stringify(delivery.managedAutomation.slackChannels)}`}`);
                 recordHostedManagedAutomation(delivery);
+                if (isHostedReminderAdmission(delivery)) {
+                    const network = yield finishNetworkWait("admission");
+                    guestNetwork = network.timing;
+                    if (network.response !== undefined) {
+                        return finish(network.response);
+                    }
+                    return finish(yield dispatchHostedReminderAdmission(input, delivery));
+                }
                 const channel = input.channels.find((candidate) => candidate.id === delivery.channelId);
                 if (channel === undefined) {
-                    return finish(errorResponse(404, "channel_not_found", `No channel named "${delivery.channelId}" is mounted.`));
+                    return finish(terminalHostedError(404, "channel_not_found", `No channel named "${delivery.channelId}" is mounted.`));
                 }
                 const network = yield finishNetworkWait("admission");
                 guestNetwork = network.timing;
@@ -350,16 +462,16 @@ export function registerHostedDeliveryRoute(input) {
                 }
                 const execution = parseHostedExecution(yield readJsonObject(request));
                 if (execution === undefined) {
-                    return finish(errorResponse(400, "invalid_hosted_execution", "Expected a supported Agent SDK hosted-execution envelope."));
+                    return finish(terminalHostedError(400, "invalid_hosted_execution", "Expected a supported Agent SDK hosted-execution envelope."));
                 }
                 pruneExpired();
                 const admitted = pending.get(execution.admissionToken);
                 if (admitted === undefined) {
-                    return finish(errorResponse(409, "hosted_admission_unavailable", "The hosted admission token is missing or expired."));
+                    return finish(transientHostedError(409, "hosted_admission_unavailable", "The hosted admission token is missing or expired."));
                 }
                 if (admitted.sessionPublicId !== undefined &&
                     admitted.sessionPublicId !== execution.sessionPublicId) {
-                    return finish(errorResponse(409, "hosted_admission_session_mismatch", "The hosted admission token is already bound to another session."));
+                    return finish(transientHostedError(409, "hosted_admission_session_mismatch", "The hosted admission token is already bound to another session."));
                 }
                 const network = yield finishNetworkWait("execution");
                 guestNetwork = network.timing;
@@ -381,11 +493,14 @@ export function registerHostedDeliveryRoute(input) {
                         ? {}
                         : { snapshotLogs: input.snapshotLogs }));
                     const writeDiag = (fields) => __awaiter(this, void 0, void 0, function* () {
-                        yield flushHostedExecutionRecord(sinks, Object.assign(Object.assign(Object.assign({ executionId, sessionPublicId: execution.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs: Math.max(0, Math.round(performance.now() - startedAt)) }, (fields.message === undefined
+                        const classification = fields.failureCode === undefined
+                            ? undefined
+                            : hostedFailureClassification(fields.failureCode);
+                        yield flushHostedExecutionRecord(sinks, Object.assign(Object.assign(Object.assign(Object.assign({ executionId, sessionPublicId: execution.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs: Math.max(0, Math.round(performance.now() - startedAt)) }, (fields.message === undefined
                             ? {}
                             : { message: fields.message })), (fields.abortReason === undefined
                             ? {}
-                            : { abortReason: fields.abortReason })), (fields.error === undefined ? {} : { error: fields.error })));
+                            : { abortReason: fields.abortReason })), { failureCode: fields.failureCode, classification }), (fields.error === undefined ? {} : { error: fields.error })));
                     });
                     // Claim the file before the turn runs. The host reads it after its
                     // own POST returns, which for a 9-minute timeout is while this turn
@@ -410,21 +525,24 @@ export function registerHostedDeliveryRoute(input) {
                         // as soon as the POST returns. A leftover SDK handle freezes a
                         // dead Connect/HTTP2 session that the next wake then reuses.
                         evictHostedSdkSessions(input.evictSdkSession, session.id, execution.sessionPublicId);
+                        const hostedFailure = outcome.status === "finished"
+                            ? undefined
+                            : hostedFailureForUnfinishedTurn(outcome);
                         yield writeDiag({
                             sessionId: session.id,
                             turnStatus: outcome.status,
                             message: outcome.errorMessage,
-                            abortReason: abortReasonFromTurnStatus(outcome.status, outcome.errorMessage),
+                            abortReason: abortReasonFromTurnStatus(outcome.status, outcome.cancellationReason),
+                            failureCode: hostedFailure === null || hostedFailure === void 0 ? void 0 : hostedFailure.error,
                         });
-                        if (outcome.status !== "finished") {
-                            // waitForCompletion resolves (does not throw) on a quiet
-                            // Connect abort. Map that to guest_connect_stalled so TAS
-                            // retries the same pod. Real runner failures stay turn_failed.
+                        if (hostedFailure !== undefined) {
                             return {
                                 status: 503,
                                 body: {
                                     ok: false,
-                                    error: hostedErrorForUnfinishedTurn(outcome.errorMessage),
+                                    error: hostedFailure.error,
+                                    retry: hostedFailure.retry,
+                                    classification: hostedFailureClassification(hostedFailure.error),
                                     turnStatus: outcome.status,
                                     message: outcome.errorMessage,
                                 },
@@ -446,6 +564,7 @@ export function registerHostedDeliveryRoute(input) {
                             turnStatus: "error",
                             message: error instanceof Error ? error.message : String(error),
                             abortReason: "execute_throw",
+                            failureCode: "internal_error",
                             error,
                         });
                         throw error;
@@ -470,12 +589,36 @@ function evictHostedSdkSessions(evict, ...ids) {
         evict(id);
     }
 }
-function hostedErrorForUnfinishedTurn(errorMessage) {
-    if (errorMessage !== undefined &&
-        isQuietGuestConnectStallMessage(errorMessage)) {
-        return GUEST_CONNECT_STALLED;
+const TRANSIENT_TURN_ERROR_CODES = new Set([
+    "ABORT_ERR",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "canceled",
+    "unavailable",
+    "unknown",
+]);
+function hostedFailureForUnfinishedTurn(outcome) {
+    if (outcome.errorCode === "agent_dependency_failed") {
+        return {
+            error: "agent_dependency_failed",
+            retry: HOSTED_GUEST_RETRY_TERMINAL,
+        };
+    }
+    if (outcome.status === "error" &&
+        outcome.errorCode !== undefined &&
+        TRANSIENT_TURN_ERROR_CODES.has(outcome.errorCode)) {
+        return {
+            error: GUEST_CONNECT_STALLED,
+            retry: HOSTED_GUEST_RETRY_TRANSIENT,
+        };
+    }
+    if (outcome.status === "cancelled") {
+        return {
+            error: "turn_cancelled",
+            retry: HOSTED_GUEST_RETRY_TERMINAL,
+        };
     }
-    return "turn_failed";
+    return { error: "turn_failed", retry: HOSTED_GUEST_RETRY_TERMINAL };
 }
 function afterHostedWork(flushOtel, work) {
     return __awaiter(this, void 0, void 0, function* () {

package/dist/internal/hosted-execution-diag.d.ts

@@ -3,6 +3,7 @@
  * session-run document and the `start.log` tee by
  * `hosted-execution-flush.ts`.
  */
+import { type HostedFailureClassification } from "./hosted-delivery-protocol.js";
 export declare const HOSTED_EXECUTION_DIAG_VERSION = 1;
 /** Cap so a runaway message cannot fill the guest disk or the host log. */
 export declare const HOSTED_EXECUTION_DIAG_MAX_BYTES = 4096;
@@ -41,6 +42,8 @@ export type HostedExecutionDiag = {
     signalAborted?: boolean;
     requestId?: string;
     abortReason?: HostedExecutionDiagAbortReason;
+    failureCode?: string;
+    classification?: HostedFailureClassification;
 };
 /** Written before the turn starts so a stalled execution still has a record. */
 export declare const HOSTED_EXECUTION_DIAG_RUNNING_STATUS = "running";
@@ -54,7 +57,7 @@ export declare const HOSTED_ERROR_SNIPPET_MAX_CHARS = 700;
  */
 export declare function hostedErrorStackSnippet(error: unknown): string;
 export declare function hostedExecutionDiagPath(stateRoot: string): string;
-export declare function abortReasonFromTurnStatus(status: string, message: string | undefined): HostedExecutionDiagAbortReason | undefined;
+export declare function abortReasonFromTurnStatus(status: string, cancellationReason: "signal" | "runner" | undefined): HostedExecutionDiagAbortReason | undefined;
 export declare function parseHostedExecutionDiag(raw: string): HostedExecutionDiag | undefined;
 /**
  * Overwrite the per-execution diag file. Soft-fail: a write error must not

package/dist/internal/hosted-execution-diag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hosted-execution-diag.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-execution-diag.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,2EAA2E;AAC3E,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,MAAM,MAAM,8BAA8B,GACtC,cAAc,GACd,kBAAkB,GAClB,cAAc,GACd,eAAe,CAAC;AAEpB;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,CAAC,EAAE,OAAO,6BAA6B,CAAC;IACxC,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,8BAA8B,CAAC;CAC9C,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,oCAAoC,YAAY,CAAC;AAmC9D,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAyB9D;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,8BAA8B,GAAG,SAAS,CAU5C;AAED,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,GACV,mBAAmB,GAAG,SAAS,CA2EjC;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,IAAI,CAAC,CAmBf"}
+{"version":3,"file":"hosted-execution-diag.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-execution-diag.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,+BAA+B,CAAC;AAEvC,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,2EAA2E;AAC3E,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,MAAM,MAAM,8BAA8B,GACtC,cAAc,GACd,kBAAkB,GAClB,cAAc,GACd,eAAe,CAAC;AAEpB;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,CAAC,EAAE,OAAO,6BAA6B,CAAC;IACxC,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,8BAA8B,CAAC;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,2BAA2B,CAAC;CAC9C,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,oCAAoC,YAAY,CAAC;AAqC9D,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAyB9D;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAClD,8BAA8B,GAAG,SAAS,CAU5C;AAED,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,GACV,mBAAmB,GAAG,SAAS,CAqFjC;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,IAAI,CAAC,CAmBf"}

package/dist/internal/hosted-execution-diag.js

@@ -15,7 +15,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { createHash, randomBytes } from "node:crypto";
 import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { HOSTED_EXECUTION_DIAG_FILENAME } from "./hosted-delivery-protocol.js";
+import { HOSTED_EXECUTION_DIAG_FILENAME, parseHostedFailureClassification, } from "./hosted-delivery-protocol.js";
 export const HOSTED_EXECUTION_DIAG_VERSION = 1;
 /** Cap so a runaway message cannot fill the guest disk or the host log. */
 export const HOSTED_EXECUTION_DIAG_MAX_BYTES = 4096;
@@ -49,6 +49,8 @@ const DIAG_KEYS = new Set([
     "signalAborted",
     "requestId",
     "abortReason",
+    "failureCode",
+    "classification",
 ]);
 const ABORT_REASONS = new Set([
     "signal_abort",
@@ -101,12 +103,12 @@ export function hostedErrorStackSnippet(error) {
 export function hostedExecutionDiagPath(stateRoot) {
     return join(stateRoot, HOSTED_EXECUTION_DIAG_FILENAME);
 }
-export function abortReasonFromTurnStatus(status, message) {
+export function abortReasonFromTurnStatus(status, cancellationReason) {
     if (status === "finished") {
         return undefined;
     }
     if (status === "cancelled") {
-        return message !== undefined && /abort/i.test(message)
+        return cancellationReason === "signal"
             ? "signal_abort"
             : "runner_cancelled";
     }
@@ -153,6 +155,13 @@ export function parseHostedExecutionDiag(raw) {
     const message = boundedOptionalString(body.message, 1024);
     const stack = boundedOptionalString(body.stack, HOSTED_ERROR_SNIPPET_MAX_CHARS);
     const requestId = boundedOptionalString(body.requestId, 128);
+    const failureCode = boundedOptionalString(body.failureCode, 64);
+    const classification = body.classification === undefined
+        ? undefined
+        : parseHostedFailureClassification(body.classification);
+    if (body.classification !== undefined && classification === undefined) {
+        return undefined;
+    }
     const abortReason = body.abortReason === undefined
         ? undefined
         : typeof body.abortReason === "string" &&
@@ -166,7 +175,7 @@ export function parseHostedExecutionDiag(raw) {
         typeof body.signalAborted !== "boolean") {
         return undefined;
     }
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ v: HOSTED_EXECUTION_DIAG_VERSION, executionId: body.executionId, writtenAt: body.writtenAt, sessionPublicId: body.sessionPublicId, sessionId: body.sessionId, turnStatus: body.turnStatus, durationMs: body.durationMs }, (message === undefined ? {} : { message })), (stack === undefined ? {} : { stack })), (body.signalAborted === true ? { signalAborted: true } : {})), (requestId === undefined ? {} : { requestId })), (abortReason === undefined ? {} : { abortReason }));
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ v: HOSTED_EXECUTION_DIAG_VERSION, executionId: body.executionId, writtenAt: body.writtenAt, sessionPublicId: body.sessionPublicId, sessionId: body.sessionId, turnStatus: body.turnStatus, durationMs: body.durationMs }, (message === undefined ? {} : { message })), (stack === undefined ? {} : { stack })), (body.signalAborted === true ? { signalAborted: true } : {})), (requestId === undefined ? {} : { requestId })), (abortReason === undefined ? {} : { abortReason })), (failureCode === undefined ? {} : { failureCode })), (classification === undefined ? {} : { classification }));
 }
 /**
  * Overwrite the per-execution diag file. Soft-fail: a write error must not

package/dist/internal/hosted-execution-flush.d.ts

@@ -8,6 +8,7 @@
  * durable document and re-snapshots the tee; the local json stays `running`
  * so TAS does not treat a previous delivery's terminal record as this one.
  */
+import type { HostedFailureClassification } from "./hosted-delivery-protocol.js";
 import { type HostedExecutionDiagAbortReason } from "./hosted-execution-diag.js";
 import type { LogRingEntry } from "./log-ring.js";
 import { type SessionRunAbortReason, type SessionRunExecutionWrite } from "./session-run-log.js";
@@ -26,6 +27,8 @@ export type HostedExecutionFlushFields = {
     durationMs: number;
     message?: string;
     abortReason?: HostedExecutionDiagAbortReason;
+    failureCode?: string;
+    classification?: HostedFailureClassification;
     error?: unknown;
 };
 /**

package/dist/internal/hosted-execution-flush.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hosted-execution-flush.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-execution-flush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,8BAA8B,EAGpC,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAG9B,MAAM,sBAAsB,CAAC;AAU9B,MAAM,MAAM,yBAAyB,GAAG;IACtC,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,aAAa,CAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,YAAY,CAAC,IAAI,YAAY,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,8BAA8B,CAAC;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,yBAAyB,EAChC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CA0Df;AAED;;GAEG;AACH,wBAAsB,gCAAgC,CAAC,IAAI,EAAE;IAC3D,iBAAiB,EAAE,CACjB,MAAM,EAAE,OAAO,CACb,qBAAqB,EACrB,cAAc,GAAG,oBAAoB,GAAG,qBAAqB,CAC9D,EACD,KAAK,CAAC,EAAE,OAAO,KACZ,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CACb,qBAAqB,EACrB,cAAc,GAAG,oBAAoB,GAAG,qBAAqB,CAC9D,CAAC;IACF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKhB"}
+{"version":3,"file":"hosted-execution-flush.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-execution-flush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,EACL,KAAK,8BAA8B,EAGpC,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAG9B,MAAM,sBAAsB,CAAC;AAU9B,MAAM,MAAM,yBAAyB,GAAG;IACtC,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,aAAa,CAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,YAAY,CAAC,IAAI,YAAY,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,8BAA8B,CAAC;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,2BAA2B,CAAC;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,yBAAyB,EAChC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CA0Df;AAED;;GAEG;AACH,wBAAsB,gCAAgC,CAAC,IAAI,EAAE;IAC3D,iBAAiB,EAAE,CACjB,MAAM,EAAE,OAAO,CACb,qBAAqB,EACrB,cAAc,GAAG,oBAAoB,GAAG,qBAAqB,CAC9D,EACD,KAAK,CAAC,EAAE,OAAO,KACZ,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CACb,qBAAqB,EACrB,cAAc,GAAG,oBAAoB,GAAG,qBAAqB,CAC9D,CAAC;IACF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKhB"}

package/dist/internal/hosted-execution-flush.js

@@ -39,11 +39,9 @@ export function flushHostedExecutionRecord(sinks, fields) {
             ? undefined
             : hostedErrorStackSnippet(fields.error);
         if (sinks.stateRoot !== undefined) {
-            yield writeHostedExecutionDiag(sinks.stateRoot, Object.assign(Object.assign(Object.assign(Object.assign({ v: 1, executionId: fields.executionId, writtenAt, sessionPublicId: fields.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs: fields.durationMs }, (message === undefined ? {} : { message })), (stack === undefined || stack.length === 0 ? {} : { stack })), (message !== undefined && /abort/i.test(message)
-                ? { signalAborted: true }
-                : {})), (fields.abortReason === undefined
+            yield writeHostedExecutionDiag(sinks.stateRoot, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ v: 1, executionId: fields.executionId, writtenAt, sessionPublicId: fields.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs: fields.durationMs }, (message === undefined ? {} : { message })), (stack === undefined || stack.length === 0 ? {} : { stack })), { signalAborted: fields.abortReason === "signal_abort" ? true : undefined }), (fields.abortReason === undefined
                 ? {}
-                : { abortReason: fields.abortReason })));
+                : { abortReason: fields.abortReason })), { failureCode: fields.failureCode, classification: fields.classification }));
         }
         if (sinks.persistSessionRun !== undefined) {
             const error = fields.error === undefined

package/dist/internal/http-control-plane-session.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Built-in HTTP channel admission for control-plane session starts.
+ *
+ * `agent-sdk run --prod` reaches the authenticated CP start route, which
+ * delivers `agentsdk.session` to the built-in `http` channel of every v2
+ * agent. The wake is `send(message, { dryRun, asOf })`; the session id, when
+ * the caller resumed an explicit `ses_…`, arrives through the hosted
+ * execution (never through this payload), so authored code cannot pick one.
+ */
+import type { ChannelHandlerArgs, HttpChannelDefinition } from "../types.js";
+export type ControlPlaneSessionPayload = {
+    message: string;
+    dryRun?: boolean | undefined;
+    asOf?: string | undefined;
+};
+export declare function parseControlPlaneSessionPayload(payload: unknown): {
+    ok: true;
+    data: ControlPlaneSessionPayload;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function dispatchHttpControlPlaneSession(input: {
+    eventType: string;
+    payload: unknown;
+    args: ChannelHandlerArgs;
+    onMessage?: HttpChannelDefinition["onMessage"];
+}): Promise<Response>;
+export declare function attachHttpControlPlaneAdmission(definition: HttpChannelDefinition): void;
+//# sourceMappingURL=http-control-plane-session.d.ts.map

package/dist/internal/http-control-plane-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-control-plane-session.d.ts","sourceRoot":"","sources":["../../src/internal/http-control-plane-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAQ7E,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AASF,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,OAAO,GAEd;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,0BAA0B,CAAA;CAAE,GAC9C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CA6B/B;AAED,wBAAsB,+BAA+B,CAAC,KAAK,EAAE;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,CAAC,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;CAChD,GAAG,OAAO,CAAC,QAAQ,CAAC,CAiBpB;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,qBAAqB,GAChC,IAAI,CAWN"}

package/dist/internal/http-control-plane-session.js

@@ -0,0 +1,83 @@
+/**
+ * Built-in HTTP channel admission for control-plane session starts.
+ *
+ * `agent-sdk run --prod` reaches the authenticated CP start route, which
+ * delivers `agentsdk.session` to the built-in `http` channel of every v2
+ * agent. The wake is `send(message, { dryRun, asOf })`; the session id, when
+ * the caller resumed an explicit `ses_…`, arrives through the hosted
+ * execution (never through this payload), so authored code cannot pick one.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { skipped, turnStarted } from "./channel-dispatch.js";
+import { attachHostedAdmissionAdapter } from "./hosted-admission-adapter.js";
+import { AGENT_SDK_HTTP_CHANNEL_KIND, AGENT_SDK_SESSION_EVENT_TYPE, } from "./hosted-catch-protocol.js";
+const PAYLOAD_KEYS = new Set(["message", "dryRun", "asOf"]);
+const MAX_MESSAGE_CHARS = 64 * 1024;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function parseControlPlaneSessionPayload(payload) {
+    if (!isRecord(payload)) {
+        return { ok: false, error: "payload must be an object" };
+    }
+    if (Object.keys(payload).some((key) => !PAYLOAD_KEYS.has(key))) {
+        return { ok: false, error: "payload carries an unsupported field" };
+    }
+    const message = typeof payload.message === "string" ? payload.message.trim() : "";
+    if (message.length === 0 || message.length > MAX_MESSAGE_CHARS) {
+        return { ok: false, error: "payload.message is required" };
+    }
+    if (payload.dryRun !== undefined && typeof payload.dryRun !== "boolean") {
+        return { ok: false, error: "payload.dryRun must be a boolean" };
+    }
+    if (payload.asOf !== undefined &&
+        (typeof payload.asOf !== "string" || payload.asOf.trim().length === 0)) {
+        return { ok: false, error: "payload.asOf must be a non-empty string" };
+    }
+    return {
+        ok: true,
+        data: {
+            message,
+            dryRun: payload.dryRun === true ? true : undefined,
+            asOf: typeof payload.asOf === "string" ? payload.asOf.trim() : undefined,
+        },
+    };
+}
+export function dispatchHttpControlPlaneSession(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (input.eventType !== AGENT_SDK_SESSION_EVENT_TYPE) {
+            return skipped("not a control-plane session");
+        }
+        const parsed = parseControlPlaneSessionPayload(input.payload);
+        if (!parsed.ok) {
+            return Response.json({ ok: false, error: parsed.error }, { status: 400 });
+        }
+        const message = input.onMessage === undefined
+            ? parsed.data.message
+            : yield input.onMessage(parsed.data.message, { auth: null });
+        const session = yield input.args.send(message, {
+            dryRun: parsed.data.dryRun,
+            asOf: parsed.data.asOf,
+        });
+        return turnStarted(session);
+    });
+}
+export function attachHttpControlPlaneAdmission(definition) {
+    attachHostedAdmissionAdapter(definition, {
+        kind: AGENT_SDK_HTTP_CHANNEL_KIND,
+        dispatch: ({ eventType, payload, args }) => dispatchHttpControlPlaneSession({
+            eventType,
+            payload,
+            args,
+            onMessage: definition.onMessage,
+        }),
+    });
+}

package/dist/internal/legacy-command-guard.d.ts

@@ -0,0 +1,22 @@
+import { type AgentServeDeployClient, DeployApiError } from "./deploy-client.js";
+/**
+ * Classify a hosted slug by probing the v2 control plane.
+ *
+ * Only HTTP 404 means “not v2.” Auth, 5xx, and transport errors fail closed
+ * so a v2 slug cannot fall through to `/internal/agent-serve`. That probe
+ * shares the factory microlith path used by secrets; a factory outage will
+ * also block legacy `--prod` until it recovers.
+ */
+export declare function deploymentArchitecture(args: {
+    client: AgentServeDeployClient;
+    teamId: number;
+    slug: string;
+}): Promise<"v1" | "v2">;
+export declare function unsupportedV2LegacyCommandError(slug: string): DeployApiError;
+export declare function isUnsupportedV2LegacyCommandError(error: unknown): error is DeployApiError;
+export declare function rejectV2ForLegacyCommand(args: {
+    client: AgentServeDeployClient;
+    teamId: number;
+    slug: string;
+}): Promise<void>;
+//# sourceMappingURL=legacy-command-guard.d.ts.map

package/dist/internal/legacy-command-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-command-guard.d.ts","sourceRoot":"","sources":["../../src/internal/legacy-command-guard.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,sBAAsB,EAC3B,cAAc,EACf,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE;IACjD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAavB;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAK5E;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,cAAc,CAMzB;AAED,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,IAAI,CAAC,CAKhB"}