@cognipeer/agent-sdk 0.10.3 → 0.10.4

package/dist/index.cjs

@@ -513,7 +513,7 @@ function getModelCapabilities(model) {
     return {
       provider,
       structuredOutput: supportsNativeStructuredOutput(provider) ? "native" : "tool_based",
-      strictToolCalling: requiresStrictToolCalling(provider),
+      strictToolCalling: requiresStrictToolCalling(provider) && isOpenAIHostedEndpoint(model._lc),
       streaming: true
     };
   }
@@ -556,6 +556,17 @@ function supportsNativeStructuredOutput(provider) {
 function requiresStrictToolCalling(provider) {
   return ["openai"].includes(provider);
 }
+function isOpenAIHostedEndpoint(lcModel) {
+  if (!lcModel) return true;
+  const baseURL = lcModel.clientConfig?.baseURL ?? lcModel.configuration?.baseURL ?? lcModel.baseURL;
+  if (typeof baseURL !== "string" || baseURL.trim() === "") return true;
+  try {
+    const host = new URL(baseURL).hostname.toLowerCase();
+    return host === "api.openai.com" || host.endsWith(".openai.azure.com") || host.endsWith(".cognitiveservices.azure.com");
+  } catch {
+    return false;
+  }
+}
 
 // src/model.ts
 function isSmartModel(m) {
@@ -2520,13 +2531,19 @@ function resolveCapabilities(provider) {
   switch (provider) {
     case "openai":
     case "azure":
-    case "openai-compatible":
       return {
         structuredOutput: "native",
         strictToolCalling: true,
         streaming: true,
         provider
       };
+    case "openai-compatible":
+      return {
+        structuredOutput: "native",
+        strictToolCalling: false,
+        streaming: true,
+        provider
+      };
     case "anthropic":
       return {
         structuredOutput: "tool_based",
@@ -3855,6 +3872,187 @@ Identical to an earlier ${duplicate.toolName} result. Use get_tool_response with
   }
   return notApplied4(output);
 }
+var identity = (value) => value;
+function describeLike(schema, source, suffix) {
+  const description = [source.description, suffix].filter(Boolean).join(" ");
+  return description ? schema.describe(description) : schema;
+}
+function jsonString(source) {
+  return {
+    schema: describeLike(zod.z.string(), source, "(a JSON value, encoded as a string)"),
+    restore: (value) => {
+      if (typeof value !== "string") return value;
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+  };
+}
+function unwrapOptional(schema) {
+  const def = schema._def;
+  if (def?.typeName === "ZodOptional") return { inner: def.innerType, optional: true };
+  if (def?.typeName === "ZodDefault") return { inner: def.innerType, optional: true };
+  return { inner: schema, optional: false };
+}
+function isZodSchema2(schema) {
+  return Boolean(schema) && typeof schema.safeParse === "function" && Boolean(schema._def);
+}
+function toStrictCompatible(schema) {
+  const def = schema?._def;
+  switch (def?.typeName) {
+    case "ZodObject": {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      const keys = Object.keys(shape ?? {});
+      const open = def.unknownKeys === "passthrough" || def.catchall && def.catchall._def?.typeName !== "ZodNever";
+      if (keys.length === 0 && open) return jsonString(schema);
+      const nextShape = {};
+      const restores = {};
+      for (const key of keys) {
+        const field = shape[key];
+        const { inner, optional } = unwrapOptional(field);
+        const child = toStrictCompatible(inner);
+        const childSchema = describeLike(child.schema, field.description ? field : inner);
+        nextShape[key] = optional ? childSchema.nullable() : childSchema;
+        restores[key] = { restore: child.restore, optional };
+      }
+      return {
+        schema: describeLike(zod.z.object(nextShape), schema),
+        restore: (value) => {
+          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+          const out = {};
+          for (const [key, raw] of Object.entries(value)) {
+            const entry = restores[key];
+            if (raw === null && entry?.optional) continue;
+            out[key] = entry ? entry.restore(raw) : raw;
+          }
+          return out;
+        }
+      };
+    }
+    case "ZodOptional":
+    case "ZodDefault": {
+      const child = toStrictCompatible(def.innerType);
+      return {
+        schema: describeLike(child.schema.nullable(), schema),
+        restore: (value) => value === null ? void 0 : child.restore(value)
+      };
+    }
+    case "ZodNullable": {
+      const child = toStrictCompatible(def.innerType);
+      return {
+        schema: describeLike(child.schema.nullable(), schema),
+        restore: (value) => value === null ? null : child.restore(value)
+      };
+    }
+    case "ZodArray": {
+      const child = toStrictCompatible(def.type);
+      return {
+        schema: describeLike(zod.z.array(child.schema), schema),
+        restore: (value) => Array.isArray(value) ? value.map(child.restore) : value
+      };
+    }
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion": {
+      const rawOptions = def.options instanceof Map ? [...def.options.values()] : def.options;
+      const options = rawOptions.map(toStrictCompatible);
+      if (options.length === 1) return options[0];
+      if (options.every((option, index) => option.schema === rawOptions[index])) {
+        return { schema, restore: identity };
+      }
+      return {
+        schema: describeLike(zod.z.union(options.map((option) => option.schema)), schema),
+        restore: (value) => {
+          const candidates = options.map((option) => option.restore(value));
+          const index = candidates.findIndex((candidate, i) => rawOptions[i].safeParse(candidate).success);
+          return candidates[index >= 0 ? index : 0];
+        }
+      };
+    }
+    case "ZodEffects":
+      return toStrictCompatible(def.schema);
+    case "ZodRecord":
+    case "ZodAny":
+    case "ZodUnknown":
+      return jsonString(schema);
+    default:
+      return { schema, restore: identity };
+  }
+}
+function topLevelObject(transform) {
+  if (transform.schema._def?.typeName === "ZodObject") return transform;
+  return {
+    schema: zod.z.object({
+      input: transform.schema.describe(
+        transform.schema.description ?? "The tool arguments as a JSON object, encoded as a string"
+      )
+    }),
+    restore: (value) => {
+      const input = value && typeof value === "object" ? value.input : void 0;
+      const restored = transform.restore(input);
+      return restored && typeof restored === "object" ? restored : {};
+    }
+  };
+}
+function toStrictToolSchema(schema) {
+  return topLevelObject(toStrictCompatible(schema));
+}
+function restoreToolCalls(message, restorers) {
+  if (!message || typeof message !== "object" || restorers.size === 0) return message;
+  const restoreList = (calls) => {
+    if (!Array.isArray(calls) || calls.length === 0) return calls;
+    return calls.map((call) => {
+      const fn = call?.function;
+      const name = call?.name ?? fn?.name;
+      const restore = name ? restorers.get(name) : void 0;
+      if (!restore) return call;
+      let next = call;
+      if (call.args && typeof call.args === "object") next = { ...next, args: restore(call.args) };
+      if (fn && typeof fn.arguments === "string") {
+        try {
+          next = { ...next, function: { ...fn, arguments: JSON.stringify(restore(JSON.parse(fn.arguments))) } };
+        } catch {
+        }
+      }
+      return next;
+    });
+  };
+  const m = message;
+  const hasDirect = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;
+  const hasKwargs = Array.isArray(m.additional_kwargs?.tool_calls) && m.additional_kwargs.tool_calls.length > 0;
+  if (!hasDirect && !hasKwargs) return message;
+  return {
+    ...message,
+    ...hasDirect ? { tool_calls: restoreList(m.tool_calls) } : {},
+    ...hasKwargs ? { additional_kwargs: { ...m.additional_kwargs, tool_calls: restoreList(m.additional_kwargs.tool_calls) } } : {}
+  };
+}
+var strictViews = /* @__PURE__ */ new WeakMap();
+function prepareStrictToolMenu(tools) {
+  const restorers = /* @__PURE__ */ new Map();
+  const menu = tools.map((tool) => {
+    const t = tool;
+    if (!t || typeof t.name !== "string" || !isZodSchema2(t.schema)) return tool;
+    const cached = strictViews.get(tool);
+    if (cached && cached.schema === t.schema) {
+      restorers.set(t.name, cached.restore);
+      return cached.view;
+    }
+    try {
+      const transform = toStrictToolSchema(t.schema);
+      const view = Object.create(tool);
+      view.schema = transform.schema;
+      view.__lcTool = void 0;
+      strictViews.set(tool, { schema: t.schema, view, restore: transform.restore });
+      restorers.set(t.name, transform.restore);
+      return view;
+    } catch {
+      return tool;
+    }
+  });
+  return { menu, restorers };
+}
 
 // src/nodes/agentCore.ts
 function createAgentCoreNode(opts) {
@@ -3875,10 +4073,17 @@ function createAgentCoreNode(opts) {
     };
     let tools = runtime.tools ?? [];
     const shouldUseStrictToolCalling = Boolean(
-      runtime.responseFormat && runtime.model?.capabilities?.strictToolCalling
+      runtime.model?.capabilities?.strictToolCalling
     );
+    let strictRestorers = /* @__PURE__ */ new Map();
+    const wireMenu = (menu) => {
+      if (!shouldUseStrictToolCalling) return menu;
+      const prepared = prepareStrictToolMenu(menu);
+      strictRestorers = prepared.restorers;
+      return prepared.menu;
+    };
     const bindToolMenu = (menu) => runtime.model?.bindTools ? runtime.model.bindTools(
-      menu,
+      wireMenu(menu),
       shouldUseStrictToolCalling ? { strict: true } : void 0
     ) : runtime.model;
     const menuMutationReachesProvider = typeof runtime.model?.bindTools === "function";
@@ -3889,7 +4094,8 @@ function createAgentCoreNode(opts) {
     const computeTraceToolDefinitions = (menu) => {
       if (!traceSession || !traceSession.resolvedConfig.logData || menu.length === 0) return void 0;
       try {
-        return menu.map((tool) => {
+        const wire = shouldUseStrictToolCalling ? prepareStrictToolMenu(menu).menu : menu;
+        return wire.map((tool) => {
           const def = toToolDefinition(tool, shouldUseStrictToolCalling ? true : void 0);
           return { name: def.name, description: def.description || void 0, parameters: def.parameters };
         });
@@ -4195,6 +4401,9 @@ ${append}`;
           throw err;
         }
       }
+      if (shortCircuited === void 0 && strictRestorers.size > 0) {
+        response = restoreToolCalls(response, strictRestorers);
+      }
       if (!host?.has("postModelCall")) break;
       const postGate = await host.runGate("postModelCall", {
         message: response,
@@ -8793,6 +9002,21 @@ var todoUpdateItemSchema = zod.z.object({
   status: todoStatusSchema.optional(),
   evidence: zod.z.string().max(300).optional()
 });
+var todoItemWireSchema = zod.z.object({
+  id: zod.z.number().int().min(1).describe("Sequential id starting from 1 (write) or an existing id (update)"),
+  step: zod.z.string().min(1).optional(),
+  title: zod.z.string().min(1).optional(),
+  description: zod.z.string().min(1).optional(),
+  owner: zod.z.string().min(1).optional(),
+  exitCriteria: zod.z.string().min(1).optional(),
+  status: todoStatusSchema.optional().describe("Required for every item on write"),
+  evidence: zod.z.string().max(300).optional()
+});
+function describeTodoIssue(issue) {
+  if (!issue) return void 0;
+  const path2 = issue.path.length > 0 ? `todoList[${issue.path[0]}]${issue.path.slice(1).map((p) => `.${String(p)}`).join("")}` : "todoList";
+  return `${path2}: ${issue.message}`;
+}
 function normalizeTodoItem(item, existing) {
   const id = item.id ?? existing?.id;
   const step = item.step || item.title || item.description || existing?.step || existing?.title || existing?.description || `Step ${id}`;
@@ -8909,7 +9133,7 @@ function createPlanTool(stateRef, toolName, description) {
     schema: zod.z.object({
       operation: zod.z.enum(["write", "read", "update"]),
       expectedVersion: zod.z.number().int().min(0).optional(),
-      todoList: zod.z.array(zod.z.union([todoWriteItemSchema, todoUpdateItemSchema])).optional()
+      todoList: zod.z.array(todoItemWireSchema).optional()
     }),
     func: async ({ operation, expectedVersion, todoList }) => {
       const toolStateRef = manageTodo._stateRef;
@@ -8975,7 +9199,10 @@ function createPlanTool(stateRef, toolName, description) {
           return {
             status: "error",
             operation,
-            error: parsed.error.issues[0]?.message || "Invalid todoList for write.",
+            // The wire schema has `status` optional (one shape for write and
+            // update), so a missing one is caught here — named, so the model
+            // can fix the call.
+            error: describeTodoIssue(parsed.error.issues[0]) || "Invalid todoList for write.",
             version: currentVersion,
             adherenceScore: stateRef.adherenceScore || 0
           };
@@ -8998,7 +9225,7 @@ function createPlanTool(stateRef, toolName, description) {
           return {
             status: "error",
             operation,
-            error: parsed.error.issues[0]?.message || "Invalid todoList for update.",
+            error: describeTodoIssue(parsed.error.issues[0]) || "Invalid todoList for update.",
             version: currentVersion,
             adherenceScore: stateRef.adherenceScore || 0
           };
@@ -16658,6 +16885,7 @@ exports.httpSink = httpSink;
 exports.inMemoryCheckpointStore = inMemoryCheckpointStore;
 exports.inMemoryConversationStore = inMemoryConversationStore;
 exports.isHookImplemented = isHookImplemented;
+exports.isOpenAIHostedEndpoint = isOpenAIHostedEndpoint;
 exports.isSmartModel = isSmartModel;
 exports.isValidIban = isValidIban;
 exports.isValidLuhn = isValidLuhn;
@@ -16686,6 +16914,7 @@ exports.portkeyGateway = portkeyGateway;
 exports.portkeyGuardrail = portkeyGuardrail;
 exports.preopenSkills = preopenSkills;
 exports.preopenToolCallId = preopenToolCallId;
+exports.prepareStrictToolMenu = prepareStrictToolMenu;
 exports.promptInjectionGuard = promptInjectionGuard;
 exports.rateLimit = rateLimit;
 exports.readMemoryFacts = readMemoryFacts;
@@ -16705,6 +16934,7 @@ exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.resolveUserQuestionState = resolveUserQuestionState;
 exports.responseCache = responseCache;
 exports.restoreSnapshot = restoreSnapshot;
+exports.restoreToolCalls = restoreToolCalls;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
 exports.scoreItemsByRelevance = scoreItemsByRelevance;
 exports.searchSkills = searchSkills;
@@ -16715,6 +16945,8 @@ exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.summarizeObject = summarizeObject;
 exports.textFromContent = textFromContent;
+exports.toStrictCompatible = toStrictCompatible;
+exports.toStrictToolSchema = toStrictToolSchema;
 exports.tokenize = tokenize;
 exports.toolPolicy = toolPolicy;
 exports.traceSessionToOtlp = traceSessionToOtlp;