nolo-cli 0.201.0-alpha.2 → 0.202.0-alpha.2

package/{chunk-WFUIXNKC.js → chunk-P4YLK2OD.js}

@@ -5,15 +5,15 @@ import {
   ANTIGRAVITY_CLOUD_CODE_BASE_URL,
   isAntigravityCloudCodeBaseUrl,
   isAntigravityOAuthAgent
-} from "./chunk-QU3TLYBR.js";
+} from "./chunk-VEUSD6OF.js";
 import {
   isOpenAiResponsesModel,
   resolvePlatformChatCompletionsEndpoint,
   resolvePlatformResponsesEndpoint
-} from "./chunk-TVGX5QIN.js";
+} from "./chunk-YUA6OAH5.js";
 import {
   findModelConfig
-} from "./chunk-GC64WGMD.js";
+} from "./chunk-SM3NSZJV.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";

package/chunk-PRJ473FK.js

@@ -0,0 +1,63 @@
+// packages/agent-runtime/skillSlashReference.ts
+var DEFAULT_SKILL_SLASH_USER_PROMPT = "\u8BF7\u6309\u7167\u8BE5\u6280\u80FD\u7684\u6307\u793A\u6267\u884C\u3002";
+function resolveSkillSlashUserPrompt(args) {
+  const trimmed = args.replace(/^\s+/, "");
+  return trimmed.length > 0 ? trimmed : DEFAULT_SKILL_SLASH_USER_PROMPT;
+}
+function isNonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function formatSkillSlashReference(reference) {
+  let payload;
+  switch (reference.source) {
+    case "builtin":
+      if (!isNonEmpty(reference.id)) throw new TypeError("Empty builtin skill id");
+      payload = reference.id;
+      break;
+    case "space":
+      if (!isNonEmpty(reference.dbKey)) throw new TypeError("Empty space skill dbKey");
+      payload = reference.dbKey;
+      break;
+    case "project":
+      if (!isNonEmpty(reference.projectBinding) || !isNonEmpty(reference.relativePath)) {
+        throw new TypeError("Empty project skill binding or relative path");
+      }
+      payload = JSON.stringify([reference.projectBinding, reference.relativePath]);
+      break;
+    default:
+      throw new TypeError("Unknown skill source");
+  }
+  return `/skill@${reference.source}:${encodeURIComponent(payload)}`;
+}
+function parseSkillSlashReference(input) {
+  const match = /^\/skill@([^:\s]+):(\S+)([\s\S]*)$/.exec(input);
+  if (!match) return null;
+  const [, source, encoded, args] = match;
+  if (source !== "builtin" && source !== "space" && source !== "project") return null;
+  try {
+    const payload = decodeURIComponent(encoded);
+    if (!isNonEmpty(payload)) return null;
+    switch (source) {
+      case "builtin":
+        return { reference: { source, id: payload }, args };
+      case "space":
+        return { reference: { source, dbKey: payload }, args };
+      case "project": {
+        const pair = JSON.parse(payload);
+        if (!Array.isArray(pair) || pair.length !== 2 || !pair.every(isNonEmpty)) return null;
+        return {
+          reference: { source, projectBinding: pair[0], relativePath: pair[1] },
+          args
+        };
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+
+export {
+  resolveSkillSlashUserPrompt,
+  formatSkillSlashReference,
+  parseSkillSlashReference
+};

package/{chunk-2SHLT6JB.js → chunk-Q7GNBUT4.js}

@@ -4,12 +4,12 @@ import {
   isAgentSkillDisabled,
   resolveAgentSkillConfig,
   resolveUserEnabledSkills
-} from "./chunk-QYOB7RVA.js";
+} from "./chunk-DKZJJ2NQ.js";
 import {
   resolveBuiltinSkillEntry,
   resolveBuiltinSkillPage,
   resolveSkillGraphFromRoots
-} from "./chunk-O5V7QQAF.js";
+} from "./chunk-LEX6DEH4.js";
 import {
   parseSkillDocProtocol
 } from "./chunk-AETZ7AD6.js";

package/{chunk-C2UXCAMB.js → chunk-RIKSN62L.js}

@@ -2,7 +2,7 @@ import {
   clipMultilineText,
   fetchAndSerializeTable,
   waitForAbortableDelay
-} from "./chunk-KORCRPLO.js";
+} from "./chunk-C7PKPHK6.js";
 import {
   isGatewayHttpStatus
 } from "./chunk-NF64D32W.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-AGIM7IMJ.js";
 import {
   fetchAndCacheMessages
-} from "./chunk-EOLPKHSB.js";
+} from "./chunk-326HCB6L.js";
 import {
   createSpaceKey
 } from "./chunk-UAD2WT54.js";
