@cognipeer/agent-sdk 0.8.12 → 0.9.0

package/dist/index.cjs

@@ -7556,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 = {
@@ -8262,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;
@@ -11544,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;
@@ -11630,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;