@cognipeer/agent-sdk 0.8.9 → 0.8.11

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 };
   }
 }
 
@@ -4299,7 +4513,7 @@ var LEVEL_DEFAULTS = {
 };
 var VALID_LEVELS = ["minimal", "low", "medium", "high"];
 var VALID_CADENCES = ["off", "every_turn", "after_tool", "on_branch", "initial_then_after_tool"];
-var VALID_EFFORTS = ["minimal", "low", "medium", "high"];
+var VALID_EFFORTS = ["none", "minimal", "low", "medium", "high"];
 function validateReasoningConfig(input) {
   if (!input) return;
   if (input.level !== void 0 && !VALID_LEVELS.includes(input.level)) {
@@ -8793,12 +9007,19 @@ function parseSSEBlock(block) {
 
 // src/providers/utils/reasoning.ts
 var ANTHROPIC_EFFORT_BUDGET = {
+  // 0 = off. `applyAnthropicReasoning` bails on a falsy budget and emits no
+  // thinking block, which on Anthropic IS off — thinking there is opt-in.
+  none: 0,
   minimal: 1024,
   low: 2048,
   medium: 8192,
   high: 16384
 };
 var GEMINI_EFFORT_BUDGET = {
+  // 0 is Gemini's own documented spelling for "do not think", and unlike
+  // Anthropic it has to be SENT — hence `applyGeminiReasoning` testing for null
+  // rather than falsiness.
+  none: 0,
   minimal: 512,
   low: 1024,
   medium: 4096,
@@ -8874,14 +9095,15 @@ function clampBudget(budget, maxTokens) {
 }
 function normalizeEffort(effort) {
   if (!effort) return void 0;
-  const allowed = ["minimal", "low", "medium", "high"];
+  const allowed = ["none", "minimal", "low", "medium", "high"];
   return allowed.includes(effort) ? effort : void 0;
 }
 function resolveBudget(reasoning, effortBudget) {
+  const effort = normalizeEffort(reasoning.effort);
+  if (effort === "none") return 0;
   if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
     return Math.floor(reasoning.budgetTokens);
   }
-  const effort = normalizeEffort(reasoning.effort);
   if (effort && effortBudget[effort]) return effortBudget[effort];
   return void 0;
 }
@@ -8970,12 +9192,21 @@ var OpenAIProvider = class extends BaseProvider {
       ...config.defaultHeaders,
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
+    this.responsesApi = config.responsesApi ?? "auto";
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
-  /** True when the request targets a reasoning model (o-series / gpt-5) so we
-   * should route through the Responses API, which exposes `reasoning.effort`
-   * and reasoning summaries. Chat Completions silently drops these. */
+  /** True when this request should go to the Responses API rather than Chat
+   * Completions — which exposes `reasoning.effort` and reasoning summaries that
+   * Chat Completions silently drops.
+   *
+   * `auto` (the default) keeps the historical rule: only when the request
+   * carries a reasoning config AND the model name looks like an o-series/gpt-5
+   * model. `never`/`always` let a caller state the answer instead, because the
+   * name check is a guess and the two APIs differ in far more than reasoning —
+   * see `responsesApi` in OpenAIProviderConfig. */
   useResponsesApi(request) {
+    if (this.responsesApi === "never") return false;
+    if (this.responsesApi === "always") return true;
     if (!request.reasoning) return false;
     return isReasoningModel(request.model || this.defaultModel);
   }
@@ -10838,7 +11069,7 @@ function fromNativeProvider(provider, options) {
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
     const reasoningOverride = invokeOptions?.reasoning;
-    const reasoningCfg = reasoningOverride ?? opts?.reasoning;
+    const reasoningCfg = mergeReasoning(opts?.reasoning, reasoningOverride);
     if (reasoningCfg) req.reasoning = reasoningCfg;
     const tc = invokeOptions?.tool_choice ?? invokeOptions?.toolChoice;
     if (tc && tools?.length) {
@@ -10867,6 +11098,15 @@ function fromNativeProvider(provider, options) {
     return req;
   }
 }
+function mergeReasoning(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  const merged = { ...base, ...override };
+  if (base.providerExtras || override.providerExtras) {
+    merged.providerExtras = { ...base.providerExtras, ...override.providerExtras };
+  }
+  return merged;
+}
 function toUnifiedMessage(msg) {
   const unified = {
     role: msg.role,
@@ -11033,6 +11273,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 };
@@ -11097,6 +11374,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 } : {} };
 }
@@ -11269,6 +11548,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;
@@ -11363,6 +11643,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;