@@ -35,7 +35,7 @@ import {
   extractRuntimePageCapabilities,
   resolveBuiltinSkillPage,
   resolveSkillGraphFromRoots
-} from "./chunk-O5V7QQAF.js";
+} from "./chunk-LEX6DEH4.js";
 import {
   isAbortError
 } from "./chunk-7DPNBQSV.js";

package/{chunk-GTP6VNWH.js → chunk-RQ22OZD7.js}

@@ -1,6 +1,6 @@
 import {
   getModelPricing
-} from "./chunk-ZBCBFOWC.js";
+} from "./chunk-A2ZMIRLN.js";
 import {
   PUBLIC_DEEPSEEK_V4_FLASH_AGENT_ID,
   PUBLIC_DEEPSEEK_V4_PRO_AGENT_ID,
@@ -23,14 +23,14 @@ import {
 } from "./chunk-M2EJHDJP.js";
 import {
   getModelConfig
-} from "./chunk-GC64WGMD.js";
+} from "./chunk-SM3NSZJV.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 import {
   isNoloHostedProvider,
   isPlatformHostedImageModel
-} from "./chunk-5KTQVMCX.js";
+} from "./chunk-GOO6G4PY.js";
 
 // packages/core/publicAgentSeeds.ts
 var AGENT_SEED_DEFAULTS = {

package/{chunk-H7NIQGTU.js → chunk-RS66RJLA.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-NBTY7YJF.js";
 import {
   resolveCliLocalRuntimeKeyCapability
-} from "./chunk-H44LQSZ2.js";
+} from "./chunk-HKWGI3TM.js";
 import {
   HIGH_RISK_MUTATION_TOOL_NAMES
-} from "./chunk-NABJEYPJ.js";
+} from "./chunk-2Q3LOAFE.js";
 import {
   DEFAULT_NOLO_SERVER_URL
 } from "./chunk-OLZBQWZU.js";

package/{chunk-GC64WGMD.js → chunk-SM3NSZJV.js}

