cartethyia 2.7.3 → 2.7.5

package/src/transport/dispatch/responses-compact.ts

@@ -1,11 +1,15 @@
 import { GatewayError } from "../../protocol/gateway-error";
-import { resolveCredentialForAccount } from "../../providers/operations/provider-credential-service";
 import { metrics } from "../../observability/metrics";
-import { parseThinkingSuffix } from "../../protocol/translation/thinking";
 import type { CodexCompactAdapter } from "../../providers/integrations/codex/codex";
 import { completeAttempt, estimatedUsage, nativeCompletionBase } from "./attempt-finalize";
-import { repriceUsage, usageFromProvider } from "../../providers/provider-usage";
 import { runAttemptLoop } from "./attempt-loop";
+import {
+  networkFetchContext,
+  requireRecordBody,
+  resolveAttemptCredential,
+  stripThinkingSuffix,
+  usageFromUpstreamClone,
+} from "./native-shared";
 
 /**
  * The native Codex compaction route (`POST /v1/responses/compact`) and the
@@ -13,7 +17,7 @@ import { runAttemptLoop } from "./attempt-loop";
  */
 import type { GatewayHandlerDeps } from "./handler-deps";
 
-export type ResponsesCompactHandlerDeps = GatewayHandlerDeps;
+type ResponsesCompactHandlerDeps = GatewayHandlerDeps;
 
 /**
  * Handles `POST /v1/responses/compact`: the native Codex compaction proxy. The
@@ -25,12 +29,12 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
   return async ({ request }: { request: Request }): Promise<Response> => {
     const state = deps.stateStore.require(request);
     const authorization = state.authorization;
-    const body = state.ingressBody;
-    if (!authorization || body === null || typeof body !== "object" || Array.isArray(body))
-      throw new GatewayError("invalid_request", 400, "compact request body must be a JSON object");
-    const compact = body as Record<string, unknown>;
+    const compact = requireRecordBody(
+      state,
+      "compact request body must be a JSON object (request {requestId}). Check the shape of what you sent — then resend 🪞",
+    );
     if (typeof compact.model !== "string" || compact.model.trim().length === 0)
-      throw new GatewayError("invalid_request", 400, "model is required");
+      throw new GatewayError("invalid_request", 400, "model is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
     // A thinking suffix (`model(high)`) is stripped here for the same reason the
     // canonical preparer strips it: this route matches the model name against
     // the allowlist and the route plan, and `(high)` is not part of any
@@ -39,25 +43,23 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
     // reasoning effort to shape, and the body is passed upstream verbatim.
     // Stripping keeps a client that appends the suffix to every request working
     // here instead of failing with a misleading model-not-found.
-    const { model: compactModel } = parseThinkingSuffix(compact.model);
-    const compactBody: Record<string, unknown> =
-      compactModel === compact.model ? compact : { ...compact, model: compactModel };
+    const { bareModel: compactModel, body: compactBody } = stripThinkingSuffix(compact.model, compact);
     if (!(typeof compact.input === "string" || Array.isArray(compact.input)))
-      throw new GatewayError("invalid_request", 400, "input must be a string or array");
+      throw new GatewayError("invalid_request", 400, "input must be a string or array (request {requestId}). Check the shape of what you sent — then resend 🪞");
     if ("instructions" in compact && typeof compact.instructions !== "string")
-      throw new GatewayError("invalid_request", 400, "instructions must be a string");
+      throw new GatewayError("invalid_request", 400, "instructions must be a string (request {requestId}). Check the shape of what you sent — then resend 🪞");
     if (compact.stream === true)
       throw new GatewayError(
         "capability_unsupported",
         400,
-        "Responses compact does not support streaming",
+        "Responses compact does not support streaming (request {requestId}). Know your tools — this one just isn't in the box 🧰",
       );
     const adapter = (await deps.resolveProviderAdapter?.("codex")) as CodexCompactAdapter | undefined;
     if (!adapter || typeof adapter.compact !== "function")
-      throw new GatewayError("admission_unavailable", 503, "Codex compact transport unavailable");
+      throw new GatewayError("admission_unavailable", 503, "Codex compact transport unavailable (request {requestId}). The bouncer stepped out — come back shortly 🚪");
     const prepared = await deps.proxyPreparer.prepareNativeCompact({
       model: compactModel,
-      authorization,
+      authorization: authorization!,
       signal: state.abortController.signal,
       ...(state.clientUserAgent === undefined ? {} : { clientUserAgent: state.clientUserAgent }),
     });
@@ -77,30 +79,26 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
       // Lenient pool semantics: a missing slot tolerates direct egress.
       strictPoolSelection: false,
       exhaustedError: new GatewayError(
-        "admission_unavailable",
+        "route_unavailable",
         503,
-        "no eligible Codex route",
+        "no eligible Codex route (request {requestId}). The bouncer stepped out — come back shortly 🚪",
       ),
       prepare: async (candidate) => {
         if (!candidate.provider_account_id)
           throw new GatewayError(
-            "admission_unavailable",
+            "route_unavailable",
             503,
-            "Codex compact requires an OAuth account",
+            "Codex compact requires an OAuth account (request {requestId}). Wrong key, right door — check the credential 🔑",
           );
-        const credential = await resolveCredentialForAccount(
-          deps.db,
-          "codex",
-          candidate.provider_account_id,
-          deps.oauthRefreshService && deps.resolveOAuthRefresher
-            ? { refreshService: deps.oauthRefreshService, resolveRefresher: deps.resolveOAuthRefresher }
-            : undefined,
-        );
+        const credential = await resolveAttemptCredential(deps, {
+          ...candidate,
+          provider_id: "codex",
+        });
         if (credential.credential_kind !== "oauth")
           throw new GatewayError(
             "capability_unsupported",
             400,
-            "Responses compact requires a Codex ChatGPT OAuth account",
+            "Responses compact requires a Codex ChatGPT OAuth account (request {requestId}). Wrong key, right door — check the credential 🔑",
           );
         return { credential, adapter };
       },
@@ -110,36 +108,17 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
           credential,
           deadline: state.deadlineMs,
           abort_signal: state.abortController.signal,
-          ...(deps.networkBindingFactory
-            ? {
-                outbound_fetch: deps.networkBindingFactory.fetch(
-                  leases.proxySlot?.poolId,
-                  authorization.tenantId,
-                ),
-              }
-            : {}),
+          ...networkFetchContext(deps, leases.proxySlot?.poolId, authorization!.tenantId),
         });
         // Prefer the usage the compaction endpoint actually reported. The
         // estimate is a fixed 1024+1024 reserve, and compaction is by
         // construction a large-input operation, so charging it unconditionally
-        // let real spend run far past the counter. `usageFromProvider` returns
-        // undefined when the body reported nothing, which keeps the estimate as
-        // the fallback. `response.clone()` leaves the body readable for the
-        // client.
-        let reportedUsage: ReturnType<typeof usageFromProvider>;
-        try {
-          const parsed: unknown = await response.clone().json();
-          reportedUsage = usageFromProvider(
-            typeof parsed === "object" && parsed !== null
-              ? (parsed as Record<string, unknown>)["usage"]
-              : undefined,
-          );
-        } catch {
-          reportedUsage = undefined;
-        }
-        const usage = repriceUsage(
-          reportedUsage ??
-            estimatedUsage(prepared.estimatedInputTokens, prepared.estimatedOutputTokens),
+        // let real spend run far past the counter. `usageFromUpstreamClone`
+        // falls back to the estimate when the body reported nothing, and
+        // `response.clone()` leaves the body readable for the client.
+        const usage = await usageFromUpstreamClone(
+          response,
+          estimatedUsage(prepared.estimatedInputTokens, prepared.estimatedOutputTokens),
           candidate.provider_id,
           candidate.model_id,
         );

package/src/transport/dispatch/retry-policy.ts

@@ -8,9 +8,12 @@
  * than inside it so the loop stays a policy *consumer* — one place decides
  * retryability (`../failure-policy.ts`), one place decides refresh and
  * cooldown eligibility (here).
+ *
+ * The egress-scoped half of the rate-limit decision lives in
+ * `../../network/rate-limit-verdict`; this module keeps only the credential-
+ * scoped predicates.
  */
 import { GatewayError } from "../../protocol/gateway-error";
