@qwen-code/qwen-code 0.21.13 → 0.21.14

package/chunks/{chunk-KD5BOPLP.js → chunk-J6YS7Z25.js}

@@ -4,7 +4,7 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-V57QC6WW.js";
+} from "./chunk-6LAPGPVA.js";
 import {
   applyOfficialOpenAIPromptCaching,
   isOfficialOpenAIEndpoint
@@ -30,7 +30,7 @@ import {
 } from "./chunk-FAAUPSY2.js";
 import {
   RequestTokenizer
-} from "./chunk-A4MFR4C5.js";
+} from "./chunk-ZIGC3MUS.js";
 import {
   safeJsonParse
 } from "./chunk-5CVO7YES.js";
@@ -56,7 +56,7 @@ import {
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-RVOJ2FBP.js";
+} from "./chunk-KC4WMLZO.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
@@ -924,6 +924,81 @@ var StreamingToolCallParser = class {
 
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
 var debugLogger3 = createDebugLogger("OPENAI_PIPELINE");
+var OPENAI_STRICT_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "description",
+  "enum"
+]);
+var OPENAI_STRICT_UNSUPPORTED_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "uniqueItems"
+]);
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+__name(asObject, "asObject");
+function normalizeSchemaType(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.toLowerCase();
+  return [
+    "object",
+    "array",
+    "string",
+    "number",
+    "integer",
+    "boolean",
+    "null"
+  ].includes(normalized) ? normalized : void 0;
+}
+__name(normalizeSchemaType, "normalizeSchemaType");
+function normalizeOpenAIStrictSchema(schema) {
+  const source = asObject(schema);
+  if (!source) return void 0;
+  const type = normalizeSchemaType(source["type"]);
+  if (!type) return void 0;
+  const normalized = { type };
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "type" || OPENAI_STRICT_UNSUPPORTED_SCHEMA_KEYS.has(key) || !OPENAI_STRICT_SCHEMA_KEYS.has(key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  if (type === "object") {
+    const properties = asObject(source["properties"]);
+    if (!properties) return void 0;
+    const normalizedProperties = {};
+    for (const [key, value] of Object.entries(properties)) {
+      const property = normalizeOpenAIStrictSchema(value);
+      if (!property) return void 0;
+      normalizedProperties[key] = property;
+    }
+    const propertyKeys = Object.keys(normalizedProperties);
+    const required = source["required"];
+    if (!Array.isArray(required) || !propertyKeys.every((key) => required.includes(key)) || required.length !== propertyKeys.length) {
+      return void 0;
+    }
+    normalized["properties"] = normalizedProperties;
+    normalized["required"] = required;
+    normalized["additionalProperties"] = false;
+  }
+  if (type === "array") {
+    const items = normalizeOpenAIStrictSchema(source["items"]);
+    if (!items) return void 0;
+    normalized["items"] = items;
+  }
+  return normalized;
+}
+__name(normalizeOpenAIStrictSchema, "normalizeOpenAIStrictSchema");
 function isRequiredThinkingError(error) {
   if (getErrorStatus(error) !== 400) return false;
   const providerMessage = getRateLimitErrorDetails(error).providerMessage;
@@ -1472,7 +1547,8 @@ var ContentGenerationPipeline = class {
     const baseRequest = {
       model: context.model,
       messages,
-      ...this.buildGenerateContentConfig(request)
+      ...this.buildGenerateContentConfig(request),
+      ...this.buildResponseFormat(request)
     };
     if (isStreaming) {
       baseRequest.stream = true;
@@ -1571,6 +1647,24 @@ var ContentGenerationPipeline = class {
     }
     return providerRequest;
   }
+  buildResponseFormat(request) {
+    if (!isOfficialOpenAIEndpoint(this.contentGeneratorConfig)) return {};
+    if (request.config?.responseMimeType !== "application/json") return {};
+    const schema = request.config.responseJsonSchema ?? request.config.responseSchema;
+    if (!schema) return { response_format: { type: "json_object" } };
+    const strictSchema = normalizeOpenAIStrictSchema(schema);
+    if (!strictSchema) return { response_format: { type: "json_object" } };
+    return {
+      response_format: {
+        type: "json_schema",
+        json_schema: {
+          name: "response",
+          schema: strictSchema,
+          strict: true
+        }
+      }
+    };
+  }
   requiresThinking(model) {
     const normalizedModel = model.toLowerCase();
     return this.requiredThinkingModels.has(normalizedModel) || this.contentGeneratorConfig.thinkingMandatory === true && normalizedModel === (this.contentGeneratorConfig.model ?? "").toLowerCase();