@cognipeer/agent-sdk 0.8.10 → 0.8.12

package/dist/index.cjs

@@ -2024,6 +2024,177 @@ function extractMessageText2(message) {
   return "";
 }
 
+// src/smart/toolArgCoercion.ts
+var PLACEHOLDER_TEXT = /* @__PURE__ */ new Set(["", "null", "undefined", "none", "nil", "n/a", "na"]);
+var ENVELOPE_KEYS = ["input", "args", "arguments", "params", "parameters", "payload"];
+function defOf(schema) {
+  const def = schema?._def;
+  return def && typeof def === "object" ? def : null;
+}
+function isPlaceholder(value) {
+  return typeof value === "string" && PLACEHOLDER_TEXT.has(value.trim().toLowerCase());
+}
+function parseJsonish(value) {
+  const text = value.trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return { ok: false };
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+}
+function safeParses(schema, value) {
+  try {
+    return schema.safeParse(value).success === true;
+  } catch {
+    return false;
+  }
+}
+function coerceToolArgs(schema, value) {
+  try {
+    return coerceNode(schema, value, 0);
+  } catch {
+    return value;
+  }
+}
+function coerceNode(schema, value, depth) {
+  if (depth > 12) return value;
+  const def = defOf(schema);
+  if (!def) return value;
+  switch (def.typeName) {
+    case "ZodOptional":
+    case "ZodNullable": {
+      if (value === void 0 || value === null) return value;
+      if (isPlaceholder(value)) return void 0;
+      return coerceNode(def.innerType, value, depth + 1);
+    }
+    case "ZodDefault":
+    case "ZodCatch":
+    case "ZodReadonly":
+    case "ZodBranded":
+      return coerceNode(def.innerType, value, depth + 1);
+    case "ZodEffects":
+      return coerceNode(def.schema, value, depth + 1);
+    case "ZodPipeline":
+      return coerceNode(def.in, value, depth + 1);
+    case "ZodLazy":
+      return coerceNode(def.getter(), value, depth + 1);
+    case "ZodObject":
+      return coerceObject(def, value, depth);
+    case "ZodRecord": {
+      const unwrapped = unwrapJsonString(value);
+      if (!unwrapped || typeof unwrapped !== "object" || Array.isArray(unwrapped)) return unwrapped ?? value;
+      const out = {};
+      for (const [key, entry] of Object.entries(unwrapped)) {
+        out[key] = def.valueType ? coerceNode(def.valueType, entry, depth + 1) : entry;
+      }
+      return out;
+    }
+    case "ZodArray": {
+      const unwrapped = unwrapJsonString(value);
+      const items = Array.isArray(unwrapped) ? unwrapped : unwrapped === void 0 || unwrapped === null ? unwrapped : [unwrapped];
+      if (!Array.isArray(items)) return items;
+      return items.map((item) => coerceNode(def.type, item, depth + 1));
+    }
+    case "ZodTuple": {
+      const unwrapped = unwrapJsonString(value);
+      if (!Array.isArray(unwrapped)) return unwrapped ?? value;
+      const items = def.items ?? [];
+      return unwrapped.map((item, index) => items[index] ? coerceNode(items[index], item, depth + 1) : item);
+    }
+    case "ZodNumber": {
+      if (typeof value === "number") return value;
+      if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value.trim());
+        if (Number.isFinite(parsed)) return parsed;
+      }
+      if (typeof value === "boolean") return value ? 1 : 0;
+      return value;
+    }
+    case "ZodBoolean": {
+      if (typeof value === "boolean") return value;
+      if (typeof value === "string") {
+        const text = value.trim().toLowerCase();
+        if (text === "true" || text === "yes" || text === "1") return true;
+        if (text === "false" || text === "no" || text === "0") return false;
+      }
+      if (value === 1) return true;
+      if (value === 0) return false;
+      return value;
+    }
+    case "ZodString": {
+      if (typeof value === "string") return value;
+      if (typeof value === "number" || typeof value === "boolean") return String(value);
+      if (value && typeof value === "object") {
+        try {
+          return JSON.stringify(value);
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }
+    case "ZodEnum": {
+      if (typeof value !== "string") return value;
+      const values = def.values ?? [];
+      if (values.includes(value)) return value;
+      const match = values.find((option) => option.toLowerCase() === value.trim().toLowerCase());
+      return match ?? value;
+    }
+    case "ZodNativeEnum": {
+      if (typeof value !== "string") return value;
+      const values = Object.values(def.values ?? {}).filter((option) => typeof option === "string");
+      if (values.includes(value)) return value;
+      return values.find((option) => option.toLowerCase() === value.trim().toLowerCase()) ?? value;
+    }
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion": {
+      const options = def.options ? Array.isArray(def.options) ? def.options : Array.from(def.options.values()) : [];
+      for (const option of options) {
+        const candidate = coerceNode(option, value, depth + 1);
+        if (safeParses(option, candidate)) return candidate;
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+}
+function unwrapJsonString(value) {
+  if (typeof value !== "string") return value;
+  if (isPlaceholder(value)) return void 0;
+  const parsed = parseJsonish(value);
+  return parsed.ok ? parsed.value : value;
+}
+function coerceObject(def, value, depth) {
+  const unwrapped = unwrapJsonString(value);
+  if (!unwrapped || typeof unwrapped !== "object" || Array.isArray(unwrapped)) return unwrapped ?? value;
+  const shape = typeof def.shape === "function" ? def.shape() : def.shape ?? {};
+  const shapeKeys = Object.keys(shape);
+  let source = unwrapped;
+  if (depth === 0 && shapeKeys.length > 0) {
+    const keys = Object.keys(source);
+    if (keys.length === 1 && !shapeKeys.includes(keys[0]) && ENVELOPE_KEYS.includes(keys[0].toLowerCase())) {
+      const inner = unwrapJsonString(source[keys[0]]);
+      if (inner && typeof inner === "object" && !Array.isArray(inner)) {
+        source = inner;
+      }
+    }
+  }
+  const out = {};
+  for (const [key, entry] of Object.entries(source)) {
+    const field = shape[key];
+    if (!field) {
+      out[key] = entry;
+      continue;
+    }
+    const coerced = coerceNode(field, entry, depth + 1);
+    if (coerced === void 0) continue;
+    out[key] = coerced;
+  }
+  return out;
+}
+
 // src/smart/toolResponses.ts
 var CONTROL_PLANE_TOOL_NAMES = [
   "response",
@@ -2226,17 +2397,60 @@ Use get_tool_response with executionId "${refId}" only if you must recover the o
 }
 function validateToolArgs(tool, args) {
   const schema = tool.schema;
-  if (!schema || typeof schema.parse !== "function") {
+  if (!schema || typeof schema.safeParse !== "function") {
     return { ok: true, value: args };
   }
-  try {
-    return { ok: true, value: schema.parse(args) };
-  } catch (error) {
-    if (error instanceof zod.ZodError) {
-      const message = error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
-      return { ok: false, message };
-    }
-    return { ok: false, message: error instanceof Error ? error.message : String(error) };
+  const direct = schema.safeParse(args);
+  if (direct.success) {
+    return { ok: true, value: direct.data };
+  }
+  const repaired = schema.safeParse(coerceToolArgs(schema, args));
+  if (repaired.success) {
+    return { ok: true, value: repaired.data, coerced: true };
+  }
+  const error = direct.error;
+  if (error instanceof zod.ZodError) {
+    const issues = error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
+    const expected = describeExpectedArgs(schema);
+    return { ok: false, message: expected ? `${issues}. Expected arguments: ${expected}` : issues };
+  }
+  return { ok: false, message: error instanceof Error ? error.message : String(error) };
+}
+function describeExpectedArgs(schema) {
+  const shape = typeof schema?._def?.shape === "function" ? schema._def.shape() : schema?._def?.shape;
+  if (!shape || typeof shape !== "object") return null;
+  const parts = Object.entries(shape).map(([key, field]) => {
+    const { typeName, optional } = describeField(field);
+    return `${key}${optional ? "?" : ""}: ${typeName}`;
+  });
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+function describeField(field, depth = 0) {
+  const def = field?._def;
+  if (!def || depth > 6) return { typeName: "value", optional: false };
+  switch (def.typeName) {
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodDefault":
+      return { typeName: describeField(def.innerType, depth + 1).typeName, optional: true };
+    case "ZodEffects":
+      return { ...describeField(def.schema, depth + 1), optional: describeField(def.schema, depth + 1).optional };
+    case "ZodObject":
+      return { typeName: "object", optional: false };
+    case "ZodArray":
+      return { typeName: `array of ${describeField(def.type, depth + 1).typeName}`, optional: false };
+    case "ZodRecord":
+      return { typeName: "object", optional: false };
+    case "ZodString":
+      return { typeName: "string", optional: false };
+    case "ZodNumber":
+      return { typeName: "number", optional: false };
+    case "ZodBoolean":
+      return { typeName: "boolean", optional: false };
+    case "ZodEnum":
+      return { typeName: `one of ${(def.values ?? []).join("|")}`, optional: false };
+    default:
+      return { typeName: "value", optional: false };
   }
 }
 
@@ -5095,7 +5309,10 @@ function shouldSignalSummarization(state, threshold) {
   });
   const tokenCount = countMessagesTokens(tokCountMessages);
   if (tokenCount <= threshold) return "skip";
-  if (state.ctx?.__summarizationExhausted) return "skip";
+  if (state.ctx?.__summarizationExhausted) {
+    const exhaustedAt = state.ctx?.__summarizationExhaustedAtToolCount;
+    if (typeof exhaustedAt !== "number" || (state.toolHistory || []).length <= exhaustedAt) return "skip";
+  }
   const hasFreshSummary = (state.messages || []).some(
     (m) => m.role === "tool" && typeof m.content === "string" && (m.content === "SUMMARIZED" || m.content.startsWith("SUMMARIZED_TOOL_RESPONSE"))
   );
@@ -6140,6 +6357,20 @@ function extractCanonicalFacts(messages) {
 function isSummarizedToolPlaceholder(content) {
   return typeof content === "string" && (content === "SUMMARIZED" || content.startsWith("SUMMARIZED_TOOL_RESPONSE") || content.startsWith("ARCHIVED_TOOL_RESPONSE") || content.startsWith("STRUCTURED_TOOL_RESPONSE") || content.startsWith("DROPPED_TOOL_RESPONSE"));
 }
+function collectLatestTurnToolCallIds(messages) {
+  const ids = /* @__PURE__ */ new Set();
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (isSyntheticSummaryMessage(m)) continue;
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      for (const tc of m.tool_calls) {
+        if (tc.id) ids.add(tc.id);
+      }
+      break;
+    }
+  }
+  return ids;
+}
 function findToolHistoryEntry(state, toolCallId, toolName) {
   const entries = [
     ...state.toolHistory || [],
@@ -6234,6 +6465,10 @@ function createContextSummarizeNode(opts) {
     if (compressableMessages.length === 0) {
       return {};
     }
+    const protectedToolCallIds = collectLatestTurnToolCallIds(messages);
+    if (compressableMessages.every((m) => m.tool_call_id && protectedToolCallIds.has(m.tool_call_id))) {
+      return {};
+    }
     const tokenCountBefore = countMessagesTokens(messages);
     const summaryPromptMaxTokens = config.summaryPromptMaxTokens;
     const availableTokensForConversation = summaryPromptMaxTokens - 500;
@@ -6253,7 +6488,8 @@ function createContextSummarizeNode(opts) {
         const historyEntry = findToolHistoryEntry(state, m.tool_call_id, m.name);
         if (historyEntry) {
           const original = historyEntry.rawOutput ?? historyEntry.output;
-          content = typeof original === "string" ? original : JSON.stringify(original);
+          const recovered = typeof original === "string" ? original : JSON.stringify(original);
+          if (typeof recovered === "string") content = recovered;
         }
       }
       const maxContentLength = 2e3;
@@ -6392,22 +6628,6 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
         });
       }
     });
-    const protectedToolCallIds = /* @__PURE__ */ new Set();
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const m = messages[i];
-      if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
-        const thisToolCallIds = new Set(m.tool_calls.map((tc) => tc.id).filter(Boolean));
-        const otherCompressable = compressableMessages.filter(
-          (cm) => !thisToolCallIds.has(cm.tool_call_id)
-        );
-        if (otherCompressable.length > 0) {
-          for (const tc of m.tool_calls) {
-            if (tc.id) protectedToolCallIds.add(tc.id);
-          }
-        }
-        break;
-      }
-    }
     const retentionDeclarations = collectToolRetentionDeclarations(state.agent?.tools);
     const digestableToolCallIds = /* @__PURE__ */ new Set();
     for (const m of messages) {
@@ -7992,11 +8212,16 @@ function createSmartAgent(opts) {
     if (!summarizer) return { state: currentState, rawMessages: currentRawMessages, compressed: false };
     const delta = await summarizer(currentState);
     if (!delta || Object.keys(delta).length === 0) {
-      const ctx2 = { ...currentState.ctx || {}, __summarizationExhausted: true };
+      const ctx2 = {
+        ...currentState.ctx || {},
+        __summarizationExhausted: true,
+        __summarizationExhaustedAtToolCount: (currentState.toolHistory || []).length
+      };
       return { state: { ...currentState, ctx: ctx2 }, rawMessages: currentRawMessages, compressed: false };
     }
     const ctx = { ...currentState.ctx || {} };
     delete ctx.__summarizationExhausted;
+    delete ctx.__summarizationExhaustedAtToolCount;
     const updated = await persistLatestSummary(syncPlanStateWith(ref, { ...currentState, ...delta, ctx }));
     return { state: updated, rawMessages: [...updated.messages || currentRawMessages], compressed: true };
   }
@@ -11059,6 +11284,43 @@ function convertToJsonSchema(schema, strict = false) {
   }
   return converted;
 }
