@mcpc-tech/core 0.3.3 → 0.3.5

package/index.mjs

@@ -510,7 +510,7 @@ function processToolTags({ description, tagToResults, $, tools, toolOverrides, t
     } else {
       const toolId = findToolId(toolName, tools, toolNameMapping);
       if (toolId) {
-        $(toolEl).replaceWith(`<action action="${toolId}"/>`);
+        $(toolEl).replaceWith(`<tool name="${toolId}"/>`);
       } else {
         $(toolEl).remove();
       }
@@ -691,7 +691,7 @@ var SystemPrompts = {
   /**
    * Base system prompt for autonomous MCP execution
    */
-  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively calling actions, gathering results, and deciding next steps until completion. Use this tool when the task matches the manual below.
+  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively selecting and calling tools, gathering results, and continuing until completion. Use this tool when the task matches the manual below.
 
 You must follow the <manual/>, obey the <execution_rules/>, and use the <call_format/>.
 
@@ -699,31 +699,39 @@ You must follow the <manual/>, obey the <execution_rules/>, and use the <call_fo
 {description}
 </manual>
 
+<parameters>
+\`useTool\` - Which tool to execute this iteration
+\`hasDefinitions\` - Tool names whose schemas you already have
+\`definitionsOf\` - Tool names whose schemas you need
+</parameters>
+
 <execution_rules>
-1. **Execute** one action per call
-2. **Collect** feedback from each action result
-3. **Decide** next step based on feedback:
-   - **proceed**: More work needed
-   - **complete**: Task finished (omit action field)
-   - **retry**: Current action failed
-4. **Provide** parameters matching the action name
-5. **Continue** until task is complete
-6. Note: You are an agent exposed as an MCP tool - **"action" is an internal parameter, NOT an external MCP tool you can call**
+1. **First call**: No tool definitions available\u2014you must request them via \`definitionsOf\`
+2. **When executing tools**: Must provide \`hasDefinitions\` with ALL tools you have schemas for (avoid duplicate requests and reduce tokens)
+3. **When requesting definitions**: Use \`definitionsOf\` to request tool schemas you need
+4. **Both together**: Execute tool AND request new definitions in one call for efficiency
+5. **Never request definitions you already have**
+6. **Select** one tool to execute per call using \`useTool\`
+7. **Provide** parameters matching the selected tool name
+8. Note: You are an agent exposed as an MCP tool - **\`useTool\` is an internal parameter for choosing which tool to execute, NOT an external MCP tool you can call**
 </execution_rules>
 
 <call_format>
+Initial definition request:
 \`\`\`json
 {
-  "action": "action_name",
-  "decision": "proceed|retry", 
-  "action_name": { /* action parameters */ }
+  "hasDefinitions": [],
+  "definitionsOf": ["tool1", "tool2"]
 }
 \`\`\`
 
-When complete:
+Execute tool + get new definitions:
 \`\`\`json
 {
-  "decision": "complete"
+  "useTool": "tool1",
+  "tool1": { /* parameters */ },
+  "hasDefinitions": ["tool1", "tool2"],
+  "definitionsOf": ["tool3"]
 }
 \`\`\`
 </call_format>`,
@@ -1119,17 +1127,15 @@ var AgenticExecutor = class {
   allToolNames;
   toolNameToDetailList;
   server;
-  ACTION_KEY;
-  NEXT_ACTION_KEY;
+  USE_TOOL_KEY;
   logger;
   tracingEnabled;
-  constructor(name, allToolNames, toolNameToDetailList, server, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
+  constructor(name, allToolNames, toolNameToDetailList, server, USE_TOOL_KEY = "useTool") {
     this.name = name;
     this.allToolNames = allToolNames;
     this.toolNameToDetailList = toolNameToDetailList;
     this.server = server;
-    this.ACTION_KEY = ACTION_KEY;
-    this.NEXT_ACTION_KEY = NEXT_ACTION_KEY;
+    this.USE_TOOL_KEY = USE_TOOL_KEY;
     this.tracingEnabled = false;
     this.logger = createLogger(`mcpc.agentic.${name}`, server);
     try {
@@ -1149,8 +1155,7 @@ var AgenticExecutor = class {
   async execute(args, schema, parentSpan) {
     const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
       agent: this.name,
-      action: String(args[this.ACTION_KEY] ?? "unknown"),
-      nextAction: String(args[this.NEXT_ACTION_KEY] ?? "none"),
+      selectTool: String(args[this.USE_TOOL_KEY] ?? "unknown"),
       args: JSON.stringify(args)
     }, parentSpan ?? void 0) : null;
     try {
@@ -1165,7 +1170,7 @@ var AgenticExecutor = class {
         }
         this.logger.warning({
           message: "Validation failed",
-          action: args[this.ACTION_KEY],
+          selectTool: args[this.USE_TOOL_KEY],
           error: validationResult.error
         });
         return {
@@ -1180,105 +1185,67 @@ var AgenticExecutor = class {
           isError: true
         };
       }
-      const actionName = args[this.ACTION_KEY];
-      if (executeSpan && actionName) {
+      const useTool = args[this.USE_TOOL_KEY];
+      const definitionsOf = args.definitionsOf || [];
+      const hasDefinitions = args.hasDefinitions || [];
+      if (executeSpan && useTool) {
         try {
-          const safeAction = String(actionName).replace(/\s+/g, "_");
+          const safeTool = String(useTool).replace(/\s+/g, "_");
           if (typeof executeSpan.updateName === "function") {
-            executeSpan.updateName(`mcpc.agentic_execute.${safeAction}`);
+            executeSpan.updateName(`mcpc.agentic_execute.${safeTool}`);
           }
         } catch {
         }
       }
-      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === actionName)?.[1];
+      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === useTool)?.[1];
       if (currentTool) {
-        const nextAction = args[this.NEXT_ACTION_KEY];
         if (executeSpan) {
           executeSpan.setAttributes({
             toolType: "external",
-            actionName,
-            nextAction: nextAction || "none"
+            selectedTool: useTool
           });
         }
         this.logger.debug({
           message: "Executing external tool",
-          action: actionName,
-          nextAction
+          selectTool: useTool
         });
         const currentResult = await currentTool.execute({
-          ...args[actionName]
+          ...args[useTool]
         });
-        if (args[nextAction]) {
-          currentResult?.content?.push({
-            type: "text",
-            text: CompiledPrompts.actionSuccess({
-              toolName: this.name,
-              nextAction,
-              currentAction: actionName
-            })
-          });
-        } else {
-          currentResult?.content?.push({
-            type: "text",
-            text: CompiledPrompts.planningPrompt({
-              currentAction: actionName,
-              toolName: this.name
-            })
-          });
-        }
+        this.appendToolSchemas(currentResult, definitionsOf, hasDefinitions);
         if (executeSpan) {
           executeSpan.setAttributes({
             success: true,
             isError: !!currentResult.isError,
             resultContentLength: currentResult.content?.length || 0,
-            hasNextAction: !!args[nextAction],
             toolResult: JSON.stringify(currentResult)
           });
           endSpan(executeSpan);
         }
         return currentResult;
       }
-      if (this.allToolNames.includes(actionName)) {
+      if (this.allToolNames.includes(useTool)) {
         if (executeSpan) {
           executeSpan.setAttributes({
             toolType: "internal",
-            actionName
+            selectedTool: useTool
           });
         }
         this.logger.debug({
           message: "Executing internal tool",
-          action: actionName
+          selectTool: useTool
         });
         try {
-          const result = await this.server.callTool(actionName, args[actionName]);
-          const nextAction = args[this.NEXT_ACTION_KEY];
-          const callToolResult = result ?? {
+          const result2 = await this.server.callTool(useTool, args[useTool]);
+          const callToolResult = result2 ?? {
             content: []
           };
-          if (nextAction && this.allToolNames.includes(nextAction)) {
-            callToolResult.content.push({
-              type: "text",
-              text: CompiledPrompts.actionSuccess({
-                toolName: this.name,
-                nextAction,
-                currentAction: actionName
-              })
-            });
-          } else {
-            callToolResult.content.push({
-              type: "text",
-              text: CompiledPrompts.planningPrompt({
-                currentAction: actionName,
-                toolName: this.name
-              })
-            });
-          }
+          this.appendToolSchemas(callToolResult, definitionsOf, hasDefinitions);
           if (executeSpan) {
             executeSpan.setAttributes({
               success: true,
               isError: !!callToolResult.isError,
               resultContentLength: callToolResult.content?.length || 0,
-              hasNextAction: !!(nextAction && this.allToolNames.includes(nextAction)),
               toolResult: JSON.stringify(callToolResult)
             });
             endSpan(executeSpan);
@@ -1290,14 +1257,14 @@ var AgenticExecutor = class {
           }
           this.logger.error({
             message: "Error executing internal tool",
-            action: actionName,
+            useTool,
             error: String(error)
           });
           return {
             content: [
               {
                 type: "text",
-                text: `Error executing internal tool ${actionName}: ${error instanceof Error ? error.message : String(error)}`
+                text: `Error executing internal tool ${useTool}: ${error instanceof Error ? error.message : String(error)}`
               }
             ],
             isError: true
@@ -1307,23 +1274,20 @@ var AgenticExecutor = class {
       if (executeSpan) {
         executeSpan.setAttributes({
           toolType: "not_found",
-          actionName: actionName || "unknown",
+          useTool: useTool || "unknown",
           completion: true
         });
         endSpan(executeSpan);
       }
       this.logger.debug({
         message: "Tool not found, returning completion message",
-        action: actionName
+        useTool
       });
-      return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.completionMessage()
-          }
-        ]
+      const result = {
+        content: []
       };
+      this.appendToolSchemas(result, definitionsOf, hasDefinitions);
+      return result;
     } catch (error) {
       if (executeSpan) {
         endSpan(executeSpan, error);
@@ -1343,13 +1307,32 @@ var AgenticExecutor = class {
       };
     }
   }
+  // Append tool schemas to result if requested
+  appendToolSchemas(result, definitionsOf, hasDefinitions) {
+    const schemasToProvide = definitionsOf.filter((toolName) => !hasDefinitions.includes(toolName));
+    if (schemasToProvide.length === 0) {
+      return;
+    }
+    const definitionTexts = [];
+    for (const toolName of schemasToProvide) {
+      const toolDetail = this.toolNameToDetailList.find(([name]) => name === toolName);
+      if (toolDetail) {
+        const [name, schema] = toolDetail;
+        const schemaJson = JSON.stringify(schema, null, 2);
+        definitionTexts.push(`<tool_definition name="${name}">
+${schemaJson}
+</tool_definition>`);
+      }
+    }
+    if (definitionTexts.length > 0) {
+      result.content.push({
+        type: "text",
+        text: `${definitionTexts.join("\n\n")}`
+      });
+    }
+  }
   // Validate arguments using JSON schema
   validate(args, schema) {
-    if (args.decision === "complete") {
-      return {
-        valid: true
-      };
-    }
     return validateSchema(args, schema);
   }
 };
@@ -1585,47 +1568,103 @@ Workflow step definitions - provide ONLY on initial call.
         ]
       };
     },
-    forAgentic: function(toolNameToDetailList, _sampling = false, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
-      const allOf = toolNameToDetailList.map(([toolName, _toolDetail]) => {
-        return {
+    forAgentic: function(toolNameToDetailList, _sampling = false, USE_TOOL_KEY = "useTool") {
+      const allOf = [
+        // When hasDefinitions is empty, definitionsOf must be provided
+        {
           if: {
             properties: {
-              [ACTION_KEY]: {
-                const: toolName
+              hasDefinitions: {
+                type: "array",
+                maxItems: 0
               }
             },
             required: [
-              ACTION_KEY
+              "hasDefinitions"
             ]
           },
           then: {
             required: [
-              toolName
+              "definitionsOf"
             ]
           }
-        };
-      });
-      const actionDescription = `Specifies the action to be performed from the enum. **\u26A0\uFE0F When setting \`action: "example_action"\`, you MUST also provide \`"example_action": { ... }\`**`;
+        },
+        // When useTool is present, hasDefinitions must contain that tool
+        ...toolNameToDetailList.map(([toolName, _toolDetail]) => {
+          return {
+            if: {
+              properties: {
+                [USE_TOOL_KEY]: {
+                  const: toolName
+                }
+              },
+              required: [
+                USE_TOOL_KEY
+              ]
+            },
+            then: {
+              properties: {
+                hasDefinitions: {
+                  type: "array",
+                  contains: {
+                    const: toolName
+                  }
+                }
+              },
+              required: [
+                "hasDefinitions"
+              ]
+            }
+          };
+        }),
+        // When a specific tool is selected, its parameters must be provided
+        ...toolNameToDetailList.map(([toolName, _toolDetail]) => {
+          return {
+            if: {
+              properties: {
+                [USE_TOOL_KEY]: {
+                  const: toolName
+                }
+              },
+              required: [
+                USE_TOOL_KEY
+              ]
+            },
+            then: {
+              required: [
+                toolName
+              ]
+            }
+          };
+        })
+      ];
+      const useToolDescription = `Specifies which tool to execute from the available options. **When setting \`useTool: "example_tool"\`, you MUST also provide \`"example_tool": { ...parameters }\` with that tool's parameters**`;
+      const toolItems = allToolNames.length > 0 ? {
+        type: "string",
+        enum: allToolNames
+      } : {
+        type: "string"
+      };
       const baseProperties = {
-        [ACTION_KEY]: {
+        [USE_TOOL_KEY]: {
           type: "string",
           enum: allToolNames,
-          description: actionDescription
+          description: useToolDescription
         },
-        [NEXT_ACTION_KEY]: {
-          type: "string",
-          enum: allToolNames,
-          description: "Optional: Specify the next action to execute. Only include this when you know additional actions are needed after the current one completes."
+        hasDefinitions: {
+          type: "array",
+          items: toolItems,
+          description: "Tool names whose schemas you already have. List all tools you have schemas for to avoid duplicate schema requests and reduce token usage."
         },
-        decision: this.decision(),
-        ...depGroups
+        definitionsOf: {
+          type: "array",
+          items: toolItems,
+          description: "Tool names whose schemas you need. Request tool schemas before calling them to understand their parameters."
+        }
       };
-      const requiredFields = [
-        ACTION_KEY,
-        "decision"
-      ];
+      const requiredFields = [];
       const schema = {
-        additionalProperties: false,
+        additionalProperties: true,
         type: "object",
         properties: baseProperties,
         required: requiredFields

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcpc-tech/core",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "homepage": "https://jsr.io/@mcpc/core",
   "type": "module",
   "dependencies": {

package/types/src/prompts/types.d.ts

@@ -1,4 +1,4 @@
 /**
  * Execution mode types
- */ export type ExecutionMode = "agentic" | "agentic_workflow" | "agentic_sampling" | "agentic_workflow_sampling" | "custom";
+ */ export type ExecutionMode = "agentic" | "agentic_workflow" | "agentic_sampling" | "agentic_workflow_sampling" | (string & Record<never, never>);
 //# sourceMappingURL=types.d.ts.map

package/types/src/prompts/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sources":["../../../src/prompts/types.ts"],"names":[],"mappings":"AA4BA;;CAEC,GACD,YAAY,gBACR,YACA,qBACA,qBACA,8BACA"}
+{"version":3,"file":"types.d.ts","sources":["../../../src/prompts/types.ts"],"names":[],"mappings":"AA4BA;;CAEC,GACD,YAAY,gBACR,YACA,qBACA,qBACA,+BACC,MAAM,GAAG,OAAO,KAAK,EAAE,KAAK"}

package/types/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sources":["../../src/types.ts"],"names":[],"mappings":"AAEA,YAAY,aAAa,OAAO,MAAM,EAAE,OAAO;AAE/C,YAAY,gBAAgB,MAAM,OAAO,EAAE,QAAQ,OAAO,KAAK,OAAO;AAEtE,iBAAiB;EACf,gBAAgB,MAAM;EACtB;;;GAGC,GACD,YAAY,OAAO;;AAgDrB;;;;;;;;CAQC,GACD,YAAY,WAAW,MAAM,cAAc,EAAE,MAAM,CAAC,CAAC;AACrD,YAAY,YACR,KACA,UACA,YACA,iBACA;AACJ,YAAY,UAAU,OAAO;AAE7B,YAAY,cACP,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,WAAW,YAAY,aAC/C,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,YAAY,WAAW"}
+{"version":3,"file":"types.d.ts","sources":["../../src/types.ts"],"names":[],"mappings":"AAEA,YAAY,aAAa,OAAO,MAAM,EAAE,OAAO;AAE/C,YAAY,gBAAgB,MAAM,OAAO,EAAE,QAAQ,OAAO,KAAK,OAAO;AAEtE,iBAAiB;EACf,gBAAgB,MAAM;EACtB;;;GAGC,GACD,YAAY,OAAO;;AA+CrB;;;;;;;;CAQC,GACD,YAAY,WAAW,MAAM,cAAc,EAAE,MAAM,CAAC,CAAC;AACrD,YAAY,YACR,KACA,UACA,YACA,iBACA;AACJ,YAAY,UAAU,OAAO;AAE7B,YAAY,cACP,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,WAAW,YAAY,aAC/C,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,YAAY,WAAW"}