@cognipeer/agent-sdk 0.10.2 → 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,
@@ -6156,6 +6365,9 @@ function isSyntheticSummaryMessage(message) {
   }
   return false;
 }
+function isCompactedToolContent(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"));
+}
 
 // src/structuredOutput/manager.ts
 var StructuredOutputManager = class {
@@ -8072,6 +8284,10 @@ function collectRecentTurns(messages, lastTurnsToKeep) {
 function renderStructuredSummary(summary) {
   if (!summary) return "";
   const lines = ["Context summary:"];
+  if (summary.user_directives && summary.user_directives.length > 0) {
+    lines.push("User directives (still in force \u2014 follow them):");
+    lines.push(...summary.user_directives.map((directive) => `- ${directive}`));
+  }
   if (summary.stable_facts.length > 0) {
     lines.push("Stable facts:");
     lines.push(...summary.stable_facts.map((fact) => `- ${fact.key}: ${fact.value}`));
@@ -8147,17 +8363,46 @@ function clampToBudget(messages, maxContextTokens) {
   }
   return working;
 }
+function collectSummaryOnlyBody(body, hasSummary, lastTurnsToKeep) {
+  if (!hasSummary) {
+    return collectRecentTurns(body, Math.max(1, lastTurnsToKeep));
+  }
+  let boundary = -1;
+  for (let index = body.length - 1; index >= 0; index -= 1) {
+    if (isSyntheticSummaryMessage(body[index])) {
+      boundary = index;
+      break;
+    }
+  }
+  let lastUserIndex = -1;
+  for (let index = body.length - 1; index >= 0; index -= 1) {
+    if (body[index].role === "user") {
+      lastUserIndex = index;
+      break;
+    }
+  }
+  const keep = /* @__PURE__ */ new Set();
+  const firstUserIndex = body.findIndex((message) => message.role === "user");
+  if (firstUserIndex >= 0) keep.add(firstUserIndex);
+  const verbatimFrom = Math.min(lastUserIndex >= 0 ? lastUserIndex : body.length, boundary + 1);
+  for (let index = Math.max(0, verbatimFrom); index < body.length; index += 1) {
+    if (!isSyntheticSummaryMessage(body[index])) keep.add(index);
+  }
+  return body.filter((_, index) => keep.has(index));
+}
 function buildModelMessages(state, config) {
   const rawMessages = state.messages || [];
   if (config.context.policy === "raw") {
     return clampToBudget(rawMessages, config.limits.maxContextTokens);
   }
-  const recentMessages = collectRecentTurns(rawMessages, config.context.lastTurnsToKeep);
   const latestSummary = state.summaryRecords?.[state.summaryRecords.length - 1];
   const summaryText = renderStructuredSummary(latestSummary);
   const memoryText = renderMemoryBlock(state.memoryFacts);
-  const systemMessage2 = recentMessages[0]?.role === "system" ? recentMessages[0] : void 0;
-  const body = systemMessage2 ? recentMessages.slice(1) : recentMessages;
+  const systemMessage2 = rawMessages[0]?.role === "system" ? rawMessages[0] : void 0;
+  const body = config.context.policy === "summary_only" ? collectSummaryOnlyBody(systemMessage2 ? rawMessages.slice(1) : rawMessages, Boolean(summaryText), config.context.lastTurnsToKeep) : (() => {
+    const recentMessages = collectRecentTurns(rawMessages, config.context.lastTurnsToKeep);
+    return recentMessages[0]?.role === "system" ? recentMessages.slice(1) : recentMessages;
+  })();
   const syntheticContextMessages = [];
   if (summaryText) {
     syntheticContextMessages.push({ role: "system", name: "context_summary", content: summaryText });
@@ -8168,7 +8413,7 @@ function buildModelMessages(state, config) {
   const assembled = [
     ...systemMessage2 ? [systemMessage2] : [],
     ...syntheticContextMessages,
-    ...config.context.policy === "summary_only" ? body.filter((message) => message.role === "user" || message.role === "assistant").slice(-2) : body
+    ...body
   ];
   return clampToBudget(assembled, config.limits.maxContextTokens);
 }
@@ -8213,6 +8458,7 @@ function extractJsonObject(text) {
 }
 function normalizeStructuredSummary(input, fallbackText) {
   const summary = {
+    user_directives: Array.isArray(input?.user_directives) ? input.user_directives.map((directive) => String(directive ?? "").trim()).filter(Boolean) : [],
     stable_facts: Array.isArray(input?.stable_facts) ? input.stable_facts.filter((fact) => fact && typeof fact === "object").map((fact) => ({
       key: String(fact.key || "unknown"),
       value: String(fact.value || ""),
@@ -8273,7 +8519,7 @@ function extractCanonicalFacts(messages) {
   return [...facts.values()];
 }
 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"));
+  return isCompactedToolContent(content);
 }
 function collectLatestTurnToolCallIds(messages) {
   const ids = /* @__PURE__ */ new Set();
@@ -8332,11 +8578,16 @@ function runIntegrityCheck(previous, current) {
   const previousKeys = new Set((previous?.stable_facts || []).map((fact) => fact.key));
   const currentKeys = new Set(current.stable_facts.map((fact) => fact.key));
   const obsoleteKeys = new Set(current.discarded_obsolete);
-  const criticalFactLoss = [...previousKeys].some((key) => !obsoleteKeys.has(key) && !currentKeys.has(key));
+  const currentDirectives = new Set(current.user_directives || []);
+  const lostDirectives = (previous?.user_directives || []).filter((directive) => !currentDirectives.has(directive) && !obsoleteKeys.has(directive));
+  const criticalFactLoss = [...previousKeys].some((key) => !obsoleteKeys.has(key) && !currentKeys.has(key)) || lostDirectives.length > 0;
   const obsoleteFactRevived = current.stable_facts.some((fact) => obsoleteKeys.has(fact.key));
   if (criticalFactLoss) {
     notes.push("Missing previously retained facts; merged forward during integrity repair.");
   }
+  if (lostDirectives.length > 0) {
+    notes.push(`Dropped ${lostDirectives.length} user directive(s); merged forward during integrity repair.`);
+  }
   if (obsoleteFactRevived) {
     notes.push("Obsolete facts reappeared; removed during integrity repair.");
   }
@@ -8359,7 +8610,13 @@ function repairStructuredSummary(previous, current, integrity) {
     }
   }
   const filteredFacts = integrity.obsoleteFactRevived ? nextFacts.filter((fact) => !current.discarded_obsolete.includes(fact.key)) : nextFacts;
-  return { ...current, stable_facts: filteredFacts };
+  const directives = [...current.user_directives || []];
+  for (const directive of previous.user_directives || []) {
+    if (!directives.includes(directive) && !current.discarded_obsolete.includes(directive)) {
+      directives.push(directive);
+    }
+  }
+  return { ...current, user_directives: directives, stable_facts: filteredFacts };
 }
 function createContextSummarizeNode(opts) {
   return async (state) => {
@@ -8433,6 +8690,7 @@ function createContextSummarizeNode(opts) {
 
 Return exactly one JSON object with this schema:
 {
+  "user_directives": [string],
   "stable_facts": [{ "key": string, "value": string, "confidence": number }],
   "active_goals": [string],
   "open_questions": [string],
@@ -8441,6 +8699,7 @@ Return exactly one JSON object with this schema:
 }
 
 Rules:
+- user_directives: standing instructions the user gave about HOW to work or answer for the rest of the conversation (language, format, tone, scope, things to always or never do) that still apply. NOT the tasks or questions themselves \u2014 "read the logs" is a task (an active goal), "always answer in Turkish" is a directive. Copy each directive close to verbatim; never merge, soften or drop one. Carry forward every directive from the previous structured summary unless the user explicitly revoked it \u2014 then put its exact text in discarded_obsolete.
 - Keep stable_facts only for facts that future turns must remember.
 - Put invalidated or superseded fact keys in discarded_obsolete.
 - Preserve active_goals still relevant to the user.
@@ -8508,6 +8767,7 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
       durationMs = Date.now() - startTime;
       structuredSummary = normalizeStructuredSummary(void 0, previousSummary || conversationText.slice(0, 800));
       structuredSummary = mergeStableFacts(structuredSummary, canonicalFacts);
+      structuredSummary.user_directives = [...previousStructuredSummary?.user_directives || []];
       integrity = { passed: true, criticalFactLoss: false, obsoleteFactRevived: false, notes: ["Fallback summary generated locally."] };
       summaryText = renderStructuredSummary(structuredSummary);
       const errorEvent = {
@@ -8742,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}`;
@@ -8858,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;
@@ -8924,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
           };
@@ -8947,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
           };
@@ -16607,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;
@@ -16635,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;
@@ -16654,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;
@@ -16664,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;