-import { providerRateLimitIsIpScoped } from "../../providers/provider-metadata";
 
 /**
  * Returns true only when an upstream failure is evidence that the OAuth
@@ -32,69 +35,3 @@ export function isOAuthCredentialInvalidated(error: unknown): error is GatewayEr
   if (/web[ _-]?search|web[ _-]?fetch|x[ _-]?search|tool invocation|search backend/i.test(message)) return false;
   return error.details.credentialEvidence === true;
 }
-
-/**
- * A free-tier IP refusal: the upstream has flagged this egress address, not
- * this request.
- *
- * OpenCode answers a blocked address with `403` and its own
- * `FreeTierError`/`ModelDeprecated`-style body. The request was never read, so
- * retrying it — with the same tools, the same headers, or the same credential —
- * cannot succeed from the same address. Only a different egress can.
- *
- * This is deliberately narrower than "any 403": a content-policy rejection or a
- * licence refusal is also a 403 and must not retire a healthy proxy. The
- * provider must also declare `ipScopedRateLimit`, which is the same fact the
- * 429 path already relies on.
- */
-export function isFreeTierIpBlock(error: unknown, providerId: string): error is GatewayError {
-  if (!(error instanceof GatewayError) || error.origin !== "upstream" || error.status !== 403) {
-    return false;
-  }
-  if (!providerRateLimitIsIpScoped(providerId)) return false;
-  const providerCode = typeof error.details.providerCode === "string" ? error.details.providerCode : "";
-  const raw = String(error.details.raw ?? "");
-  return (
-    /freetier|free.?tier/i.test(providerCode) ||
-    /FreeTierError|free tier can only be used/i.test(`${error.message} ${raw}`)
-  );
-}
-
-/**
- * A provider-scoped 429, on a provider whose limits follow the egress address.
- *
- * Only then is the pool the thing that ran out: the upstream counted requests
- * from this address, so the next attempt must leave by a different one and
- * cooling this pool is the fix. `providerRateLimitIsIpScoped` holds that fact
- * per provider (see the metadata field) rather than inferring it from the
- * response — a 429 states which bucket was exhausted only in the provider's own
- * wording, and every account-keyed provider words it the same way.
- *
- * For an account-keyed provider the 429 belongs to the credential that was
- * dialed. The account health machine already records it and routes the next
- * request to a sibling, so cooling the pool as well only removed healthy
- * accounts from service: every account sharing that egress lost its route for
- * the cooldown window because one of them hit its own limit. A bare 429 with no
- * provider scope stays a request-level limit and never cools the pool.
- *
- * `providerId` is the caller's own candidate, not a field read off the error:
- * the in-stream error frames the protocol modules build carry no `providerId`
- * detail, so reading it from `details` would silently disable the IP-scoped
- * rule on exactly the streaming path it exists for.
- *
- * A type guard on `GatewayError`, so a caller that passes this check can hand
- * the same value to `flagPoolCooldown` without a second narrowing step.
- */
-export function shouldCooldownPool(error: unknown, providerId: string): error is GatewayError {
-  if (
-    !(
-      error instanceof GatewayError &&
-      error.origin === "upstream" &&
-      error.status === 429 &&
-      error.details.rateLimitScope === "provider"
-    )
-  ) {
-    return false;
-  }
-  return providerRateLimitIsIpScoped(providerId);
-}