@@ -7,9 +7,10 @@ import {
   gmiModels,
   openrouterModels,
   platformHostedModels,
+  resolvePlatformEffectiveModel,
   toCnyCredits,
   zaiModels
-} from "./chunk-5KTQVMCX.js";
+} from "./chunk-GOO6G4PY.js";
 
 // packages/integrations/qwen/models.ts
 var qwenModels = [
@@ -2361,11 +2362,12 @@ var REASONING_EFFORT_OPTIONS = [
   "medium",
   "high",
   "xhigh",
-  "max"
+  "max",
+  "ultra"
 ];
 var PROVIDER_REASONING_EFFORT_VALUES = {
-  openai: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
-  openrouter: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+  openai: ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"],
+  openrouter: ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"],
   deepseek: ["low", "high", "max"],
   // nolo (Ollama Cloud) 支持 DeepSeek/Kimi/GLM 等 thinking 模型，
   // reasoning_effort 通过 OpenAI 兼容端点透传到 Ollama Cloud。
@@ -3219,6 +3221,7 @@ var REASONING_MODEL_NAMES = /* @__PURE__ */ new Set([
   "gpt-5.5-pro",
   "gpt-6-astra",
   "gpt-6.1-sol",
+  "gpt-6.1-terra",
   "gpt-6-sol",
   "gpt-6-luna",
   "gpt-5.6-sol",
@@ -3254,7 +3257,8 @@ var EFFORT_ORDER = [
   "medium",
   "high",
   "xhigh",
-  "max"
+  "max",
+  "ultra"
 ];
 function nearestSupportedEffort(effort, supported) {
   const effortIdx = EFFORT_ORDER.indexOf(effort);
@@ -3440,6 +3444,13 @@ var findOpenRouterUpstreamModel = (name) => {
 function findModelConfig(provider, name) {
   const normalizedProvider = normalizeLookupProvider(provider);
   if (!normalizedProvider) return null;
+  if (normalizedProvider === "nolo") {
+    const effective = resolvePlatformEffectiveModel(name);
+    if (effective && effective !== name) {
+      const aliased = findCandidateInProvider(normalizedProvider, effective);
+      if (aliased) return aliased;
+    }
+  }
   const direct = findCandidateInProvider(normalizedProvider, name);
   if (direct) return direct;
   if (normalizedProvider === "openrouter") {

package/{chunk-QKDMI22S.js → chunk-SSK4WNJA.js}

@@ -7,7 +7,7 @@ import {
   deleteDialog,
   runtime_default,
   toast
-} from "./chunk-EOLPKHSB.js";
+} from "./chunk-326HCB6L.js";
 import {
   UNCATEGORIZED_ID,
   addContentAction,

package/{chunk-6MAFLMAO.js → chunk-SUBNV2JH.js}

@@ -1,10 +1,10 @@
 import {
   fetchReferenceContents,
   resolveReferenceAssets
-} from "./chunk-C2UXCAMB.js";
+} from "./chunk-RIKSN62L.js";
 import {
   updateTokensAction
-} from "./chunk-EOLPKHSB.js";
+} from "./chunk-326HCB6L.js";
 import {
   applyUpdateTokensFulfilled
 } from "./chunk-OWYYDMGJ.js";
@@ -12,7 +12,7 @@ import {
   extractReasoningFromResponseOutput,
   extractTextFromResponseOutput,
   extractToolCallsFromResponseOutput
-} from "./chunk-OHRDHS4N.js";
+} from "./chunk-CVCRAO6Q.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";

package/{chunk-HLAL63BZ.js → chunk-T43B7LB2.js}

@@ -4,7 +4,7 @@ import {
   openrouterModels,
   platformHostedModels,
   zaiModels
-} from "./chunk-5KTQVMCX.js";
+} from "./chunk-GOO6G4PY.js";
 
 // packages/ai/llm/modelAbility.ts
 var MODEL_ABILITY_TABLE = {

package/{chunk-HTLIKE5U.js → chunk-TWVVTUNG.js}

@@ -15,10 +15,10 @@ import {
 } from "./chunk-Y6ROFCZO.js";
 import {
   scheduleWindowsSelfUpdate
-} from "./chunk-WAZ6BTSC.js";
+} from "./chunk-5E4FSR4J.js";
 import {
   t
-} from "./chunk-UNOILAZP.js";
+} from "./chunk-CLTGWJVT.js";
 
 // packages/cli/updateCommands.ts
 import { existsSync, readFileSync, accessSync, constants } from "node:fs";

package/{chunk-X3RWBJDQ.js → chunk-U7HTU2S7.js}

@@ -1,7 +1,7 @@
 import {
   buildAgentRuntimeAgentLookupKeys,
   shouldFetchAgentRuntimeRecordRemotely
-} from "./chunk-NABJEYPJ.js";
+} from "./chunk-2Q3LOAFE.js";
 
 // packages/agent-runtime/oauthProviderRefs.ts
 var OAUTH_PROVIDER_REFS = [

package/{chunk-76YUTLOT.js → chunk-UIOEHFF6.js}

@@ -2,7 +2,7 @@ import {
   getCredentialsDir,
   getLegacyCredentialPath,
   migrateLegacyCredentialFile
-} from "./chunk-ZWQUWF6W.js";
+} from "./chunk-G7Y4GXTY.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";

package/{chunk-IIX6VWLW.js → chunk-VCFU3BO5.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HNUWUO75.js";
 import {
   resolveToolImagePolicy
-} from "./chunk-PVD7CRYV.js";
+} from "./chunk-6I7ZP7KJ.js";
 import {
   projectOpenAiToolImages
 } from "./chunk-E2BESSAW.js";
@@ -11,7 +11,7 @@ import {
   getAntigravityUserAgent,
   readAntigravityProjectId,
   resolveAntigravityCloudCodeBaseUrl
-} from "./chunk-QU3TLYBR.js";
+} from "./chunk-VEUSD6OF.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -408,7 +408,8 @@ function sanitizeGeminiSchemaNodeInner(src, out, seen) {
     if (typeof firstNonNull === "string") out.type = firstNonNull;
     out.nullable = true;
   } else if (typeof src.type === "string") {
-    out.type = src.type;
+    out.type = src.type === "null" ? "string" : src.type;
+    if (src.type === "null") out.nullable = true;
   }
   if (typeof src.description === "string") out.description = src.description;
   if (typeof src.minimum === "number") out.minimum = src.minimum;
@@ -420,54 +421,229 @@ function sanitizeGeminiSchemaNodeInner(src, out, seen) {
     enumMetaByNode.set(out, { values: enumValues, baseDescription });
     applyGeminiEnum(out, geminiEnumFields(enumValues, baseDescription));
   }
