oricore 1.5.0 → 1.5.1

package/dist/{chunk-DO76AL42.js → chunk-D5X6YFSK.js}

@@ -24817,6 +24817,7 @@ ${captureLines}` : capture.stack;
 });
 
 export {
+  __require,
   __toESM,
   require_undici
 };
@@ -24828,4 +24829,4 @@ undici/lib/web/fetch/body.js:
 undici/lib/web/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-DO76AL42.js.map
+//# sourceMappingURL=chunk-D5X6YFSK.js.map

package/dist/{chunk-4QYFQSAC.js → chunk-MZNH54NB.js}

@@ -1,7 +1,7 @@
 import {
   __toESM,
   require_undici
-} from "./chunk-DO76AL42.js";
+} from "./chunk-D5X6YFSK.js";
 
 // src/core/history.ts
 import createDebug7 from "debug";
@@ -2560,7 +2560,7 @@ function createProxyFetch(proxyUrl) {
   }
   return async (input, init) => {
     if (!undiciFetch) {
-      undiciFetch = (await import("./undici-326ZBRKH.js")).fetch;
+      undiciFetch = (await import("./undici-NSB7IUB7.js")).fetch;
     }
     let url;
     let requestInit = init;
@@ -6991,72 +6991,10 @@ function readFileWithOffsetLimit(filePath, offset = 1, limit = MAX_LINES_TO_READ
 
 // src/tools/tools/skill.ts
 import path9 from "pathe";
-import { z as z10 } from "zod";
-function renderAvailableSkills(skills) {
-  return skills.map(
-    (skill) => `<skill>
-<name>${skill.name}</name>
-<description>${skill.description}</description>
-</skill>`
-  ).join("\n");
-}
-function generateDescription(skillManager) {
-  const skills = skillManager.getSkills();
-  return `Execute a skill within the main conversation
-<skills_instructions>
-When users ask you to perform tasks, check if any of the available skills below match the task. If a skill matches, use this tool to invoke it. Skills provide specialized knowledge and procedures for specific tasks.
-</skills_instructions>
-<available_skills>
-${renderAvailableSkills(skills)}
-</available_skills>`;
-}
-function createSkillTool(opts) {
-  return createTool({
-    name: "skill",
-    description: generateDescription(opts.skillManager),
-    parameters: z10.object({
-      skill: z10.string().describe("The skill name to execute")
-    }),
-    getDescription: ({ params }) => {
-      return params.skill;
-    },
-    async execute({ skill }) {
-      const trimmed = skill.trim();
-      const skillName = trimmed.startsWith("/") ? trimmed.substring(1) : trimmed;
-      const foundSkill = opts.skillManager.getSkill(skillName);
-      if (!foundSkill) {
-        return {
-          isError: true,
-          llmContent: `Skill "${skillName}" not found`
-        };
-      }
-      const body = await opts.skillManager.readSkillBody(foundSkill);
-      const baseDir = path9.dirname(foundSkill.path);
-      const messages = [
-        {
-          type: "text",
-          text: `<command-message>${skillName} is running\u2026</command-message>
-<command-name>${skillName}</command-name>`
-        },
-        {
-          type: "text",
-          text: `Base directory for this skill: ${baseDir}
-
-${body}`,
-          isMeta: true
-        }
-      ];
-      return {
-        llmContent: safeStringify(messages),
-        returnDisplay: `Loaded skill: ${foundSkill.name}`
-      };
-    },
-    approval: { category: "read" }
-  });
-}
+import { z as z11 } from "zod";
 
 // src/tools/tools/task.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 function createTaskTool(opts) {
   const { signal, sessionId } = opts;
   const { cwd, agentManager, messageBus } = opts.context;
@@ -7122,11 +7060,11 @@ Since the user is greeting, use the greeting-responder agent to respond with a f
 assistant: "I'm going to use the ${"task" /* TASK */} tool to launch the with the greeting-responder agent"
 </example>
       `,
