oricore 1.4.1 → 1.5.1

package/src/tools/tools/skill.ts

@@ -1,11 +1,15 @@
 import path from 'pathe';
 import { z } from 'zod';
+import type { Context } from '../../core/context';
 import type { SkillManager, SkillMetadata } from '../../skill/skill';
-import { createTool } from '../tool';
+import { createTool, type Tool } from '../tool';
 import { safeStringify } from '../../utils/safeStringify';
+import { createTaskTool } from './task';
+import { randomUUID } from '../../utils/randomUUID';
 
 function renderAvailableSkills(skills: SkillMetadata[]): string {
   return skills
+    .filter((skill) => skill.modelInvocable !== false)
     .map(
       (skill) =>
         `<skill>\n<name>${skill.name}</name>\n<description>${skill.description}</description>\n</skill>`,
@@ -14,7 +18,7 @@ function renderAvailableSkills(skills: SkillMetadata[]): string {
 }
 
 function generateDescription(skillManager: SkillManager): string {
-  const skills = skillManager.getSkills();
+  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.
@@ -24,22 +28,38 @@ ${renderAvailableSkills(skills)}
 </available_skills>`;
 }
 
-export function createSkillTool(opts: { skillManager: SkillManager }) {
+export interface CreateSkillToolOpts {
+  skillManager: SkillManager;
+  context: Context;
+  tools: Tool[];
+  sessionId: string;
+  signal?: AbortSignal;
+}
+
+export function createSkillTool(opts: CreateSkillToolOpts) {
+  const { skillManager, context, tools, sessionId, signal } = opts;
+
   return createTool({
     name: 'skill',
-    description: generateDescription(opts.skillManager),
+    description: generateDescription(skillManager),
     parameters: z.object({
       skill: z.string().describe('The skill name to execute'),
+      args: z
+        .string()
+        .optional()
+        .describe('Optional arguments to pass to the skill'),
     }),
     getDescription: ({ params }) => {
-      return params.skill;
+      return params.args
+        ? `${params.skill} ${params.args}`
+        : params.skill;
     },
-    async execute({ skill }) {
+    async execute({ skill, args }) {
       const trimmed = skill.trim();
       const skillName = trimmed.startsWith('/')
         ? trimmed.substring(1)
         : trimmed;
-      const foundSkill = opts.skillManager.getSkill(skillName);
+      const foundSkill = skillManager.getSkill(skillName);
 
       if (!foundSkill) {
         return {
@@ -48,9 +68,67 @@ export function createSkillTool(opts: { skillManager: SkillManager }) {
         };
       }
 
-      const body = await opts.skillManager.readSkillBody(foundSkill);
+      // Check if skill can be invoked by model
+      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 = path.dirname(foundSkill.path);
 
+      // If skill has context: 'fork', use task tool for isolated execution
+      if (foundSkill.context === 'fork') {
+        if (!context.agentManager) {
+          return {
+            isError: true,
+            llmContent: `Skill "${skillName}" requires fork execution but agent manager is not available`,
+          };
+        }
+
+        // Create filtered tools list based on allowedTools
+        // Exclude 'skill' tool itself to prevent recursive invocation loops
+        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');
+
+        // Create task tool with filtered tools
+        const taskTool = createTaskTool({
+          context,
+          tools: filteredTools,
+          sessionId,
+          signal,
+        });
+
+        // Execute skill as a task
+        const agentType = foundSkill.agent || 'general-purpose';
+        const prompt = `Base directory for this skill: ${baseDir}\n\n${body}`;
+
+        // Generate a unique toolCallId for tracking
+        const toolCallId = `skill-${skillName}-${randomUUID()}`;
+
+        return taskTool.execute(
+          {
+            description: `Execute skill: ${skillName}`,
+            prompt,
+            subagent_type: agentType,
+          },
+          toolCallId,
+        );
+      }
+
+      // Inline execution (default)
       const messages = [
         {
           type: 'text',

package/src/utils/messageNormalization.ts

@@ -1,4 +1,5 @@
 import type {
+  ImagePart,
   NormalizedMessage,
   ReasoningPart,
   TextPart,
@@ -154,6 +155,23 @@ export function normalizeMessagesForCompact(
         };
       }
 
+      // Filter out image parts from user messages in compact mode
+      // Images consume too many tokens and are not needed for summarization
+      if (message.role === 'user') {
+        if (Array.isArray(message.content)) {
+          const filteredContent = message.content.filter(
+            (part): part is TextPart => part.type === 'text',
+          );
+          return {
+            ...message,
+            content: (filteredContent.length > 0
+              ? filteredContent
+              : message.content) as Array<TextPart | ImagePart>,
+          };
+        }
+        return message;
+      }
+
       return message;
     })
     .filter((message) => {