+  if (src.type === "null") {
+    out.description = [out.description, "null only"].filter(Boolean).join("\n");
+  }
   const variantBranches = [
     ...Array.isArray(src.oneOf) ? src.oneOf : [],
     ...Array.isArray(src.anyOf) ? src.anyOf : []
   ];
   if (variantBranches.length > 0) {
-    const mergedProperties = {};
-    let requiredIntersection;
-    for (const branch of variantBranches) {
-      const sanitized = sanitizeGeminiSchemaNode(branch, seen);
-      const branchProperties = sanitized.properties ?? {};
-      for (const [key, value] of Object.entries(branchProperties)) {
-        const previous = mergedProperties[key];
-        const prevMeta = enumMetaOf(previous);
-        const nextMeta = enumMetaOf(value);
-        if (prevMeta && nextMeta) {
-          const values = [...prevMeta.values, ...nextMeta.values];
-          const baseDescription = nextMeta.baseDescription ?? prevMeta.baseDescription;
-          const node = {
-            ...value
-          };
-          delete node.enum;
-          delete node.description;
-          applyGeminiEnum(node, geminiEnumFields(values, baseDescription));
-          enumMetaByNode.set(node, { values, baseDescription });
-          mergedProperties[key] = node;
-        } else {
-          mergedProperties[key] = value;
+    const rawBranches = variantBranches.map(
+      (branch) => branch && typeof branch === "object" && !Array.isArray(branch) ? branch : {}
+    );
+    const allSanitized = variantBranches.map(
+      (branch) => sanitizeGeminiSchemaNode(branch, seen)
+    );
+    if (rawBranches.some(
+      (branch, index) => branch.type === "null" || allSanitized[index]?.nullable === true || rawEnumValues(branch)?.includes(null)
+    )) out.nullable = true;
+    const nonNullIndices = rawBranches.flatMap(
+      (branch, index) => branch.type === "null" ? [] : [index]
+    );
+    const branches = nonNullIndices.map((index) => rawBranches[index]);
+    const sanitizedBranches = nonNullIndices.map((index) => allSanitized[index]);
+    const inferType = (branch) => {
+      if (typeof branch.type === "string") return branch.type;
+      const values = rawEnumValues(branch)?.filter((value) => value !== null);
+      if (!values?.length) return void 0;
+      if (values.every((value) => typeof value === "number")) {
+        return values.every((value) => Number.isInteger(value)) ? "integer" : "number";
+      }
+      if (values.every((value) => typeof value === "boolean")) return "boolean";
+      if (values.every((value) => typeof value === "string")) return "string";
+      return void 0;
+    };
+    const candidateTypes = (branch, active = /* @__PURE__ */ new Set()) => {
+      if (active.has(branch)) return [];
+      active.add(branch);
+      const nested = [branch.oneOf, branch.anyOf].flatMap((value) => Array.isArray(value) ? value : []);
+      const type = inferType(branch);
+      const types = [
+        ...type && type !== "null" ? [type] : [],
+        ...nested.flatMap((value) => value && typeof value === "object" ? candidateTypes(value, active) : [])
+      ];
+      active.delete(branch);
+      return types;
+    };
+    const unconstrainedBranch = branches.some(
+      (branch) => branch.type === void 0 && rawEnumValues(branch) === void 0 && branch.properties === void 0 && branch.oneOf === void 0 && branch.anyOf === void 0 && branch.allOf === void 0 && branch.$ref === void 0
+    );
+    if (sanitizedBranches.every(
+      (branch) => branch.properties === void 0 && branch.required === void 0
+    )) {
+      const types = [...new Set(branches.flatMap((branch) => candidateTypes(branch)))];
+      const first = sanitizedBranches[0] ?? {};
+      const baseDescription = typeof out.description === "string" ? out.description : typeof branches[0]?.description === "string" ? branches[0].description : void 0;
+      const scalar = {
+        ...first,
+        type: types.length > 0 && types.every((type) => type === "integer" || type === "number") ? types.includes("number") ? "number" : "integer" : types[0] ?? "string",
+        ...out
+      };
+      delete scalar.description;
+      if (baseDescription !== void 0) scalar.description = baseDescription;
+      if (!enumValues) {
+        delete scalar.enum;
+        const values = branches.flatMap(
+          (branch, index) => rawEnumValues(branch) ?? enumMetaOf(sanitizedBranches[index])?.values ?? []
+        );
+        const allEnum = branches.length > 0 && branches.every(
+          (branch, index) => rawEnumValues(branch) !== void 0 || enumMetaOf(sanitizedBranches[index]) !== void 0
+        );
+        if (values.length > 0) {
+          if (allEnum) {
+            if (typeof out.type !== "string") {
+              scalar.type = inferType({ enum: values }) ?? "string";
+            }
+            applyGeminiEnum(scalar, geminiEnumFields(values, baseDescription));
+            enumMetaByNode.set(out, { values, baseDescription });
+          } else {
+            scalar.description = [
+              baseDescription,
+              `Candidates: ${[...new Set(values.map(geminiEnumLiteral))].join(", ")}`
+            ].filter(Boolean).join("\n");
+          }
+        }
+      }
+      const conflictingRanges = [];
+      for (const key of ["minimum", "maximum", "minLength", "maxLength"]) {
+        if (typeof src[key] === "number") {
+          scalar[key] = src[key];
+          continue;
+        }
+        const values = branches.map((branch) => branch[key]).filter((value) => typeof value === "number");
+        if (values.length !== branches.length || new Set(values).size > 1) {
+          delete scalar[key];
+          if (values.length > 0 && conflictingRanges.length === 0) {
+            conflictingRanges.push(...branches.map((branch) => Object.fromEntries(
+              ["minimum", "maximum", "minLength", "maxLength"].flatMap(
+                (name) => typeof branch[name] === "number" ? [[name, branch[name]]] : []
+              )
+            )));
+          }
+        } else if (values.length > 0) scalar[key] = values[0];
+      }
+      if (conflictingRanges.length > 0) {
+        scalar.description = [
+          scalar.description,
+          `Original ranges: ${conflictingRanges.map((range) => JSON.stringify(range)).join(" | ")}`
+        ].filter(Boolean).join("\n");
+      }
+      const stableValue = (value) => {
+        if (Array.isArray(value)) return value.map(stableValue);
+        if (value && typeof value === "object") return Object.fromEntries(
+          Object.keys(value).sort().map((key) => [key, stableValue(value[key])])
+        );
+        return value;
+      };
+      if (src.items === void 0 && branches.some((branch) => branch.items !== void 0)) {
+        const firstItems = branches[0]?.items;
+        const sameItems = firstItems !== void 0 && branches.every(
+          (branch) => branch.items !== void 0 && JSON.stringify(stableValue(branch.items)) === JSON.stringify(stableValue(firstItems))
+        );
+        if (!sameItems) {
+          const itemTypes = branches.map((branch) => {
+            const items = branch.items;
+            return items && typeof items === "object" && !Array.isArray(items) ? items.type : void 0;
+          });
+          const commonType = itemTypes[0];
+          const fallbackType = typeof commonType === "string" && ["string", "integer", "number", "boolean", "object", "array"].includes(commonType) && itemTypes.every((type) => type === commonType) ? commonType : "string";
+          scalar.items = fallbackType === "array" ? { type: "array", items: { type: "string" } } : { type: fallbackType };
+          scalar.description = [
+            scalar.description,
+            `Original items: ${branches.map((branch) => branch.items === void 0 ? "unconstrained" : geminiEnumLiteral(branch.items)).join(" | ")}`
+          ].filter(Boolean).join("\n");
+        }
+      }
+      const originalConstraints = branches.map((branch) => Object.fromEntries(
+        ["pattern", "format"].flatMap((key) => branch[key] !== void 0 ? [[key, branch[key]]] : [])
+      ));
+      if (originalConstraints.some((constraints) => Object.keys(constraints).length > 0)) {
+        scalar.description = [
+          scalar.description,
+          `Original constraints: ${originalConstraints.map((value) => JSON.stringify(value)).join(" | ")}`
+        ].filter(Boolean).join("\n");
+      }
+      for (let index = 0; index < branches.length; index++) {
+        if ((branches[index].oneOf || branches[index].anyOf) && sanitizedBranches[index].description) {
+          scalar.description = [
+            scalar.description,
+            `Branch ${index + 1}: ${sanitizedBranches[index].description}`
+          ].filter(Boolean).join("\n");
+        }
+      }
+      if (types.length > 1) {
+        scalar.description = [scalar.description, `One of: ${types.join(" | ")}`].filter(Boolean).join("\n");
+      }
+      if (branches.length === 0) {
+        scalar.description = [scalar.description, "null only"].filter(Boolean).join("\n");
+      } else if (branches.some((branch) => inferType(branch) === void 0 && rawEnumValues(branch)?.some((value) => value !== null))) {
+        scalar.description = [scalar.description, "Mixed enum types; using a fallback type"].filter(Boolean).join("\n");
+      }
+      Object.assign(out, scalar);
+    } else {
+      const mergedProperties = {};
+      let requiredIntersection;
+      for (const sanitized of sanitizedBranches) {
+        const branchProperties = sanitized.properties ?? {};
+        for (const [key, value] of Object.entries(branchProperties)) {
+          const previous = mergedProperties[key];
+          const prevMeta = enumMetaOf(previous);
+          const nextMeta = enumMetaOf(value);
+          if (prevMeta && nextMeta) {
+            const values = [...prevMeta.values, ...nextMeta.values];
+            const baseDescription = nextMeta.baseDescription ?? prevMeta.baseDescription;
+            const node = {
+              ...value
+            };
+            delete node.enum;
+            delete node.description;
+            applyGeminiEnum(node, geminiEnumFields(values, baseDescription));
+            enumMetaByNode.set(node, { values, baseDescription });
+            mergedProperties[key] = node;
+          } else {
+            mergedProperties[key] = value;
+          }
         }
+        const branchRequired = Array.isArray(sanitized.required) ? sanitized.required : [];
+        requiredIntersection = requiredIntersection === void 0 ? [...branchRequired] : requiredIntersection.filter((r) => branchRequired.includes(r));
+      }
+      out.properties = {
+        ...out.properties ?? {},
+        ...mergedProperties
+      };
+      if (requiredIntersection !== void 0 && requiredIntersection.length > 0) {
+        out.required = requiredIntersection;
+      }
+      if (typeof out.type !== "string") out.type = "object";
+      if (sanitizedBranches.some((branch) => branch.properties === void 0)) {
+        const types = [...new Set(branches.flatMap(
+          (branch) => branch.properties !== void 0 ? ["object"] : candidateTypes(branch)
+        ))].sort();
+        if (rawBranches.some((branch) => branch.type === "null")) types.push("null");
+        out.description = [
+          out.description,
+          `One of: ${types.join(" | ")}. This declaration represents only one branch of the union; other candidates are not structurally represented.`
+        ].filter(Boolean).join("\n");
       }
-      const branchRequired = Array.isArray(sanitized.required) ? sanitized.required : [];
-      requiredIntersection = requiredIntersection === void 0 ? [...branchRequired] : requiredIntersection.filter((r) => branchRequired.includes(r));
     }
-    out.properties = {
-      ...out.properties ?? {},
-      ...mergedProperties
-    };
-    if (requiredIntersection !== void 0 && requiredIntersection.length > 0) {
-      out.required = requiredIntersection;
+    if (unconstrainedBranch) {
+      out.description = [
+        out.description,
+        "An unconstrained branch accepts any JSON value (any value, including null). This declaration uses a fallback type and cannot express the full union."
+      ].filter(Boolean).join("\n");
+      if (src.type === void 0) out.nullable = true;
     }
-    if (typeof out.type !== "string") out.type = "object";
   }
   if (Array.isArray(src.allOf)) {
     for (const branch of src.allOf) {
       const sanitized = sanitizeGeminiSchemaNode(branch, seen);
-      out.properties = {
-        ...out.properties ?? {},
-        ...sanitized.properties ?? {}
-      };
+      if (out.type === void 0 || out.type === "object" || out.properties || sanitized.properties) {
+        out.properties = {
+          ...out.properties ?? {},
+          ...sanitized.properties ?? {}
+        };
+      }
       if (Array.isArray(sanitized.required)) {
         out.required = [
           .../* @__PURE__ */ new Set([
@@ -501,6 +677,16 @@ function sanitizeGeminiSchemaNodeInner(src, out, seen) {
     if (typeof out.type !== "string") out.type = "array";
   }
   if (typeof out.type !== "string") out.type = "object";
+  if (out.type === "array" && !out.items) out.items = { type: "string" };
+  if (out.type !== "object" && !out.properties) {
+    const dropped = Object.fromEntries(["minLength", "maxLength", "pattern", "format"].flatMap(
+      (key) => src[key] !== void 0 && out[key] === void 0 ? [[key, src[key]]] : []
+    ));
+    if (Object.keys(dropped).length > 0) out.description = [
+      out.description,
+      `Original constraints: ${JSON.stringify(dropped)}`
+    ].filter(Boolean).join("\n");
+  }
   return out;
 }
 function convertOpenAiToolsToGemini(tools) {