@cognipeer/agent-sdk 0.8.12 → 0.9.1

package/dist/index.cjs

@@ -434,7 +434,7 @@ function createTool({
     run: execute,
     func: execute
   };
-  if (typeof needsApproval === "boolean") {
+  if (typeof needsApproval === "function" || typeof needsApproval === "boolean") {
     toolRecord.needsApproval = needsApproval;
   }
   if (approvalPrompt !== void 0) {
@@ -3483,6 +3483,29 @@ function selectPendingToolCalls(messages) {
 }
 
 // src/nodes/tools.ts
+function resolveNeedsApproval(tool, args) {
+  const spec = tool?.needsApproval;
+  if (typeof spec === "function") {
+    try {
+      return Boolean(spec(args));
+    } catch {
+      return true;
+    }
+  }
+  return Boolean(spec);
+}
+function resolveApprovalPrompt(tool, args) {
+  const prompt = tool?.approvalPrompt;
+  if (typeof prompt === "function") {
+    try {
+      const resolved = prompt(args);
+      return typeof resolved === "string" && resolved.length > 0 ? resolved : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return typeof prompt === "string" ? prompt : void 0;
+}
 function normalizeMaxExecutionsPerRun(value) {
   if (value === null || value === void 0 || value === "") return null;
   const parsed = Number(value);
@@ -3529,10 +3552,13 @@ function buildToolDetails(tool, toolName) {
   }
   const inputSchema = normalizeToolSchema(tool, toolName);
   if (inputSchema !== void 0) details.inputSchema = inputSchema;
-  const needsApproval = typeof tool.needsApproval === "boolean" ? tool.needsApproval : void 0;
-  if (needsApproval !== void 0 || tool.approvalPrompt !== void 0 || tool.approvalDefaults !== void 0) {
+  const approvalSpec = tool.needsApproval;
+  const needsApproval = typeof approvalSpec === "boolean" ? approvalSpec : void 0;
+  const conditionalApproval = typeof approvalSpec === "function" ? true : void 0;
+  if (needsApproval !== void 0 || conditionalApproval !== void 0 || tool.approvalPrompt !== void 0 || tool.approvalDefaults !== void 0) {
     details.approval = {
       required: needsApproval,
+      conditional: conditionalApproval,
       prompt: typeof tool.approvalPrompt === "string" ? tool.approvalPrompt : void 0,
       defaults: tool.approvalDefaults !== void 0 ? sanitizeTracePayload(tool.approvalDefaults) : void 0
     };
@@ -3757,7 +3783,7 @@ function createToolsNode(initialTools, opts) {
         }
       }
       let approvalEntry = pendingByCallId.get(toolCallId);
-      const needsApproval = Boolean(tool.needsApproval);
+      const needsApproval = resolveNeedsApproval(tool, args);
       if (needsApproval) {
         if (!approvalEntry) {
           approvalEntry = {
@@ -3767,7 +3793,7 @@ function createToolsNode(initialTools, opts) {
             args,
             status: "pending",
             requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            metadata: tool.approvalPrompt || tool.approvalDefaults ? { prompt: tool.approvalPrompt, defaults: tool.approvalDefaults } : void 0
+            metadata: resolveApprovalPrompt(tool, args) !== void 0 || tool.approvalDefaults !== void 0 ? { prompt: resolveApprovalPrompt(tool, args), defaults: tool.approvalDefaults } : void 0
           };
           pendingApprovals.push(approvalEntry);
           pendingByCallId.set(toolCallId, approvalEntry);
@@ -7556,6 +7582,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 +8409,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 +11709,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 +11796,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;