+function simplifyOptionalNullableUnions(schema, required = null) {
+  if (!schema || typeof schema !== "object") return schema;
+  const clone2 = { ...schema };
+  if (clone2.properties && typeof clone2.properties === "object") {
+    const requiredKeys = new Set(Array.isArray(clone2.required) ? clone2.required : []);
+    const properties = {};
+    for (const [key, value] of Object.entries(clone2.properties)) {
+      const child = simplifyOptionalNullableUnions(value, requiredKeys);
+      properties[key] = requiredKeys.has(key) ? child : dropNullBranch(child);
+    }
+    clone2.properties = properties;
+  }
+  if (clone2.items) clone2.items = simplifyOptionalNullableUnions(clone2.items, required);
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    if (Array.isArray(clone2[key])) {
+      clone2[key] = clone2[key].map((entry) => simplifyOptionalNullableUnions(entry, required));
+    }
+  }
+  return clone2;
+}
+function dropNullBranch(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema.type) && schema.type.includes("null") && schema.type.length === 2) {
+    return { ...schema, type: schema.type.find((entry) => entry !== "null") };
+  }
+  if (Array.isArray(schema.anyOf)) {
+    const branches = schema.anyOf.filter((entry) => entry?.type !== "null");
+    if (branches.length === 1 && branches.length !== schema.anyOf.length) {
+      const { anyOf, ...rest } = schema;
+      return { ...branches[0], ...rest };
+    }
+    if (branches.length !== schema.anyOf.length && branches.length > 1) {
+      return { ...schema, anyOf: branches };
+    }
+  }
+  return schema;
+}
 function normalizeStrictSchema(schema) {
   if (!schema || typeof schema !== "object") return schema;
   const clone2 = { ...schema };
@@ -11123,6 +11385,8 @@ function toToolDefinition(tool, strict) {
   parameters = convertToJsonSchema(rawSchema, useStrict);
   if (useStrict) {
     parameters = normalizeStrictSchema(parameters);
+  } else {
+    parameters = simplifyOptionalNullableUnions(parameters);
   }
   return { name, description, parameters, ...useStrict ? { strict: true } : {} };
 }
@@ -11295,6 +11559,7 @@ exports.canOpenSkill = canOpenSkill;
 exports.canSpawn = canSpawn;
 exports.captureSnapshot = captureSnapshot;
 exports.codePresenceRule = codePresenceRule;
+exports.coerceToolArgs = coerceToolArgs;
 exports.cognipeerSink = cognipeerSink;
 exports.collectToolRetentionDeclarations = collectToolRetentionDeclarations;
 exports.composeToolSets = composeToolSets;
@@ -11389,6 +11654,7 @@ exports.summarizeObject = summarizeObject;
 exports.tokenize = tokenize;
 exports.traceSessionToOtlp = traceSessionToOtlp;
 exports.validateReasoningConfig = validateReasoningConfig;
+exports.validateToolArgs = validateToolArgs;
 exports.withTools = withTools;
 exports.withinDepth = withinDepth;
 exports.writeSummaryFactsToMemory = writeSummaryFactsToMemory;