@cognipeer/agent-sdk 0.8.11 → 0.9.0

package/dist/index.cjs

@@ -5309,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"))
   );
@@ -6354,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 || [],
@@ -6448,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;
@@ -6467,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;
@@ -6606,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) {
@@ -7550,6 +7556,127 @@ function createSkillTools(deps) {
   if (isSearchDisclosure(deps.policy)) tools.unshift(createSearchSkillsTool(deps));
   return tools;
 }
+var PREOPEN_TOOL_CALL_PREFIX = "preopen_skill_";
+var OPEN_SKILL_TOOL_NAME = "open_skill";
+function preopenToolCallId(skillKey) {
+  return `${PREOPEN_TOOL_CALL_PREFIX}${skillKey.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function messagesContainCallId(messages, callId) {
+  if (!Array.isArray(messages)) return false;
+  return messages.some((message) => {
+    const calls = message?.tool_calls;
+    return Array.isArray(calls) && calls.some((call) => call?.id === callId);
+  });
+}
+function serializeToolContent(result) {
+  if (typeof result === "string") return result;
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+async function preopenSkills(input) {
+  const empty = { messages: [], toolHistory: [], openedKeys: [], skipped: [] };
+  const requested = [...new Set(
+    (input.skillKeys ?? []).map((key) => String(key ?? "").trim()).filter(Boolean)
+  )];
+  if (requested.length === 0) return empty;
+  const openSkillTool = input.tools.find((tool) => tool?.name === OPEN_SKILL_TOOL_NAME);
+  if (!openSkillTool) {
+    return { ...empty, skipped: requested.map((skillKey) => ({ skillKey, reason: "open_skill tool is not wired" })) };
+  }
+  const alreadyOpen = new Set(input.alreadyOpenedKeys ?? []);
+  const toolCalls = [];
+  const toolMessages = [];
+  const toolHistory = [];
+  const openedKeys = [];
+  const skipped = [];
+  for (const skillKey of requested) {
+    const toolCallId = preopenToolCallId(skillKey);
+    if (alreadyOpen.has(skillKey) || messagesContainCallId(input.existingMessages, toolCallId)) {
+      skipped.push({ skillKey, reason: "already open" });
+      continue;
+    }
+    const args = { skillKey };
+    input.onEvent?.({ type: "tool_call", phase: "start", name: OPEN_SKILL_TOOL_NAME, id: toolCallId, args });
+    const start = Date.now();
+    let result;
+    try {
+      result = await openSkillTool.invoke(args);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "open_skill failed";
+      input.onEvent?.({
+        type: "tool_call",
+        phase: "error",
+        name: OPEN_SKILL_TOOL_NAME,
+        id: toolCallId,
+        args,
+        error: { message },
+        durationMs: Date.now() - start
+      });
+      skipped.push({ skillKey, reason: message });
+      continue;
+    }
+    const durationMs = Date.now() - start;
+    if (result && typeof result === "object" && typeof result.error === "string") {
+      input.onEvent?.({
+        type: "tool_call",
+        phase: "skipped",
+        name: OPEN_SKILL_TOOL_NAME,
+        id: toolCallId,
+        args,
+        error: { message: result.error },
+        durationMs
+      });
+      skipped.push({ skillKey, reason: result.error });
+      continue;
+    }
+    if (result && typeof result === "object") delete result.__runtimeToolsDelta;
+    toolCalls.push({
+      id: toolCallId,
+      type: "function",
+      function: { name: OPEN_SKILL_TOOL_NAME, arguments: JSON.stringify(args) }
+    });
+    toolMessages.push({
+      role: "tool",
+      name: OPEN_SKILL_TOOL_NAME,
+      tool_call_id: toolCallId,
+      content: serializeToolContent(result)
+    });
+    toolHistory.push({
+      executionId: nanoid.nanoid(),
+      toolName: OPEN_SKILL_TOOL_NAME,
+      args,
+      output: result,
+      rawOutput: result,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tool_call_id: toolCallId,
+      summarized: false,
+      retentionPolicy: "keep_full",
+      status: "success"
+    });
+    openedKeys.push(skillKey);
+    input.onEvent?.({
+      type: "tool_call",
+      phase: "success",
+      name: OPEN_SKILL_TOOL_NAME,
+      id: toolCallId,
+      args,
+      result,
+      durationMs
+    });
+  }
+  if (toolCalls.length === 0) {
+    return { ...empty, skipped };
+  }
+  const assistantMessage = {
+    role: "assistant",
+    content: `Opening the ${openedKeys.join(", ")} skill${openedKeys.length > 1 ? "s" : ""} required for this task.`,
+    tool_calls: toolCalls
+  };
+  return { messages: [assistantMessage, ...toolMessages], toolHistory, openedKeys, skipped };
+}
 
 // src/smart/subagents/types.ts
 var DEFAULT_SUBAGENT_POLICY = {
@@ -8206,11 +8333,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 };
   }
@@ -8251,7 +8383,25 @@ function createSmartAgent(opts) {
       const disclosureBlock = [skillBlock, subagentBlock].filter(Boolean).join("\n\n") || void 0;
       const alreadyHasSystem = Array.isArray(input.messages) && input.messages[0]?.role === "system";
       const seedMessages = alreadyHasSystem ? [...input.messages || []] : [systemMessage2(disclosureBlock), ...input.messages || []];
-      let state = syncRuntimeTools(await syncMemory({ ...input, messages: seedMessages }), seedMessages, toolSet);
+      let seedToolHistory = input.toolHistory;
+      if (skillsEnabled && toolSet.skillRegistryRef) {
+        const preopenKeys = config?.preopenedSkills ?? [];
+        if (preopenKeys.length > 0) {
+          const preopened = await preopenSkills({
+            skillKeys: preopenKeys,
+            tools: toolSet.toolsWithoutRecovery,
+            alreadyOpenedKeys: toolSet.skillRegistryRef.openedSkillKeys,
+            existingMessages: seedMessages,
+            onEvent: config?.onEvent ?? opts.onEvent
+          });
+          if (preopened.messages.length > 0) {
+            seedMessages.push(...preopened.messages);
+            seedToolHistory = [...seedToolHistory ?? [], ...preopened.toolHistory];
+            stateRef.toolHistory = seedToolHistory;
+          }
+        }
+      }
+      let state = syncRuntimeTools(await syncMemory({ ...input, messages: seedMessages, toolHistory: seedToolHistory }), seedMessages, toolSet);
       let lastResult = null;
       let rawMessages = [...seedMessages];
       const effectiveMaxToolCalls = config?.limits?.maxToolCalls ?? resolved.limits.maxToolCalls ?? 10;
@@ -11533,6 +11683,7 @@ exports.InMemoryMemoryStore = InMemoryMemoryStore;
 exports.NativeJsonSchemaStrategy = NativeJsonSchemaStrategy;
 exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
 exports.OpenAIProvider = OpenAIProvider;
+exports.PREOPEN_TOOL_CALL_PREFIX = PREOPEN_TOOL_CALL_PREFIX;
 exports.ProviderError = ProviderError;
 exports.SMALL_TIER_SKILL_POLICY = SMALL_TIER_SKILL_POLICY;
 exports.StructuredOutputManager = StructuredOutputManager;
@@ -11619,6 +11770,8 @@ exports.loadSkillsFromDisk = loadSkillsFromDisk;
 exports.normalizeSmartAgentOptions = normalizeSmartAgentOptions;
 exports.otlpSink = otlpSink;
 exports.parseSkillFrontmatter = parseSkillFrontmatter;
+exports.preopenSkills = preopenSkills;
+exports.preopenToolCallId = preopenToolCallId;
 exports.readMemoryFacts = readMemoryFacts;
 exports.regexRule = regexRule;
 exports.resolveAvailableSkills = resolveAvailableSkills;