@cognipeer/agent-sdk 0.5.1 → 0.5.3

package/dist/index.mjs

@@ -3615,6 +3615,21 @@ function createAgent(opts) {
       }
       if (toolCalls.length === 0) {
         if (soManager && !state.ctx?.__finalizedDueToStructuredOutput && !state.ctx?.__structuredOutputForceFinalize) {
+          if (soManager.strategy.kind === "native") {
+            const assistantText = extractMessageText2(lastMsg);
+            if (assistantText) {
+              const parsed = soManager.parseFromContent(assistantText);
+              if (parsed.success) {
+                const ctx2 = {
+                  ...state.ctx || {},
+                  __finalizedDueToStructuredOutput: true,
+                  __structuredOutputParsed: parsed.data
+                };
+                state = { ...state, ctx: ctx2 };
+              }
+            }
+            break;
+          }
           const nudge = soManager.buildNudgeMessage(false);
           const ctx = { ...state.ctx || {}, __structuredOutputForceFinalize: true };
           state = { ...state, messages: [...state.messages, nudge], ctx };
@@ -3631,6 +3646,23 @@ function createAgent(opts) {
       if (state.ctx?.__finalizedDueToStructuredOutput) break;
     }
     if (soManager && !state.ctx?.__finalizedDueToStructuredOutput) {
+      const lastForParse = state.messages[state.messages.length - 1];
+      if (lastForParse?.role === "assistant") {
+        const assistantText = extractMessageText2(lastForParse);
+        if (assistantText) {
+          const parsed = soManager.parseFromContent(assistantText);
+          if (parsed.success) {
+            const ctx = {
+              ...state.ctx || {},
+              __finalizedDueToStructuredOutput: true,
+              __structuredOutputParsed: parsed.data
+            };
+            state = { ...state, ctx };
+          }
+        }
+      }
+    }
+    if (soManager && soManager.strategy.kind === "tool_based" && !state.ctx?.__finalizedDueToStructuredOutput) {
       const maxPostLoopRetries = soManager.maxRetries;
       for (let postRetry = 0; postRetry < maxPostLoopRetries; postRetry++) {
         if (state.ctx?.__finalizedDueToStructuredOutput) break;
@@ -7082,27 +7114,86 @@ function convertContent(content) {
 function isZodSchema(obj) {
   return obj != null && typeof obj === "object" && typeof obj.safeParse === "function" && "_def" in obj;
 }
+function hasStrictUnsafeShape(node, inProperty = false) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) {
+    return node.some((item) => hasStrictUnsafeShape(item, inProperty));
+  }
+  if (typeof node.$ref === "string") {
+    return true;
+  }
+  const hasType = typeof node.type === "string" || Array.isArray(node.type) && node.type.length > 0;
+  const hasProperties = !!node.properties && typeof node.properties === "object" && !Array.isArray(node.properties);
+  const hasItems = node.items !== void 0;
+  const hasComposite = ["anyOf", "oneOf", "allOf"].some((key) => Array.isArray(node[key]) && node[key].length > 0);
+  if (inProperty && !hasType && !hasProperties && !hasItems) {
+    return true;
+  }
+  if (inProperty && hasComposite && !hasType) {
+    return true;
+  }
+  if (hasProperties) {
+    for (const value of Object.values(node.properties)) {
+      if (hasStrictUnsafeShape(value, true)) {
+        return true;
+      }
+    }
+  }
+  if (node.items && hasStrictUnsafeShape(node.items, false)) {
+    return true;
+  }
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    if (Array.isArray(node[key]) && hasStrictUnsafeShape(node[key], false)) {
+      return true;
+    }
+  }
+  for (const key of ["definitions", "$defs"]) {
+    const defs = node[key];
+    if (defs && typeof defs === "object") {
+      for (const value of Object.values(defs)) {
+        if (hasStrictUnsafeShape(value, false)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function canUseStrictToolSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return true;
+  }
+  if (isZodSchema(schema)) {
+    return true;
+  }
+  return !hasStrictUnsafeShape(schema);
+}
 function convertToJsonSchema(schema, strict = false) {
   if (!schema || typeof schema !== "object") {
     return { type: "object", properties: {}, required: [], additionalProperties: false };
   }
   if (isZodSchema(schema)) {
-    const converted = zodToJsonSchema(schema, {
+    const converted2 = zodToJsonSchema(schema, {
       $refStrategy: "none",
       ...strict ? { openaiStrictMode: true } : {}
     });
-    delete converted["$schema"];
-    if (!converted.type) converted.type = "object";
-    return converted;
+    delete converted2["$schema"];
+    if (!converted2.type) converted2.type = "object";
+    return converted2;
   }
-  if (!schema.type && schema.properties) {
-    return { type: "object", ...schema };
+  const converted = { ...schema };
+  delete converted["$schema"];
+  if (!converted.type && converted.properties) {
+    return { type: "object", ...converted };
   }
-  return schema;
+  return converted;
 }
 function normalizeStrictSchema(schema) {
   if (!schema || typeof schema !== "object") return schema;
   const clone2 = { ...schema };
+  if (typeof clone2.format === "string") {
+    delete clone2.format;
+  }
   if (clone2.type === "object" || clone2.properties) {
     if (!clone2.type) clone2.type = "object";
     if (clone2.properties && typeof clone2.properties === "object") {
@@ -7144,20 +7235,25 @@ function toToolDefinition(tool, strict) {
   let name;
   let description;
   let parameters;
+  let rawSchema;
+  let useStrict = strict ?? false;
   if (tool.type === "function" && tool.function) {
     name = tool.function.name;
     description = tool.function.description ?? "";
-    parameters = tool.function.parameters ?? { type: "object", properties: {}, additionalProperties: false };
+    rawSchema = tool.function.parameters ?? { type: "object", properties: {}, additionalProperties: false };
   } else {
     name = tool.name ?? "unknown";
     description = tool.description ?? "";
-    const rawSchema = tool.schema ?? tool.parameters;
-    parameters = convertToJsonSchema(rawSchema, strict);
+    rawSchema = tool.schema ?? tool.parameters;
+  }
+  if (useStrict && !canUseStrictToolSchema(rawSchema)) {
+    useStrict = false;
   }
-  if (strict) {
+  parameters = convertToJsonSchema(rawSchema, useStrict);
+  if (useStrict) {
     parameters = normalizeStrictSchema(parameters);
   }
-  return { name, description, parameters, ...strict ? { strict: true } : {} };
+  return { name, description, parameters, ...useStrict ? { strict: true } : {} };
 }
 function toBaseChatMessage(response) {
   const msg = {