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

package/dist/desktop/main.js

@@ -214,9 +214,8 @@ var ProviderConfigSchema = z2.object({
   // parameter. Provider thinking deltas are forwarded whenever they arrive.
   thinkingBudget: z2.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: z2.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
+  // reasoning.effort). The adapter defaults an omitted value to high.
+  thinkingEffort: z2.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: z2.boolean().optional(),
@@ -4267,10 +4266,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)) {
@@ -6404,7 +6405,10 @@ function jsonSchemaFromZod(schema) {
   return z12.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();
@@ -6542,40 +6546,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 ["$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
-      ]));
+  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;
+  }
+  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 = [
@@ -7979,9 +8137,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 } : {}
       };
@@ -8014,7 +8174,7 @@ var ToolRuntime = class {
           payload: {
             toolCallId,
             tool: tool.name,
-            input: tool.permissionInput?.(input) ?? input,
+            input: approvalInput,
             agent: context.agent,
             reason,
             toolCategory: getToolCategory(tool.name),
@@ -11460,10 +11620,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: {
@@ -12033,7 +12194,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;
@@ -12747,10 +12908,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));
@@ -14578,6 +14739,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");
@@ -14653,7 +14815,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;
@@ -14676,12 +14838,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
         }))
       };
@@ -21467,6 +21629,15 @@ var RegisterManagedToolInputSchema = z37.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 = z37.object({
   name: z37.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
   scope: z37.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
@@ -21612,6 +21783,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);
@@ -28793,7 +28966,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 = createHash21("sha256");