flavor-code 1.4.0-beta.8 → 1.4.1-beta.1

package/dist/{chunk-EXOSMO57.js → chunk-7YFHRORG.js}

@@ -38,9 +38,8 @@ var ProviderConfigSchema = z.object({
   // parameter. Provider thinking deltas are forwarded whenever they arrive.
   thinkingBudget: z.number().int().min(0).optional(),
   // Reasoning effort requested from the OpenAI Responses protocol (sent as
-  // reasoning.effort). Omitted by default so strict compatible gateways never
-  // see an unknown parameter and the endpoint uses its server-side default.
-  thinkingEffort: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
+  // reasoning.effort). The adapter defaults an omitted value to high.
+  thinkingEffort: z.enum(["minimal", "low", "medium", "high", "xhigh", "ultra"]).optional(),
   // Send the Claude Code client fingerprint (User-Agent/x-app) with Anthropic requests,
   // for gateways that restrict the Anthropic protocol to Claude clients.
   claudeClient: z.boolean().optional(),

package/dist/{chunk-EUKT7HEU.js → chunk-FAORPP4F.js}

@@ -4,7 +4,7 @@ import {
   message,
   redactErrorText,
   redactSecrets
-} from "./chunk-LLC7WBXP.js";
+} from "./chunk-O2PC44GY.js";
 
 // src/rpc/server.ts
 import { createInterface } from "readline";

package/dist/{chunk-LLC7WBXP.js → chunk-O2PC44GY.js}

@@ -23,7 +23,7 @@ import {
   redactConfig,
   setProjectMcpServerDisabled,
   updateProtectedFile
-} from "./chunk-EXOSMO57.js";
+} from "./chunk-7YFHRORG.js";
 import {
   AuditLogger,
   appendUsageLog,
@@ -66,10 +66,12 @@ function normalizeProviderError(error) {
     code = "authentication";
   } else if (status === 429 || /rate.?limit|overloaded/.test(searchable)) {
     code = "rate_limit";
-  } else if (/context|too many tokens|prompt.*long/.test(searchable)) {
+  } else if (/context[_\s-]?(?:length|window|overflow)(?:[_\s-]?(?:exceeded|limit))?/.test(searchable) || /maximum context length|too many tokens|prompt.*(?:too )?long/.test(searchable)) {
     code = "context_overflow";
   } else if (status === 404 || /model.*not.?found|not.?found.*model/.test(searchable)) {
     code = "model_not_found";
+  } else if (status === 400 || status === 422 || /invalid schema|schema.*(?:invalid|not (?:a )?valid)/.test(searchable)) {
+    code = "invalid_request";
   } else if (status !== void 0 && status >= 500 && status <= 599) {
     code = "network";
   } else if (status === void 0 && /econn|enet|socket|network|fetch failed|connection|timeout/.test(searchable)) {
@@ -1012,10 +1014,11 @@ async function createExampleFlavorConfig(cwd) {
       pkce: {
         type: "oauth-callback",
         apiType: "anthropic",
-        authorizationUrl: "http://192.168.1.100:8091/authorize",
-        tokenUrl: "http://192.168.1.100:8091/token",
+        authorizationUrl: "http://127.0.0.1:8091/authorize",
+        tokenUrl: "http://127.0.0.1:8091/token",
         clientId: "flavor-code-cli",
-        scope: "models:read models:use"
+        scope: "models:read models:use",
+        thinkingEffort: "high"
       }
     },
     agents: {
@@ -8651,7 +8654,10 @@ function jsonSchemaFromZod(schema) {
   return z11.toJSONSchema(schema);
 }
 function strictJsonSchemaObject(schema) {
-  return ensureStrictSchema(schema);
+  return normalizeOpenAIJsonSchemaObject(schema, true);
+}
+function openAIJsonSchemaObject(schema, strict) {
+  return normalizeOpenAIJsonSchemaObject(schema, strict);
 }
 function extractJsonObject(text) {
   const trimmed = text.trim();
@@ -8789,40 +8795,194 @@ function jsonSchemaAllowsNull(schema) {
 function modelToolFromZod(name, description, schema) {
   return { name, description, inputSchema: strictJsonSchema(schema) };
 }
-function ensureStrictSchema(schema) {
+var JSON_SCHEMA_TYPES = /* @__PURE__ */ new Set(["null", "boolean", "object", "array", "number", "string", "integer"]);
+var OPENAI_UNSUPPORTED_SCHEMA_KEYWORDS = [
+  "$schema",
+  "$id",
+  "$anchor",
+  "$dynamicAnchor",
+  "$dynamicRef",
+  "$comment",
+  "default",
+  "examples",
+  "example",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  "format",
+  "propertyNames",
+  "patternProperties",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "additionalItems",
+  "contains",
+  "minContains",
+  "maxContains",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties",
+  "contentEncoding",
+  "contentMediaType",
+  "not",
+  "if",
+  "then",
+  "else",
+  "dependentRequired",
+  "dependentSchemas",
+  "dependencies"
+];
+function normalizeOpenAIJsonSchemaObject(schema, strict) {
+  const normalized = normalizeOpenAIJsonSchemaNode(schema, strict);
+  if (normalized.type === "object") return normalized;
+  return strict ? { type: "object", properties: {}, required: [], additionalProperties: false } : { type: "object", properties: {}, additionalProperties: true };
+}
+function normalizeOpenAIJsonSchemaNode(rawSchema, strict) {
+  const schema = mergeObjectAllOf(rawSchema);
   const output = { ...schema };
-  delete output.propertyNames;
-  delete output.patternProperties;
-  for (const keyword of ["anyOf", "oneOf", "allOf", "prefixItems"]) {
-    const branches = schema[keyword];
-    if (Array.isArray(branches)) {
-      output[keyword] = branches.map((branch) => typeof branch === "object" && branch !== null ? ensureStrictSchema(branch) : branch);
-    }
-  }
-  if (typeof schema.items === "object" && schema.items !== null) {
-    output.items = ensureStrictSchema(schema.items);
+  for (const keyword of OPENAI_UNSUPPORTED_SCHEMA_KEYWORDS) delete output[keyword];
+  delete output.oneOf;
+  delete output.allOf;
+  delete output.prefixItems;
+  delete output.nullable;
+  delete output.definitions;
+  if (typeof output.$ref === "string" && output.$ref.startsWith("#/definitions/")) {
+    output.$ref = output.$ref.replace("#/definitions/", "#/$defs/");
+  }
+  const compositionBranches = [
+    ...Array.isArray(schema.anyOf) ? schema.anyOf : [],
+    ...Array.isArray(schema.oneOf) ? schema.oneOf : [],
+    ...Array.isArray(schema.allOf) ? schema.allOf : []
+  ];
+  if (compositionBranches.length > 0) {
+    output.anyOf = compositionBranches.map((branch) => normalizeOpenAISchemaValue(branch, strict));
+  } else {
+    delete output.anyOf;
   }
-  for (const keyword of ["$defs", "definitions"]) {
-    const definitions = schema[keyword];
-    if (typeof definitions === "object" && definitions !== null && !Array.isArray(definitions)) {
-      output[keyword] = Object.fromEntries(Object.entries(definitions).map(([key, definition]) => [
-        key,
-        typeof definition === "object" && definition !== null ? ensureStrictSchema(definition) : definition
-      ]));
+  const definitions = {
+    ...isSchemaRecord(schema.definitions) ? schema.definitions : {},
+    ...isSchemaRecord(schema.$defs) ? schema.$defs : {}
+  };
+  if (Object.keys(definitions).length > 0) {
+    output.$defs = Object.fromEntries(Object.entries(definitions).map(([key, definition]) => [key, normalizeOpenAISchemaValue(definition, strict)]));
+  }
+  const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+  if (prefixItems !== void 0 && prefixItems.length > 0) {
+    const tupleItems = prefixItems.map((item) => normalizeOpenAISchemaValue(item, strict));
+    output.items = tupleItems.length === 1 ? tupleItems[0] : { anyOf: tupleItems };
+  } else if (Array.isArray(schema.items)) {
+    const tupleItems = schema.items.map((item) => normalizeOpenAISchemaValue(item, strict));
+    output.items = tupleItems.length === 1 ? tupleItems[0] : { anyOf: tupleItems };
+  } else if (isSchemaRecord(schema.items)) {
+    output.items = normalizeOpenAIJsonSchemaNode(schema.items, strict);
+  } else if (schema.items === true || schema.items === false) {
+    output.items = universalJsonValueSchema(strict);
+  }
+  let type = schema.type;
+  if (type === void 0 && isSchemaRecord(schema.properties)) type = "object";
+  if (type === void 0 && output.items !== void 0) type = "array";
+  if (type === void 0 && Array.isArray(schema.enum)) type = inferJsonTypes(schema.enum);
+  if (type === void 0 && Object.hasOwn(schema, "const")) type = inferJsonTypes([schema.const]);
+  if (typeof type === "string" && !JSON_SCHEMA_TYPES.has(type)) type = void 0;
+  if (Array.isArray(type)) {
+    const types = type.filter((candidate) => typeof candidate === "string" && JSON_SCHEMA_TYPES.has(candidate));
+    type = types.length === 0 ? void 0 : types;
+  }
+  delete output.type;
+  if (type !== void 0) output.type = type;
+  if (schemaTypeIncludes(type, "array") && output.items === void 0) {
+    output.items = universalJsonValueSchema(strict);
+  }
+  if (schemaTypeIncludes(type, "object")) {
+    const sourceProperties = isSchemaRecord(schema.properties) ? schema.properties : {};
+    const sourceRequired = new Set(Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === "string") : []);
+    const properties = {};
+    for (const [key, value] of Object.entries(sourceProperties)) {
+      const child = normalizeOpenAISchemaValue(value, strict);
+      if (!strict || sourceRequired.has(key) || jsonSchemaAllowsNull(child)) properties[key] = child;
+      else properties[key] = { anyOf: [child, { type: "null" }] };
+      if (strict) sourceRequired.add(key);
+    }
+    output.properties = properties;
+    const required2 = strict ? Object.keys(properties) : [...sourceRequired].filter((key) => Object.hasOwn(properties, key));
+    if (strict || required2.length > 0 || Array.isArray(schema.required)) output.required = required2;
+    else delete output.required;
+    if (strict) {
+      output.additionalProperties = false;
+    } else if (schema.additionalProperties === true || schema.additionalProperties === false) {
+      output.additionalProperties = schema.additionalProperties;
+    } else if (isSchemaRecord(schema.additionalProperties)) {
+      output.additionalProperties = Object.keys(schema.additionalProperties).length === 0 ? true : normalizeOpenAIJsonSchemaNode(schema.additionalProperties, false);
+    } else {
+      delete output.additionalProperties;
     }
   }
-  if (schema.type !== "object" || typeof schema.properties !== "object" || schema.properties === null) {
-    return output;
+  if (schema.nullable === true && !jsonSchemaAllowsNull(output)) {
+    const description = typeof output.description === "string" ? output.description : void 0;
+    const branch = { ...output };
+    delete branch.description;
+    return {
+      ...description === void 0 ? {} : { description },
+      anyOf: [branch, { type: "null" }]
+    };
   }
-  const requiredSet = new Set(Array.isArray(schema.required) ? schema.required : []);
-  const properties = {};
-  for (const [key, value] of Object.entries(schema.properties)) {
-    const child = typeof value === "object" && value !== null ? ensureStrictSchema(value) : value;
-    if (requiredSet.has(key) || jsonSchemaAllowsNull(child)) properties[key] = child;
-    else properties[key] = { anyOf: [child, { type: "null" }] };
-    requiredSet.add(key);
+  if (isTypedOrComposedSchema(output)) return output;
+  return universalJsonValueSchema(strict);
+}
+function mergeObjectAllOf(schema) {
+  const branches = Array.isArray(schema.allOf) ? schema.allOf.filter(isSchemaRecord) : [];
+  if (branches.length === 0 || !branches.every(isObjectSchema)) return schema;
+  const base = { ...schema };
+  delete base.allOf;
+  const properties = isSchemaRecord(base.properties) ? { ...base.properties } : {};
+  const required2 = new Set(Array.isArray(base.required) ? base.required.filter((key) => typeof key === "string") : []);
+  for (const branch of branches) {
+    if (isSchemaRecord(branch.properties)) {
+      for (const [key, value] of Object.entries(branch.properties)) {
+        const existing = properties[key];
+        properties[key] = existing === void 0 ? value : { anyOf: [existing, value] };
+      }
+    }
+    if (Array.isArray(branch.required)) {
+      for (const key of branch.required) if (typeof key === "string") required2.add(key);
+    }
   }
-  return { ...output, additionalProperties: false, required: [...requiredSet], properties };
+  return { ...base, type: "object", properties, required: [...required2] };
+}
+function normalizeOpenAISchemaValue(value, strict) {
+  if (isSchemaRecord(value)) return normalizeOpenAIJsonSchemaNode(value, strict);
+  return universalJsonValueSchema(strict);
+}
+function universalJsonValueSchema(strict) {
+  const scalar = [{ type: "string" }, { type: "number" }, { type: "boolean" }, { type: "null" }];
+  return {
+    anyOf: [
+      ...scalar,
+      strict ? { type: "object", properties: {}, required: [], additionalProperties: false } : { type: "object", properties: {}, additionalProperties: true },
+      { type: "array", items: { anyOf: scalar } }
+    ]
+  };
+}
+function inferJsonTypes(values) {
+  const types = [...new Set(values.map((value) => {
+    if (value === null) return "null";
+    if (Array.isArray(value)) return "array";
+    if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+    if (typeof value === "object") return "object";
+    return typeof value;
+  }).filter((type) => ["null", "array", "object", "integer", "number", "string", "boolean"].includes(type)))];
+  return types.length === 0 ? void 0 : types.length === 1 ? types[0] : types;
+}
+function isSchemaRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isObjectSchema(schema) {
+  return schema.type === "object" || isSchemaRecord(schema.properties);
+}
+function isTypedOrComposedSchema(schema) {
+  return typeof schema.type === "string" || Array.isArray(schema.type) || typeof schema.$ref === "string" || Array.isArray(schema.anyOf);
+}
+function schemaTypeIncludes(type, expected) {
+  return type === expected || Array.isArray(type) && type.includes(expected);
 }
 function repairMessages(messages, tool, original, candidate, error) {
   const details = [
@@ -9781,9 +9941,11 @@ var ToolRuntime = class {
       if (pre.decision === "deny") {
         return this.#fail(toolCallId, tool.name, input, context.agent, "hook_denied", pre.reason ?? "Tool use denied by hook");
       }
+      const approvalInput = tool.permissionInput?.(input) ?? input;
       const request = {
         agent: context.agent,
         tool: tool.name,
+        input: approvalInput,
         ...tool.permissions?.(input) ?? { paths: tool.paths(input) },
         ...tool.readOnly === true ? { readOnly: true } : {}
       };
@@ -9816,7 +9978,7 @@ var ToolRuntime = class {
           payload: {
             toolCallId,
             tool: tool.name,
-            input: tool.permissionInput?.(input) ?? input,
+            input: approvalInput,
             agent: context.agent,
             reason,
             toolCategory: getToolCategory(tool.name),
@@ -13090,7 +13252,7 @@ ${evidence.summary}`;
   }
 };
 function isResumableWorkerError(error) {
-  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "cancelled" && error.code !== "memory_pressure";
+  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "invalid_request" && error.code !== "cancelled" && error.code !== "memory_pressure";
 }
 function countTrailingFailureSignature(cycles, signature) {
   let count = 0;
@@ -13804,10 +13966,10 @@ function resumeStartRound(state) {
   return state.verifyRounds >= state.workerRounds ? state.workerRounds + 1 : Math.max(state.workerRounds, 1);
 }
 function isResumableWorkerError2(error) {
-  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "cancelled" && error.code !== "memory_pressure";
+  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "invalid_request" && error.code !== "cancelled" && error.code !== "memory_pressure";
 }
 function isResumableStageError(error) {
-  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "cancelled" && error.code !== "memory_pressure";
+  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "invalid_request" && error.code !== "cancelled" && error.code !== "memory_pressure";
 }
 function stageRetryDelay(options, attempt) {
   const delayMs = options.stageRetryDelayMs?.(attempt) ?? Math.min(6e4, 1e3 * 2 ** Math.min(attempt - 1, 6));
@@ -14804,6 +14966,7 @@ function resolveCacheProfile(input) {
 // src/models/openai.ts
 import OpenAI from "openai";
 import { readFile as readFile16 } from "fs/promises";
+var DEFAULT_THINKING_EFFORT = "high";
 async function toInput(message2) {
   if (message2.role === "tool") {
     if (!message2.toolCallId) throw new Error("Tool messages require toolCallId");
@@ -14879,7 +15042,7 @@ var OpenAIModelAdapter = class {
       ...options.baseURL === void 0 ? {} : { baseURL: options.baseURL }
     });
     this.debugUsage = options.debugUsage ?? isEnvTruthy(process.env.FLAVOR_DEBUG_USAGE);
-    this.thinkingEffort = options.thinkingEffort;
+    this.thinkingEffort = options.thinkingEffort ?? DEFAULT_THINKING_EFFORT;
   }
   #logUsage(model, breakdown) {
     if (breakdown === void 0) return;
@@ -14902,12 +15065,12 @@ var OpenAIModelAdapter = class {
       const body = {
         model: request.model,
         input: (await Promise.all(request.messages.map(toInput))).flat(),
-        ...this.thinkingEffort === void 0 ? {} : { reasoning: { effort: this.thinkingEffort } },
+        reasoning: { effort: this.thinkingEffort },
         tools: [...request.tools].sort((a, b) => a.name.localeCompare(b.name)).map((tool) => ({
           type: "function",
           name: tool.name,
           description: tool.description,
-          parameters: tool.inputSchema,
+          parameters: openAIJsonSchemaObject(tool.inputSchema, tool.strict ?? true),
           strict: tool.strict ?? true
         }))
       };
@@ -19982,6 +20145,15 @@ var RegisterManagedToolInputSchema = z31.object({
     "Agent roles allowed to call the generated tool; omit to allow both"
   )
 }).strict();
+var RegisterManagedToolModelInputSchema = (() => {
+  const schema = jsonSchemaFromZod(RegisterManagedToolInputSchema);
+  const properties = schema.properties;
+  const inputSchema = { ...properties.inputSchema };
+  delete inputSchema.propertyNames;
+  delete inputSchema.patternProperties;
+  inputSchema.additionalProperties = true;
+  return { ...schema, properties: { ...properties, inputSchema } };
+})();
 var RemoveManagedToolInputSchema = z31.object({
   name: z31.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
   scope: z31.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
@@ -20127,6 +20299,8 @@ function createManagedToolManagementTools(options) {
     name: "RegisterTool",
     description: "Create a durable custom tool from JSON Schema and async JavaScript, then expose it immediately",
     inputSchema: RegisterManagedToolInputSchema,
+    modelInputSchema: RegisterManagedToolModelInputSchema,
+    modelStrict: false,
     agents: mainOnly,
     paths: (rawInput) => {
       const parsed = RegisterManagedToolInputSchema.safeParse(rawInput);
@@ -25154,7 +25328,7 @@ function terminalProgressState(status) {
   return "failed";
 }
 function isResumableLongTaskError(code) {
-  return code !== "authentication" && code !== "model_not_found" && code !== "cancelled" && code !== "memory_pressure";
+  return code !== "authentication" && code !== "model_not_found" && code !== "invalid_request" && code !== "cancelled" && code !== "memory_pressure";
 }
 async function workspaceFingerprint(workspace) {
   const hash = createHash18("sha256");

package/dist/{chunk-XMRKRPNC.js → chunk-VMQWXQEC.js}

@@ -19604,7 +19604,7 @@ function renderNodeToOutput(node, output, {
             const delta = contentCached.y - contentY;
             const regionTop = Math.floor(y + contentYoga.getComputedTop());
             const regionBottom = regionTop + innerHeight - 1;
-            if (cached?.y === y && cached.height === height && innerHeight > 0 && Math.abs(delta) < innerHeight) {
+            if (cached?.y === y && cached.height === height && innerHeight > 0 && Math.floor(x) === 0 && Math.floor(width) >= output.width && Math.abs(delta) < innerHeight) {
               hint = { top: regionTop, bottom: regionBottom, delta };
               scrollHint = hint;
             } else {
@@ -21447,6 +21447,7 @@ export {
   Box_default,
   Text,
   stripAnsi,
+  stringWidth,
   ScrollBox_default,
   instances_default,
   osc,

package/dist/{claude-ink-6EZHF64C.js → claude-ink-JZXNSAQS.js}

@@ -10,7 +10,7 @@ import {
   useStdout,
   use_app_default,
   use_input_default
-} from "./chunk-XMRKRPNC.js";
+} from "./chunk-VMQWXQEC.js";
 import "./chunk-ZJCAQXA7.js";
 import "./chunk-S32JRDZK.js";
 export {

package/dist/cli-main.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-EUKT7HEU.js";
+} from "./chunk-FAORPP4F.js";
 import {
   staticTaskLines
 } from "./chunk-RAYH6K2H.js";
@@ -29,7 +29,7 @@ import {
   redactErrorText,
   runDoctor,
   runPalBroker
-} from "./chunk-LLC7WBXP.js";
+} from "./chunk-O2PC44GY.js";
 import {
   MEMORY_RESTART_EXIT_CODE
 } from "./chunk-N5MXHJKD.js";
@@ -41,7 +41,7 @@ import {
   readRecoverableFile,
   setProjectSkillDisabled,
   updateProtectedFile
-} from "./chunk-EXOSMO57.js";
+} from "./chunk-7YFHRORG.js";
 import {
   gt,
   isValidVersion
@@ -749,7 +749,7 @@ async function runEvaluationFile(path, outputPath) {
     })),
     ...parsed.maxTokens === void 0 ? {} : { maxTokens: parsed.maxTokens }
   };
-  const configured = await import("./load-EW56Q2MM.js").then(({ loadConfig: loadConfig2 }) => loadConfig2({ cwd: workspace, home: process.env.USERPROFILE ?? process.env.HOME ?? workspace }));
+  const configured = await import("./load-UPOG3XQR.js").then(({ loadConfig: loadConfig2 }) => loadConfig2({ cwd: workspace, home: process.env.USERPROFILE ?? process.env.HOME ?? workspace }));
   const environment = createExecutionEnvironment(workspace, configured.config.execution) ?? new LocalExecutionEnvironment();
   let report;
   try {
@@ -919,9 +919,9 @@ async function runInteractiveCli(props) {
   const disposeUserTimingSweeper = installUiUserTimingSweeper();
   try {
     const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
-      import("./claude-ink-6EZHF64C.js"),
+      import("./claude-ink-JZXNSAQS.js"),
       import("react"),
-      import("./app-KSUBHHLR.js")
+      import("./app-UKTPW3E6.js")
     ]);
     const instance = await render(createElement(
       AlternateScreen,

package/dist/config/schema.d.ts

@@ -25,6 +25,7 @@ export declare const ProviderConfigSchema: z.ZodObject<{
         low: "low";
         medium: "medium";
         minimal: "minimal";
+        ultra: "ultra";
         xhigh: "xhigh";
     }>>;
     claudeClient: z.ZodOptional<z.ZodBoolean>;
@@ -82,6 +83,7 @@ export declare const FlavorConfigSchema: z.ZodObject<{
             low: "low";
             medium: "medium";
             minimal: "minimal";
+            ultra: "ultra";
             xhigh: "xhigh";
         }>>;
         claudeClient: z.ZodOptional<z.ZodBoolean>;