package/src/transport/dispatch/stream-bridge.ts

@@ -60,7 +60,7 @@ export function createDispatchStreamEncoder(
   throw new GatewayError(
     "capability_unsupported",
     400,
-    `Unknown surface: ${surface}`,
+    `Unknown surface: ${surface} (request {requestId}). Know your tools — this one just isn't in the box 🧰`,
     { surface },
   );
 }

package/src/transport/dispatch/streaming/encoder.ts

@@ -12,12 +12,12 @@
 import type { CanonicalEvent, SourceSurface, UsageRecord } from "../../../protocol/canonical-model";
 import { canonicalTerminal } from "../../../protocol/codecs";
 import { reasoningTextOf } from "../../../protocol/reasoning-text";
-import { MimoThinkSplitter } from "../../../providers/integrations/xiaomi-mimo/think-stream";
+import { ThinkSplitter } from "../../../protocol/think-split";
 import { createDispatchStreamEncoder, type DispatchStreamEncoder } from "../stream-bridge";
 import { THINKING_LOOP_MARKER, ThinkingLoopDetector } from "./thinking-loop";
 
 /** The terminal event shape every stream settles (or fails to settle) on. */
-export type StreamTerminalEvent = Extract<CanonicalEvent, { type: "terminal" }>;
+type StreamTerminalEvent = Extract<CanonicalEvent, { type: "terminal" }>;
 
 /**
  * SSE comment frame: valid framing on every streamed surface, ignored by
@@ -46,7 +46,7 @@ interface TruncatedEventTranscript {
 }
 
 /** Error-frame input in the shape the dispatch stream encoder accepts. */
