claudish 9.0.5 → 9.0.7

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.7";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -18330,6 +18330,9 @@ function lookupModelCapabilities(modelId, cachePath) {
     return;
   return { supportsTools: entry.supportsTools, supportsThinking: entry.supportsThinking };
 }
+function lookupModelEndpoint(modelId, transport, cachePath) {
+  return findCacheEntry(modelId, cachePath)?.endpoints?.[transport];
+}
 function lookupModelForProvider(modelId, provider, cachePath) {
   const entry = findCacheEntry(modelId, cachePath);
   if (!entry)
@@ -20319,6 +20322,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 +20385,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 +20417,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 +20463,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
@@ -31993,6 +32092,14 @@ var init_model_unsupported = __esm(() => {
   ];
 });
 
+// src/handlers/shared/request-shape.ts
+function isRequestShapeError(errorBody) {
+  if (!errorBody)
+    return false;
+  const lower = errorBody.toLowerCase();
+  return lower.includes("unknown_parameter") || lower.includes("unsupported_parameter") || lower.includes("invalid_parameter") || lower.includes("unknown parameter:") || lower.includes("unsupported parameter:") || lower.includes("invalid parameter:");
+}
+
 // src/handlers/shared/stream-head-sniffer.ts
 function isRetryableStreamError(code, type, message) {
   if (RETRYABLE_ERROR_CODES.has(code))
@@ -34915,6 +35022,9 @@ function getRecoveryHint(status, errorText, providerName, transportTerminal429)
     if (lower.includes("unsupported content type") || lower.includes("unsupported_content_type")) {
       return "Model doesn't support this content format. Try a different model.";
     }
+    if (isRequestShapeError(errorText)) {
+      return "Wrong request shape for this endpoint \u2014 the provider named the parameter it rejected (see the message below). Nothing was too large; a shorter prompt will not help.";
+    }
     if (lower.includes("context") || lower.includes("too long") || lower.includes("token")) {
       return "Input too large. Reduce message history or use a larger-context model.";
     }
@@ -35653,9 +35763,14 @@ __export(exports_provider_profiles, {
   openCodeZenProfile: () => openCodeZenProfile,
   openaiCodexProfile: () => openaiCodexProfile,
   openaiProfile: () => openaiProfile,
+  requiresResponsesApi: () => requiresResponsesApi,
   vertexProfile: () => vertexProfile
 });
-function requiresResponsesApi(modelName) {
+function requiresResponsesApi(modelName, cachePath) {
+  const endpoint = lookupModelEndpoint(modelName, "openai", cachePath);
+  if (endpoint?.api === "responses" || endpoint?.toolsWithReasoning === "requires-responses") {
+    return true;
+  }
   const name = modelName.toLowerCase();
   return /^gpt-5\.6/.test(name) || name.includes("codex");
 }
@@ -35684,6 +35799,7 @@ var init_provider_profiles = __esm(() => {
   init_devin_api_format();
   init_gemini_api_format();
   init_litellm_api_format();
+  init_model_catalog();
   init_ollama_api_format();
   init_openai_api_format();
   init_vertex_auth();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "9.0.5",
+  "version": "9.0.7",
   "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.7",
+    "@claudish/magmux-darwin-x64": "9.0.7",
+    "@claudish/magmux-linux-arm64": "9.0.7",
+    "@claudish/magmux-linux-x64": "9.0.7"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",