claudish 9.0.5 → 9.0.6

package/dist/index.js

@@ -715,7 +715,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "9.0.5";
+var VERSION = "9.0.6";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -20319,6 +20319,62 @@ function normalizeType(type) {
   }
   return type;
 }
+function canonicalKey(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value))
+    return `[${value.map(canonicalKey).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalKey(value[key])}`).join(",")}}`;
+}
+function dedupeBranches(branches) {
+  const seen = new Set;
+  const unique = [];
+  for (const branch of branches) {
+    const key = canonicalKey(branch);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    unique.push(branch);
+  }
+  return unique;
+}
+function describesNothing(entry) {
+  return Object.keys(entry).every((key) => ANNOTATION_KEYWORDS.has(key));
+}
+function unionBranches(entries) {
+  const branches = [];
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    if (entry.type === "null")
+      continue;
+    if (describesNothing(entry))
+      branches.push(...ANY_VALUE_BRANCHES.map((b) => ({ ...b })));
+    else
+      branches.push(sanitizeSchemaForGemini(entry));
+  }
+  return dedupeBranches(branches);
+}
+function tupleElementSchema(entries) {
+  const branches = unionBranches(entries);
+  if (branches.length === 0)
+    return { type: "string" };
+  if (branches.length === 1)
+    return branches[0];
+  return { anyOf: branches };
+}
+function describeTuple(entries) {
+  const shape = entries.map((entry) => {
+    if (!entry || typeof entry !== "object" || describesNothing(entry))
+      return "any";
+    const type = normalizeType(entry.type);
+    const values = Array.isArray(entry.enum) ? entry.enum.filter((v) => typeof v === "string" || typeof v === "number") : [];
+    if (values.length === 0)
+      return type;
+    return `${type} (one of: ${values.map((v) => JSON.stringify(v)).join(", ")})`;
+  }).join(", ");
+  return `Ordered ${entries.length}-element array: [${shape}].`;
+}
 function sanitizeSchemaForGemini(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -20326,6 +20382,18 @@ function sanitizeSchemaForGemini(schema) {
   if (Array.isArray(schema)) {
     return schema.map((item) => sanitizeSchemaForGemini(item));
   }
+  const unionSource = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : null;
+  const hasStructuralSiblings = schema.type !== undefined || schema.properties !== undefined || schema.required !== undefined || schema.items !== undefined || schema.prefixItems !== undefined;
+  if (unionSource && !hasStructuralSiblings) {
+    const branches = unionBranches(unionSource);
+    if (branches.length > 0) {
+      const union = branches.length === 1 ? branches[0] : { anyOf: branches };
+      if (typeof schema.description === "string" && !union.description) {
+        union.description = schema.description;
+      }
+      return union;
+    }
+  }
   const result = {};
   const normalizedType = normalizeType(schema.type);
   result.type = normalizedType;
@@ -20346,12 +20414,27 @@ function sanitizeSchemaForGemini(schema) {
       }
     }
   }
-  if (schema.items) {
-    if (typeof schema.items === "object" && !Array.isArray(schema.items)) {
-      result.items = sanitizeSchemaForGemini(schema.items);
-    } else if (Array.isArray(schema.items)) {
-      result.items = sanitizeSchemaForGemini(schema.items[0]);
+  if (typeof schema.minItems === "number")
+    result.minItems = schema.minItems;
+  if (typeof schema.maxItems === "number")
+    result.maxItems = schema.maxItems;
+  const tupleEntries = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : null;
+  if (tupleEntries) {
+    const restSchema = Array.isArray(schema.prefixItems) && schema.items && typeof schema.items === "object" ? [schema.items] : [];
+    result.items = tupleElementSchema([...tupleEntries, ...restSchema]);
+    result.type = "array";
+    if (tupleEntries.length > 0) {
+      const note = describeTuple(tupleEntries);
+      result.description = result.description ? `${result.description} ${note}` : note;
     }
+    if (schema.items === false && result.maxItems === undefined) {
+      result.maxItems = tupleEntries.length;
+    }
+  } else if (schema.items && typeof schema.items === "object") {
+    result.items = sanitizeSchemaForGemini(schema.items);
+  }
+  if (result.type === "array" && !result.items) {
+    result.items = { type: "string" };
   }
   return result;
 }
@@ -20377,8 +20460,21 @@ function convertToolsToGemini(tools) {
   }
   return [{ functionDeclarations }];
 }
+var ANY_VALUE_BRANCHES, ANNOTATION_KEYWORDS;
 var init_gemini_schema = __esm(() => {
   init_logger();
+  ANY_VALUE_BRANCHES = [{ type: "string" }, { type: "number" }, { type: "boolean" }];
+  ANNOTATION_KEYWORDS = new Set([
+    "description",
+    "title",
+    "$comment",
+    "default",
+    "examples",
+    "example",
+    "deprecated",
+    "readOnly",
+    "writeOnly"
+  ]);
 });
 
 // src/handlers/shared/format/identity-filter.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "9.0.5",
+  "version": "9.0.6",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,10 +60,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "9.0.5",
-    "@claudish/magmux-darwin-x64": "9.0.5",
-    "@claudish/magmux-linux-arm64": "9.0.5",
-    "@claudish/magmux-linux-x64": "9.0.5"
+    "@claudish/magmux-darwin-arm64": "9.0.6",
+    "@claudish/magmux-darwin-x64": "9.0.6",
+    "@claudish/magmux-linux-arm64": "9.0.6",
+    "@claudish/magmux-linux-x64": "9.0.6"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",