-export type StreamErrorFrameInput = Parameters<DispatchStreamEncoder["encodeError"]>[0];
+type StreamErrorFrameInput = Parameters<DispatchStreamEncoder["encodeError"]>[0];
 
 /**
  * Per-event state and framing for one stream. Client framing and protocol
@@ -93,10 +93,11 @@ export class StreamEventPipeline {
    */
   private readonly diagnosticsCaptureMode: "none" | "metadata" | "full";
   private readonly streamEncoder: DispatchStreamEncoder;
-  // One splitter per stream: a thinking tag can straddle two provider chunks,
-  // and the text/idle bookkeeping below must see the split result, not the raw
-  // tagged chunk.
-  private readonly thinkSplitter = new MimoThinkSplitter();
+  // One splitter per stream, kept purely as a feeder for the loop guard: it
+  // reports the content currently inside an open `<think>` span so a runaway
+  // chain-of-thought is caught even when the provider wrote it into the text
+  // stream. It never re-routes the emitted events — text is forwarded verbatim.
+  private readonly thinkSplitter = new ThinkSplitter();
   /**
    * Content-level loop guard. A model that degenerates into a repeated
    * chain-of-thought keeps sending bytes, so the stall timeout — which fires
@@ -259,26 +260,17 @@ export class StreamEventPipeline {
     // `loopDetected`, so this only matters for an event already in flight;
     // dropping it is the alternative to throwing mid-stream.
     if (this.loopDetector.detected) return false;
-    // The one place every surface shares. A provider that writes its reasoning
-    // into the answer as `<think>…</think>` had that text forwarded verbatim:
-    // the chat wire happened to split it in its own decoder, so chat looked
-    // right while messages and responses — and any other provider wire whose
-    // text carries the tags — showed the raw reasoning as the answer.
+    // Text is forwarded verbatim: inline thinking tags are a per-provider
+    // decoder concern, not a universal one. Splitting them here for every
+    // surface misclassified literal `<think>` in an answer as reasoning — the
+    // answer vanished into the thinking pane and the poisoned history stopped
+    // follow-up turns. The loop guard still watches reasoning a provider puts
+    // inside an open `<think>` span, without reclassifying the answer.
     if (event.type === "content_delta" && event.content.kind === "text") {
+      const enqueued = this.enqueueOne(event, controller);
       const split = this.thinkSplitter.push(event.content.text);
-      let enqueued = false;
-      if (split.reasoning.length > 0) {
-        const reasoningEvent: CanonicalEvent = {
-          ...event,
-          content: { kind: "reasoning", payload: null, summary: split.reasoning },
-        };
-        enqueued = this.enqueueOne(reasoningEvent, controller) || enqueued;
-        if (this.guardReasoning(split.reasoning, controller)) return enqueued;
-      }
-      if (split.text.length > 0) {
-        enqueued =
-          this.enqueueOne({ ...event, content: { kind: "text", text: split.text } }, controller) ||
-          enqueued;
+      if (split.pendingReasoning.length > 0) {
+        if (this.guardReasoning(split.pendingReasoning, controller)) return true;
       }
       return enqueued;
     }
@@ -290,31 +282,8 @@ export class StreamEventPipeline {
       this.guardReasoning(reasoningTextOf(event.content) ?? "", controller);
       return enqueued;
     }
-    // Text held back for a tag that never completed must be released *before*
-    // the terminal: a content event after it is rejected by the surface
-    // encoders, and the tail of the answer would be lost instead.
     if (event.type === "terminal") {
-      const rest = this.thinkSplitter.flush();
-      if (rest.reasoning.length > 0) {
-        this.enqueueOne(
-          {
-            type: "content_delta",
-            sequence_number: event.sequence_number,
-            content: { kind: "reasoning", payload: null, summary: rest.reasoning },
-          },
-          controller,
-        );
-      }
-      if (rest.text.length > 0) {
-        this.enqueueOne(
-          {
-            type: "content_delta",
-            sequence_number: event.sequence_number,
-            content: { kind: "text", text: rest.text },
-          },
-          controller,
-        );
-      }
+      return this.enqueueOne(event, controller);
     }
     return this.enqueueOne(event, controller);
   }
@@ -335,29 +304,6 @@ export class StreamEventPipeline {
   ): boolean {
     const reason = text.length > 0 ? this.loopDetector.push(text) : undefined;
     if (reason === undefined) return false;
-    // Flush before the terminal: content after it is rejected by the surface
-    // encoders, and the held-back text would be lost.
-    const rest = this.thinkSplitter.flush();
-    if (rest.reasoning.length > 0) {
-      this.enqueueOne(
-        {
-          type: "content_delta",
-          sequence_number: this.lastSequenceNumber + 1,
-          content: { kind: "reasoning", payload: null, summary: rest.reasoning },
-        },
-        controller,
-      );
-    }
-    if (rest.text.length > 0) {
-      this.enqueueOne(
-        {
-          type: "content_delta",
-          sequence_number: this.lastSequenceNumber + 1,
-          content: { kind: "text", text: rest.text },
-        },
-        controller,
-      );
-    }
     this.enqueueOne(
       canonicalTerminal({
         sequenceNumber: this.lastSequenceNumber + 1,

package/src/transport/dispatch/streaming/finalize.ts

@@ -24,7 +24,7 @@ import type { Reservation } from "../../routing/route-model";
 import { repriceUsage } from "../../../providers/provider-usage";
 import { metrics } from "../../../observability/metrics";
 import { flagPoolBlocked, flagPoolCooldown } from "../../../network/pool-health";
-import { isFreeTierIpBlock, shouldCooldownPool } from "../retry-policy";
+import { classifyEgressFailure } from "../../../network/rate-limit-verdict";
 import { releaseAttemptLeases } from "../leases";
 import type { AttemptLeaseOwnership } from "../leases";
 import { finalizeRequestTelemetry } from "../../guards/error-lifecycle";
@@ -39,7 +39,7 @@ import {
 import { KEEPALIVE_COMMENT_BYTES, type StreamEventPipeline } from "./encoder";
 
 /** Collaborators the stream tail reads from the dispatch handler. */