-    parameters: z11.object({
-      description: z11.string().describe("A short (3-5 word) description of task"),
-      prompt: z11.string().describe("The task for the agent to perform"),
-      subagent_type: z11.string().describe("The type of specialized agent to use for this task"),
-      resume: z11.string().optional().describe(
+    parameters: z10.object({
+      description: z10.string().describe("A short (3-5 word) description of task"),
+      prompt: z10.string().describe("The task for the agent to perform"),
+      subagent_type: z10.string().describe("The type of specialized agent to use for this task"),
+      resume: z10.string().optional().describe(
         "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."
       )
     }),
@@ -7298,6 +7236,112 @@ Agent ID: ${result.agentId}`,
   });
 }
 
+// src/tools/tools/skill.ts
+function renderAvailableSkills(skills) {
+  return skills.filter((skill) => skill.modelInvocable !== false).map(
+    (skill) => `<skill>
+<name>${skill.name}</name>
+<description>${skill.description}</description>
+</skill>`
+  ).join("\n");
+}
+function generateDescription(skillManager) {
+  const skills = skillManager.getSkills({ modelInvocable: true });
+  return `Execute a skill within the main conversation
+<skills_instructions>
+When users ask you to perform tasks, check if any of the available skills below match the task. If a skill matches, use this tool to invoke it. Skills provide specialized knowledge and procedures for specific tasks.
+</skills_instructions>
+<available_skills>
+${renderAvailableSkills(skills)}
+</available_skills>`;
+}
+function createSkillTool(opts) {
+  const { skillManager, context, tools, sessionId, signal } = opts;
+  return createTool({
+    name: "skill",
+    description: generateDescription(skillManager),
+    parameters: z11.object({
+      skill: z11.string().describe("The skill name to execute"),
+      args: z11.string().optional().describe("Optional arguments to pass to the skill")
+    }),
+    getDescription: ({ params }) => {
+      return params.args ? `${params.skill} ${params.args}` : params.skill;
+    },
+    async execute({ skill, args }) {
+      const trimmed = skill.trim();
+      const skillName = trimmed.startsWith("/") ? trimmed.substring(1) : trimmed;
+      const foundSkill = skillManager.getSkill(skillName);
+      if (!foundSkill) {
+        return {
+          isError: true,
+          llmContent: `Skill "${skillName}" not found`
+        };
+      }
+      if (foundSkill.modelInvocable === false) {
+        return {
+          isError: true,
+          llmContent: `Skill "${skillName}" cannot be invoked by the model`
+        };
+      }
+      const skillArgs = args || "";
+      const body = await skillManager.readSkillBody(foundSkill, skillArgs);
+      const baseDir = path9.dirname(foundSkill.path);
+      if (foundSkill.context === "fork") {
+        if (!context.agentManager) {
+          return {
+            isError: true,
+            llmContent: `Skill "${skillName}" requires fork execution but agent manager is not available`
+          };
+        }
+        const allowedTools = foundSkill.allowedTools;
+        const filteredTools = allowedTools ? tools.filter(
+          (t) => t.name !== "skill" && allowedTools.some(
+            (allowed) => allowed.toLowerCase() === t.name.toLowerCase()
+          )
+        ) : tools.filter((t) => t.name !== "skill");
+        const taskTool = createTaskTool({
+          context,
+          tools: filteredTools,
+          sessionId,
+          signal
+        });
+        const agentType = foundSkill.agent || "general-purpose";
+        const prompt = `Base directory for this skill: ${baseDir}
+
+${body}`;
+        const toolCallId = `skill-${skillName}-${randomUUID()}`;
+        return taskTool.execute(
+          {
+            description: `Execute skill: ${skillName}`,
+            prompt,
+            subagent_type: agentType
+          },
+          toolCallId
+        );
+      }
+      const messages = [
+        {
+          type: "text",
+          text: `<command-message>${skillName} is running\u2026</command-message>
+<command-name>${skillName}</command-name>`
+        },
+        {
+          type: "text",
+          text: `Base directory for this skill: ${baseDir}
+
+${body}`,
+          isMeta: true
+        }
+      ];
+      return {
+        llmContent: safeStringify(messages),
+        returnDisplay: `Loaded skill: ${foundSkill.name}`
+      };
+    },
+    approval: { category: "read" }
+  });
+}
+
 // src/tools/tools/todo.ts
 import fs10 from "fs";
 import { readFile, writeFile } from "fs/promises";
@@ -7624,8 +7668,7 @@ async function resolveTools(opts) {
     createLSTool({ cwd }),
     createGlobTool({ cwd }),
     createGrepTool({ cwd }),
-    createFetchTool({ model, fetch: opts.context.fetch }),
-    ...hasSkills ? [createSkillTool({ skillManager: opts.context.skillManager })] : []
+    createFetchTool({ model, fetch: opts.context.fetch })
   ];
   const askUserQuestionTools = opts.askUserQuestion ? [createAskUserQuestionTool()] : [];
   const writeTools = opts.write ? [
@@ -7653,7 +7696,7 @@ async function resolveTools(opts) {
     })
   ] : [];
   const mcpTools = await getMcpTools(opts.context);
-  const allTools = [
+  let allTools = [
     ...readonlyTools,
     ...askUserQuestionTools,
     ...writeTools,
@@ -7661,6 +7704,16 @@ async function resolveTools(opts) {
     ...backgroundTools,
     ...mcpTools
   ];
+  if (hasSkills) {
+    const skillTool = createSkillTool({
+      skillManager: opts.context.skillManager,
+      context: opts.context,
+      tools: allTools,
+      sessionId: opts.sessionId,
+      signal: opts.signal
+    });
+    allTools = [...allTools, skillTool];
+  }
   let availableTools = allTools;
   try {
     availableTools = await opts.context.apply({
@@ -8498,4 +8551,4 @@ export {
   Tools,
   createLSTool
 };
-//# sourceMappingURL=chunk-4QYFQSAC.js.map
+//# sourceMappingURL=chunk-MZNH54NB.js.map