-export interface StreamFinalizeDeps {
+interface StreamFinalizeDeps {
   readonly db: CartethyiaDatabase;
   readonly poolSelector?: NetworkPoolSelector | undefined;
   readonly telemetryBuffer?: TelemetryBatchBuffer | undefined;
@@ -56,7 +56,7 @@ export interface StreamCandidateIdentity {
 }
 
 /** What the stream tail needs from the attempt's input. */
-export interface StreamFinalizeInput {
+interface StreamFinalizeInput {
   readonly state: ProxyRequestState;
   readonly deps: StreamFinalizeDeps;
   readonly prepared: PreparedProxyRequest;
@@ -186,7 +186,7 @@ export class StreamFinalizer {
       // origin is the upstream's: labelling it `cartethyia` reported a
       // provider that stopped sending as a gateway defect.
       this.input.state.abortController.abort(
-        new GatewayError("deadline_exceeded", 504, "The upstream stopped sending data mid-stream. Retry; if it keeps happening, the account or pool is unstable.", {}, "upstream"),
+        new GatewayError("deadline_exceeded", 504, "The upstream stopped sending data mid-stream (request {requestId}). Retry; if it keeps happening, the account or pool is unstable. The connection ghosted us — come back in a moment 👻", {}, "upstream"),
       );
     }, timeoutMs);
   }
@@ -363,7 +363,7 @@ export class StreamFinalizer {
     if (drain) return drain;
     if (reason instanceof GatewayError && reason.code === "deadline_exceeded") return reason;
     if (reason instanceof DOMException && reason.name === "TimeoutError")
-      return new GatewayError("deadline_exceeded", 504, "request deadline exceeded", {}, "cartethyia");
+      return new GatewayError("deadline_exceeded", 504, "request deadline exceeded (request {requestId}). Some things just take longer 🐢", {}, "cartethyia");
     return undefined;
   }
 
@@ -453,7 +453,7 @@ export class StreamFinalizer {
         ? new GatewayError(
             "transport_unavailable",
             502,
-            "The upstream closed the stream before it reported a final result. Retry; if it keeps happening, the account or pool is unstable.",
+            "The upstream closed the stream before it reported a final result (request {requestId}). Retry; if it keeps happening, the account or pool is unstable. The connection ghosted us — come back in a moment 👻",
             {},
             "upstream",
           )
@@ -531,7 +531,7 @@ export class StreamFinalizer {
           ? new GatewayError(
               "deadline_exceeded",
               504,
-              "request deadline exceeded",
+              "request deadline exceeded (request {requestId}). Some things just take longer 🐢",
               {},
               "cartethyia",
             )
@@ -579,10 +579,11 @@ export class StreamFinalizer {
       ...(pipeline.clientResponseText.length > 0 ? { clientResponseText: pipeline.clientResponseText } : {}),
     });
     this.streamSettled = true;
-    if (candidate.networkPoolId && !cancelled && deps.poolSelector) {
-      if (shouldCooldownPool(err, candidate.providerId)) {
+    if (candidate.networkPoolId && !cancelled && deps.poolSelector && err instanceof GatewayError) {
+      const egressVerdict = classifyEgressFailure(err, candidate.providerId);
+      if (egressVerdict.kind === "cooldown") {
         flagPoolCooldown(deps.poolSelector, deps.db, candidate.networkPoolId, candidate.providerId, err);
-      } else if (isFreeTierIpBlock(err, candidate.providerId)) {
+      } else if (egressVerdict.kind === "blocked") {
         flagPoolBlocked(deps.poolSelector, deps.db, candidate.networkPoolId, candidate.providerId, err);
       }
     }

package/src/transport/dispatch/streaming/stream.ts

@@ -64,7 +64,7 @@ import { StreamEventPipeline } from "./encoder";
 import { StreamFinalizer, type StreamCandidateIdentity } from "./finalize";
 
 /** Collaborators the streaming branch reads from the dispatch handler. */
-export interface StreamingDispatchDeps {
+interface StreamingDispatchDeps {
   readonly db: CartethyiaDatabase;
   readonly networkBindingFactory?: ValidatedNetworkBindingFactory | undefined;
   readonly poolSelector?: NetworkPoolSelector | undefined;
@@ -73,7 +73,7 @@ export interface StreamingDispatchDeps {
 }
 
 /** Everything one streamed attempt needs, all resolved by its caller. */
-export interface StreamingDispatchInput {
+interface StreamingDispatchInput {
   readonly state: ProxyRequestState;
   readonly deps: StreamingDispatchDeps;
   readonly prepared: PreparedProxyRequest;
@@ -228,7 +228,11 @@ export async function dispatchStreamingAttempt(input: StreamingDispatchInput): P
       if (!isWrappedInjectionProvider(candidate.provider_id)) return {};
       const text = resolveTenantSystemPrompt(
         await readTenantSystemPromptsForDispatch(deps.db, prepared.authorization.snapshot.tenant_id),
-        { providerId: candidate.provider_id, modelId: candidate.model_id },
+        {
+          providerId: candidate.provider_id,
+          modelId: candidate.model_id,
+          requestedModel: prepared.plan?.requested_model ?? candidate.model_id,
+        },
       )?.text;
       return text === undefined ? {} : { tenantSystemPrompt: text };
     })()),

package/src/transport/dispatch/streaming/thinking-loop.ts

@@ -70,7 +70,7 @@ const SEGMENT_MIN_CLUSTER = 4;
  *  would hide every later prose paragraph from the heuristics. */
 const CODE_LINE = /^(?:[ \t]*```.*|(?: {2,}|\t)(?![ \t]*(?:[-*+]|\d+[.)])[ \t]).*|.*[{}[\](;,>][ \t]*)$/gm;
 
-export interface ThinkingLoopConfig {
+interface ThinkingLoopConfig {
   readonly enabled?: boolean;
 }