openloops 0.1.9 → 0.1.11

package/dist/services/agent/loops/plan-execute/plan-execute-loop.js

@@ -0,0 +1,242 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_execute_loop_exports = {};
+__export(plan_execute_loop_exports, {
+  PlanExecuteLoop: () => PlanExecuteLoop
+});
+module.exports = __toCommonJS(plan_execute_loop_exports);
+var import_core = require("../../core/index.js");
+var import_skills = require("../shared/skills");
+const MAX_STEP_RETRIES = 2;
+class PlanExecuteLoop extends import_core.AgentLoop {
+  get initialNode() {
+    return this.nodes.fast_responder;
+  }
+  get nodes() {
+    return {
+      fast_responder: this.fastResponder,
+      strategy_engine: this.strategyEngine,
+      action_planner: this.actionPlanner,
+      execution_loop: this.executionLoop,
+      state_observer: this.executionObserver,
+      final_responder: this.finalResponder,
+      confirmation_gate: this.confirmationGate
+    };
+  }
+  get name() {
+    return "plan_execute";
+  }
+  get version() {
+    return "1.0.0";
+  }
+  get author() {
+    return {
+      name: "Jose Barcos",
+      email: "jose@openloops.xyz",
+      website: "https://openloops.xyz/jose"
+    };
+  }
+  async fastResponder(ctx) {
+    ctx.chat.state?.setCurrentActivity("Analyzing requirement...");
+    const chat_history = ctx.chat.lastHistoryMessages();
+    const result = await import_skills.fastResponder.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        ...chat_history?.length ? { chat_history } : {}
+      }
+    });
+    ctx.chat.state?.setLanguage(result.detected_language);
+    if (!result.can_answer) {
+      ctx.setNextNode(this.nodes.strategy_engine);
+    } else {
+      ctx.chat.state?.setStatus(import_core.AgentStatus.IDLE);
+      ctx.setNextNode(this.nodes.fast_responder);
+      ctx.reply(result.answer ?? "");
+    }
+  }
+  async strategyEngine(ctx) {
+    ctx.chat.state?.setCurrentActivity("Designing strategy...");
+    const lastCompletedTask = ctx.task ? void 0 : ctx.chat.lastCompletedTask();
+    const chatHistory = ctx.chat.lastHistoryMessages();
+    const result = await import_skills.strategyEngine.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        user_goal: ctx.currentMessage,
+        ...chatHistory?.length ? { chat_history: chatHistory } : {},
+        ...lastCompletedTask ? { last_completed_task: { goal: lastCompletedTask.goal, summary: lastCompletedTask.summary } } : {}
+      }
+    });
+    ctx.chat.state?.setLanguage(result.detected_language);
+    const task = result.is_continuation && lastCompletedTask ? ctx.chat.reopenTask(lastCompletedTask.id) : ctx.chat.createTask(result.goal ?? ctx.currentMessage);
+    ctx.chat.context.addContext({
+      taskId: task.id,
+      meta: { name: "strategy", type: "artifact", shortDescription: "High-level strategy for the active task" },
+      content: result
+    });
+    ctx.setNextNode(this.nodes.action_planner);
+  }
+  async actionPlanner(ctx) {
+    ctx.chat.state?.setCurrentActivity("Creating action plan...");
+    const task = ctx.task;
+    const strategy = ctx.chat.context.lastContext({ taskId: task.id, name: "strategy" })?.content;
+    const tools = ctx.searchTools(strategy?.tool_keywords ?? []);
+    const result = await import_skills.actionPlanner.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        active_task: {
+          user_goal: task.goal,
+          strategy: strategy?.hypothesis,
+          required_capabilities: strategy?.required_capabilities
+        },
+        tools
+      }
+    });
+    const enqueueSteps = (steps) => steps.map((step) => task.addAction({
+      name: step.tool_name,
+      stepId: String(step.step_id),
+      args: step.args ?? step.arguments,
+      dependsOn: step.depends_on?.map(String),
+      author: "action_planner"
+    }));
+    switch (result.plan_status) {
+      case "MISSING_TOOLS":
+        ctx.chat.state?.setStatus(import_core.AgentStatus.AWAITING_USER_INPUT);
+        ctx.chat.failTask(task.id);
+        ctx.setNextNode(void 0);
+        ctx.reply(result.user_response);
+        break;
+      case "NEEDS_CLARIFICATION":
+        ctx.chat.state?.setStatus(import_core.AgentStatus.AWAITING_USER_INPUT);
+        ctx.setNextNode(void 0);
+        ctx.reply(result.clarification_prompt);
+        break;
+      case "NEEDS_CONFIRMATION": {
+        enqueueSteps(result.steps);
+        const actionsList = (result.confirmation_details?.actions ?? []).map((action) => `- ${action.description}`).join("\n");
+        ctx.chat.state?.setStatus(import_core.AgentStatus.AWAITING_USER_CONFIRMATION);
+        ctx.setNextNode(this.nodes.confirmation_gate);
+        ctx.reply([
+          result.clarification_prompt,
+          result.confirmation_details?.impact_summary,
+          actionsList,
+          result.confirmation_details?.confirm_label
+        ].filter(Boolean).join("\n\n"));
+        break;
+      }
+      case "SUCCESS":
+        enqueueSteps(result.steps);
+        ctx.setNextNode(this.nodes.execution_loop);
+        break;
+    }
+  }
+  async executionLoop(ctx) {
+    const task = ctx.task;
+    const [next] = task.readyActions;
+    if (!next) {
+      ctx.setNextNode(this.nodes.final_responder);
+      return;
+    }
+    ctx.chat.state?.setCurrentActivity(`Running ${next.name}...`);
+    const tool = ctx.tools.find((t) => t.name === next.name);
+    const executed = await task.runReadyAction(next.id, tool, ctx.chat.context, ctx.baseParams);
+    if (executed.status === "failed" && (executed.retries ?? 0) < MAX_STEP_RETRIES) {
+      executed.incrementRetries();
+      executed.resetForRetry();
+      ctx.setNextNode(this.nodes.execution_loop);
+      return;
+    }
+    ctx.setNextNode(this.nodes.state_observer);
+  }
+  async confirmationGate(ctx) {
+    const task = ctx.task;
+    const result = await import_skills.confirmationGate.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        ...ctx.chat.lastAnswer ? { pending_confirmation: ctx.chat.lastAnswer } : {}
+      }
+    });
+    switch (result.decision) {
+      case "CONFIRMED":
+        ctx.chat.state?.setStatus(import_core.AgentStatus.PROCESSING);
+        ctx.setNextNode(this.nodes.execution_loop);
+        break;
+      case "DECLINED":
+        ctx.chat.cancelTask(task.id);
+        ctx.chat.state?.setStatus(import_core.AgentStatus.IDLE);
+        ctx.setNextNode(this.nodes.fast_responder);
+        ctx.reply(result.acknowledgement);
+        break;
+      case "UNCLEAR":
+      default:
+        ctx.chat.state?.setStatus(import_core.AgentStatus.AWAITING_USER_CONFIRMATION);
+        ctx.setNextNode(this.nodes.confirmation_gate);
+        ctx.reply(result.clarification_prompt);
+        break;
+    }
+  }
+  async executionObserver(ctx) {
+    const task = ctx.task;
+    const lastAction = task.lastExecutedAction;
+    const result = await import_skills.stateObserver.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        user_intent: task.goal,
+        executed_step: lastAction?.toJSON(),
+        remaining_steps: task.readyActions.map((a) => a.toJSON())
+      }
+    });
+    ctx.chat.state?.setCurrentActivity(result.reasoning);
+    switch (result.action) {
+      case "REPLAN":
+        ctx.setNextNode(this.nodes.action_planner);
+        break;
+      case "ASK_USER":
+        ctx.chat.state?.setStatus(import_core.AgentStatus.AWAITING_USER_INPUT);
+        ctx.setNextNode(void 0);
+        ctx.reply(result.user_prompt ?? "");
+        break;
+      case "CONTINUE":
+      default: {
+        const stillPending = task.actions.some((a) => a.status === "pending");
+        ctx.setNextNode(stillPending ? this.nodes.execution_loop : this.nodes.final_responder);
+        break;
+      }
+    }
+  }
+  async finalResponder(ctx) {
+    ctx.chat.state?.setCurrentActivity("Generating final response...");
+    const task = ctx.task;
+    const executionResults = task.actions.map((a) => ({ tool_name: a.name, args: a.args, output: a.output, status: a.status }));
+    const result = await import_skills.finalResponder.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        user_goal: task.goal,
+        execution_results: executionResults
+      }
+    });
+    ctx.reply(result.final_response ?? "");
+    ctx.chat.completeTask(task.id, result.reasoning);
+    ctx.chat.state?.setStatus(import_core.AgentStatus.IDLE);
+    ctx.setNextNode(this.nodes.fast_responder);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlanExecuteLoop
+});

package/dist/services/agent/loops/plan-execute/plan-execute-loop.mjs

@@ -0,0 +1,226 @@
+import "../../../../chunk-XRJFNASX.mjs";
+import { AgentLoop, AgentStatus } from "../../core/index.js";
+import {
+  fastResponder,
+  strategyEngine,
+  actionPlanner,
+  stateObserver,
+  finalResponder,
+  confirmationGate
+} from "../shared/skills";
+const MAX_STEP_RETRIES = 2;
+class PlanExecuteLoop extends AgentLoop {
+  get initialNode() {
+    return this.nodes.fast_responder;
+  }
+  get nodes() {
+    return {
+      fast_responder: this.fastResponder,
+      strategy_engine: this.strategyEngine,
+      action_planner: this.actionPlanner,
+      execution_loop: this.executionLoop,
+      state_observer: this.executionObserver,
+      final_responder: this.finalResponder,
+      confirmation_gate: this.confirmationGate
+    };
+  }
+  get name() {
+    return "plan_execute";
+  }
+  get version() {
+    return "1.0.0";
+  }
+  get author() {
+    return {
+      name: "Jose Barcos",
+      email: "jose@openloops.xyz",
+      website: "https://openloops.xyz/jose"
+    };
+  }
+  async fastResponder(ctx) {
+    ctx.chat.state?.setCurrentActivity("Analyzing requirement...");
+    const chat_history = ctx.chat.lastHistoryMessages();
+    const result = await fastResponder.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        ...chat_history?.length ? { chat_history } : {}
+      }
+    });
+    ctx.chat.state?.setLanguage(result.detected_language);
+    if (!result.can_answer) {
+      ctx.setNextNode(this.nodes.strategy_engine);
+    } else {
+      ctx.chat.state?.setStatus(AgentStatus.IDLE);
+      ctx.setNextNode(this.nodes.fast_responder);
+      ctx.reply(result.answer ?? "");
+    }
+  }
+  async strategyEngine(ctx) {
+    ctx.chat.state?.setCurrentActivity("Designing strategy...");
+    const lastCompletedTask = ctx.task ? void 0 : ctx.chat.lastCompletedTask();
+    const chatHistory = ctx.chat.lastHistoryMessages();
+    const result = await strategyEngine.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        user_goal: ctx.currentMessage,
+        ...chatHistory?.length ? { chat_history: chatHistory } : {},
+        ...lastCompletedTask ? { last_completed_task: { goal: lastCompletedTask.goal, summary: lastCompletedTask.summary } } : {}
+      }
+    });
+    ctx.chat.state?.setLanguage(result.detected_language);
+    const task = result.is_continuation && lastCompletedTask ? ctx.chat.reopenTask(lastCompletedTask.id) : ctx.chat.createTask(result.goal ?? ctx.currentMessage);
+    ctx.chat.context.addContext({
+      taskId: task.id,
+      meta: { name: "strategy", type: "artifact", shortDescription: "High-level strategy for the active task" },
+      content: result
+    });
+    ctx.setNextNode(this.nodes.action_planner);
+  }
+  async actionPlanner(ctx) {
+    ctx.chat.state?.setCurrentActivity("Creating action plan...");
+    const task = ctx.task;
+    const strategy = ctx.chat.context.lastContext({ taskId: task.id, name: "strategy" })?.content;
+    const tools = ctx.searchTools(strategy?.tool_keywords ?? []);
+    const result = await actionPlanner.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        active_task: {
+          user_goal: task.goal,
+          strategy: strategy?.hypothesis,
+          required_capabilities: strategy?.required_capabilities
+        },
+        tools
+      }
+    });
+    const enqueueSteps = (steps) => steps.map((step) => task.addAction({
+      name: step.tool_name,
+      stepId: String(step.step_id),
+      args: step.args ?? step.arguments,
+      dependsOn: step.depends_on?.map(String),
+      author: "action_planner"
+    }));
+    switch (result.plan_status) {
+      case "MISSING_TOOLS":
+        ctx.chat.state?.setStatus(AgentStatus.AWAITING_USER_INPUT);
+        ctx.chat.failTask(task.id);
+        ctx.setNextNode(void 0);
+        ctx.reply(result.user_response);
+        break;
+      case "NEEDS_CLARIFICATION":
+        ctx.chat.state?.setStatus(AgentStatus.AWAITING_USER_INPUT);
+        ctx.setNextNode(void 0);
+        ctx.reply(result.clarification_prompt);
+        break;
+      case "NEEDS_CONFIRMATION": {
+        enqueueSteps(result.steps);
+        const actionsList = (result.confirmation_details?.actions ?? []).map((action) => `- ${action.description}`).join("\n");
+        ctx.chat.state?.setStatus(AgentStatus.AWAITING_USER_CONFIRMATION);
+        ctx.setNextNode(this.nodes.confirmation_gate);
+        ctx.reply([
+          result.clarification_prompt,
+          result.confirmation_details?.impact_summary,
+          actionsList,
+          result.confirmation_details?.confirm_label
+        ].filter(Boolean).join("\n\n"));
+        break;
+      }
+      case "SUCCESS":
+        enqueueSteps(result.steps);
+        ctx.setNextNode(this.nodes.execution_loop);
+        break;
+    }
+  }
+  async executionLoop(ctx) {
+    const task = ctx.task;
+    const [next] = task.readyActions;
+    if (!next) {
+      ctx.setNextNode(this.nodes.final_responder);
+      return;
+    }
+    ctx.chat.state?.setCurrentActivity(`Running ${next.name}...`);
+    const tool = ctx.tools.find((t) => t.name === next.name);
+    const executed = await task.runReadyAction(next.id, tool, ctx.chat.context, ctx.baseParams);
+    if (executed.status === "failed" && (executed.retries ?? 0) < MAX_STEP_RETRIES) {
+      executed.incrementRetries();
+      executed.resetForRetry();
+      ctx.setNextNode(this.nodes.execution_loop);
+      return;
+    }
+    ctx.setNextNode(this.nodes.state_observer);
+  }
+  async confirmationGate(ctx) {
+    const task = ctx.task;
+    const result = await confirmationGate.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        ...ctx.chat.lastAnswer ? { pending_confirmation: ctx.chat.lastAnswer } : {}
+      }
+    });
+    switch (result.decision) {
+      case "CONFIRMED":
+        ctx.chat.state?.setStatus(AgentStatus.PROCESSING);
+        ctx.setNextNode(this.nodes.execution_loop);
+        break;
+      case "DECLINED":
+        ctx.chat.cancelTask(task.id);
+        ctx.chat.state?.setStatus(AgentStatus.IDLE);
+        ctx.setNextNode(this.nodes.fast_responder);
+        ctx.reply(result.acknowledgement);
+        break;
+      case "UNCLEAR":
+      default:
+        ctx.chat.state?.setStatus(AgentStatus.AWAITING_USER_CONFIRMATION);
+        ctx.setNextNode(this.nodes.confirmation_gate);
+        ctx.reply(result.clarification_prompt);
+        break;
+    }
+  }
+  async executionObserver(ctx) {
+    const task = ctx.task;
+    const lastAction = task.lastExecutedAction;
+    const result = await stateObserver.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        user_intent: task.goal,
+        executed_step: lastAction?.toJSON(),
+        remaining_steps: task.readyActions.map((a) => a.toJSON())
+      }
+    });
+    ctx.chat.state?.setCurrentActivity(result.reasoning);
+    switch (result.action) {
+      case "REPLAN":
+        ctx.setNextNode(this.nodes.action_planner);
+        break;
+      case "ASK_USER":
+        ctx.chat.state?.setStatus(AgentStatus.AWAITING_USER_INPUT);
+        ctx.setNextNode(void 0);
+        ctx.reply(result.user_prompt ?? "");
+        break;
+      case "CONTINUE":
+      default: {
+        const stillPending = task.actions.some((a) => a.status === "pending");
+        ctx.setNextNode(stillPending ? this.nodes.execution_loop : this.nodes.final_responder);
+        break;
+      }
+    }
+  }
+  async finalResponder(ctx) {
+    ctx.chat.state?.setCurrentActivity("Generating final response...");
+    const task = ctx.task;
+    const executionResults = task.actions.map((a) => ({ tool_name: a.name, args: a.args, output: a.output, status: a.status }));
+    const result = await finalResponder.run({
+      ...ctx.skillParams,
+      contextInjection: {
+        user_goal: task.goal,
+        execution_results: executionResults
+      }
+    });
+    ctx.reply(result.final_response ?? "");
+    ctx.chat.completeTask(task.id, result.reasoning);
+    ctx.chat.state?.setStatus(AgentStatus.IDLE);
+    ctx.setNextNode(this.nodes.fast_responder);
+  }
+}
+export {
+  PlanExecuteLoop
+};

package/dist/services/agent/loops/shared/index.d.ts

@@ -0,0 +1 @@
+export * from './skills';

package/dist/services/agent/loops/shared/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var shared_exports = {};
+module.exports = __toCommonJS(shared_exports);
+__reExport(shared_exports, require("./skills"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./skills")
+});

package/dist/services/agent/loops/shared/index.mjs

@@ -0,0 +1 @@
+export * from "./skills";

package/dist/services/agent/loops/shared/skills/action-planner.d.ts

@@ -0,0 +1,35 @@
+import { Skill } from '../../../skills/skill';
+interface PlanStepOutput {
+    step_id: number;
+    tool_name: string;
+    arguments: Record<string, any>;
+    expected_outcome: string;
+    status: 'READY' | 'MISSING_PARAMS' | 'REQUIRES_CONFIRMATION' | 'COMPLETED' | 'FAILED';
+    is_destructive: boolean;
+    missing_fields: string[];
+    rationale: string;
+    depends_on_steps: number[];
+    output: Record<string, any>;
+}
+interface ConfirmationDetails {
+    actions: Array<{
+        step_id: number;
+        description: string;
+    }>;
+    impact_summary: string;
+    confirm_label: string;
+}
+type ResponseSchema = {
+    plan_status: 'SUCCESS' | 'MISSING_TOOLS' | 'NEEDS_CLARIFICATION' | 'NEEDS_CONFIRMATION';
+    current_step_index: number;
+    missing_tools_explanation: string;
+    user_response: string;
+    steps: PlanStepOutput[];
+    needs_clarification: boolean;
+    missing_entities: string[];
+    clarification_prompt: string;
+    confirmation_details: ConfirmationDetails | null;
+    reasoning: string;
+};
+export declare const actionPlanner: Skill<ResponseSchema>;
+export {};

package/dist/services/agent/loops/shared/skills/action-planner.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var action_planner_exports = {};
+__export(action_planner_exports, {
+  actionPlanner: () => actionPlanner
+});
+module.exports = __toCommonJS(action_planner_exports);
+var import_skill = require("../../../skills/skill");
+const actionPlanner = new import_skill.Skill({
+  name: "action_planner",
+  version: "1.6.2",
+  description: "Generates an ordered step-by-step tool execution plan based on IntentContext and candidate tools schema. Flags missing tools, missing required execution parameters, or steps requiring user confirmation for destructive actions.",
+  temperature: 0.1,
+  systemInstructions: {
+    instruction_set: {
+      goal: "Evaluate userIntent, extracted_entities, and candidate tools to output a structured execution plan. Detect missing capabilities, missing tool arguments, or destructive tool executions and ask for clarification or confirmation when necessary.",
+      role: "Action planning, tool mapping, argument mapping, and execution strategy agent",
+      logic_rules: [
+        "TOOL_EVALUATION: Analyze available tool schemas against userIntent and extracted_entities in IntentContext. Select only the necessary tools required to achieve the goal.",
+        "MISSING_TOOLS_CHECK: If no candidate tools fit the intent, or if essential actions cannot be mapped to any available tool: 1) Set 'plan_status' to 'MISSING_TOOLS', 2) Set 'current_step_index' to 0, 3) Provide a technical explanation in 'missing_tools_explanation' in English, 4) Generate a polite message in 'user_response' written in 'detected_language' explaining that no connected tools/integrations were found to complete the request and suggest checking their active integrations, 5) Set 'steps' to [], 6) Set 'needs_clarification' to false, 'missing_entities' to [], 'clarification_prompt' to '', and 'confirmation_details' to null.",
+        "STEP_PLANNING: If tools are available, sequence them logically in 'steps'. Assign incremental 'step_id' starting at 1. Set 'current_step_index' to 0 by default. Explicitly list any prerequisite step IDs in 'depends_on_steps' if a step requires output from a prior step. Define a clear 'expected_outcome' describing the precise expected result or data state after this step runs.",
+        "ARGUMENT_MAPPING: Map extracted_entities and execution context (e.g., CONTEXT metadata like 'now_utc', 'now_local', 'timezone', user_details, and session_details) to tool parameters in 'arguments'. For relative time/date expressions (e.g., 'today', 'afternoon', 'yesterday at 4:30pm'), calculate and resolve the precise value (such as ISO 8601 strings) using the provided reference timestamp and timezone. If a parameter value comes from a future step execution output, represent it as a JSON reference string (e.g., '{{step_1.output.id}}').",
+        "PARAMETER_AND_SAFETY_VALIDATION: For each step, inspect the candidate tool schema properties and flags:",
+        "1) Set 'is_destructive' to match the candidate tool's 'destructive' boolean flag.",
+        "2) If any required parameter is MISSING and CANNOT be derived from CONTEXT: Set step 'status' to 'MISSING_PARAMS' and list the missing keys in 'missing_fields'.",
+        "3) If ALL required parameters are present BUT 'is_destructive' is true: Set step 'status' to 'REQUIRES_CONFIRMATION' and 'missing_fields' to [].",
+        "4) If ALL required parameters are present and 'is_destructive' is false: Set step 'status' to 'READY' and 'missing_fields' to [].",
+        "CLARIFICATION_CHECK: If ANY step has status 'MISSING_PARAMS': 1) Set 'plan_status' to 'NEEDS_CLARIFICATION', 2) Set 'needs_clarification' to true, 3) Collect all unresolvable parameters in 'missing_entities' in English, 4) Provide a short, direct, and polite question in 'clarification_prompt' written in 'detected_language', 5) Set 'user_response' to '', and 'confirmation_details' to null.",
+        "CONFIRMATION_CHECK: If NO step has 'MISSING_PARAMS' BUT at least one step has status 'REQUIRES_CONFIRMATION': 1) Set 'plan_status' to 'NEEDS_CONFIRMATION', 2) Set 'needs_clarification' to false, 3) Set 'missing_entities' to [], 4) Populate 'confirmation_details' with: 'actions' (one entry per step with status 'REQUIRES_CONFIRMATION', each with that step's 'step_id' and a short natural-language 'description' of exactly what it will do, naming the action and its target \u2014 never the raw tool name or parameter keys), 'impact_summary' summarizing the overall permanent changes in plain terms, and 'confirm_label' \u2014 a short call-to-action asking the user to approve or decline; this will always be shown as the LAST line of the message, so it must stand on its own as the actual yes/no ask, 5) Provide context in 'clarification_prompt' introducing why confirmation is needed \u2014 this field must NOT itself ask a yes/no question, since 'confirm_label' is the only field that does that, 6) Set 'user_response' to ''. CRITICAL: every piece of text produced in this rule ('actions[].description', 'impact_summary', 'confirm_label', 'clarification_prompt') MUST be written in 'detected_language' \u2014 never default to English here regardless of the language used anywhere else in this instruction set.",
+        "SUCCESS_STATE: If all steps are 'READY' and no tools are missing or requiring confirmation: 1) Set 'plan_status' to 'SUCCESS', 2) Set 'missing_tools_explanation' to '', 3) Set 'user_response' to '', 4) Set 'needs_clarification' to false, 'missing_entities' to [], 'clarification_prompt' to '', and 'confirmation_details' to null.",
+        "LANGUAGE_ENFORCEMENT: ONLY 'clarification_prompt', 'user_response', and every field inside 'confirmation_details' (including each entry's 'description') MUST be written in the user's actual conversation language \u2014 use CONTEXT.detected_language when present; only fall back to CONTEXT.user_details.preferred_language if 'detected_language' is absent. 'preferred_language' is the app's configured display language and does NOT necessarily match the language the user is typing in right now \u2014 never prefer it over 'detected_language' when both exist. These are the only fields the end user actually reads before approving or declining. ALL OTHER fields ('missing_tools_explanation', step 'rationale', step 'expected_outcome', 'missing_entities', and 'reasoning') MUST strictly be written in English.",
+        "STRICT_OUTPUT: Return ONLY the JSON object matching response_schema."
+      ],
+      response_schema: {
+        plan_status: "string (SUCCESS | MISSING_TOOLS | NEEDS_CLARIFICATION | NEEDS_CONFIRMATION)",
+        // current_step_index: "number",
+        missing_tools_explanation: "string",
+        user_response: "string",
+        steps: "array of objects with fields 'step_id' (number), 'tool_name' (string), 'arguments' (object), 'expected_outcome' (string), 'status' ('READY' | 'MISSING_PARAMS' | 'REQUIRES_CONFIRMATION'), 'is_destructive' (boolean), 'missing_fields' (array of strings), 'rationale' (string), 'depends_on_steps' (array of numbers)",
+        needs_clarification: "boolean",
+        missing_entities: "array of strings",
+        clarification_prompt: "string",
+        confirmation_details: "object containing 'actions' (array of objects with 'step_id' (number) and 'description' (string, natural language, in the user's detected_language)), 'impact_summary' (string, in the user's detected_language), and 'confirm_label' (short string, in the user's detected_language) \u2014 or null",
+        reasoning: "string"
+      }
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  actionPlanner
+});

package/dist/services/agent/loops/shared/skills/action-planner.mjs

@@ -0,0 +1,45 @@
+import "../../../../../chunk-XRJFNASX.mjs";
+import { Skill } from "../../../skills/skill";
+const actionPlanner = new Skill({
+  name: "action_planner",
+  version: "1.6.2",
+  description: "Generates an ordered step-by-step tool execution plan based on IntentContext and candidate tools schema. Flags missing tools, missing required execution parameters, or steps requiring user confirmation for destructive actions.",
+  temperature: 0.1,
+  systemInstructions: {
+    instruction_set: {
+      goal: "Evaluate userIntent, extracted_entities, and candidate tools to output a structured execution plan. Detect missing capabilities, missing tool arguments, or destructive tool executions and ask for clarification or confirmation when necessary.",
+      role: "Action planning, tool mapping, argument mapping, and execution strategy agent",
+      logic_rules: [
+        "TOOL_EVALUATION: Analyze available tool schemas against userIntent and extracted_entities in IntentContext. Select only the necessary tools required to achieve the goal.",
+        "MISSING_TOOLS_CHECK: If no candidate tools fit the intent, or if essential actions cannot be mapped to any available tool: 1) Set 'plan_status' to 'MISSING_TOOLS', 2) Set 'current_step_index' to 0, 3) Provide a technical explanation in 'missing_tools_explanation' in English, 4) Generate a polite message in 'user_response' written in 'detected_language' explaining that no connected tools/integrations were found to complete the request and suggest checking their active integrations, 5) Set 'steps' to [], 6) Set 'needs_clarification' to false, 'missing_entities' to [], 'clarification_prompt' to '', and 'confirmation_details' to null.",
+        "STEP_PLANNING: If tools are available, sequence them logically in 'steps'. Assign incremental 'step_id' starting at 1. Set 'current_step_index' to 0 by default. Explicitly list any prerequisite step IDs in 'depends_on_steps' if a step requires output from a prior step. Define a clear 'expected_outcome' describing the precise expected result or data state after this step runs.",
+        "ARGUMENT_MAPPING: Map extracted_entities and execution context (e.g., CONTEXT metadata like 'now_utc', 'now_local', 'timezone', user_details, and session_details) to tool parameters in 'arguments'. For relative time/date expressions (e.g., 'today', 'afternoon', 'yesterday at 4:30pm'), calculate and resolve the precise value (such as ISO 8601 strings) using the provided reference timestamp and timezone. If a parameter value comes from a future step execution output, represent it as a JSON reference string (e.g., '{{step_1.output.id}}').",
+        "PARAMETER_AND_SAFETY_VALIDATION: For each step, inspect the candidate tool schema properties and flags:",
+        "1) Set 'is_destructive' to match the candidate tool's 'destructive' boolean flag.",
+        "2) If any required parameter is MISSING and CANNOT be derived from CONTEXT: Set step 'status' to 'MISSING_PARAMS' and list the missing keys in 'missing_fields'.",
+        "3) If ALL required parameters are present BUT 'is_destructive' is true: Set step 'status' to 'REQUIRES_CONFIRMATION' and 'missing_fields' to [].",
+        "4) If ALL required parameters are present and 'is_destructive' is false: Set step 'status' to 'READY' and 'missing_fields' to [].",
+        "CLARIFICATION_CHECK: If ANY step has status 'MISSING_PARAMS': 1) Set 'plan_status' to 'NEEDS_CLARIFICATION', 2) Set 'needs_clarification' to true, 3) Collect all unresolvable parameters in 'missing_entities' in English, 4) Provide a short, direct, and polite question in 'clarification_prompt' written in 'detected_language', 5) Set 'user_response' to '', and 'confirmation_details' to null.",
+        "CONFIRMATION_CHECK: If NO step has 'MISSING_PARAMS' BUT at least one step has status 'REQUIRES_CONFIRMATION': 1) Set 'plan_status' to 'NEEDS_CONFIRMATION', 2) Set 'needs_clarification' to false, 3) Set 'missing_entities' to [], 4) Populate 'confirmation_details' with: 'actions' (one entry per step with status 'REQUIRES_CONFIRMATION', each with that step's 'step_id' and a short natural-language 'description' of exactly what it will do, naming the action and its target \u2014 never the raw tool name or parameter keys), 'impact_summary' summarizing the overall permanent changes in plain terms, and 'confirm_label' \u2014 a short call-to-action asking the user to approve or decline; this will always be shown as the LAST line of the message, so it must stand on its own as the actual yes/no ask, 5) Provide context in 'clarification_prompt' introducing why confirmation is needed \u2014 this field must NOT itself ask a yes/no question, since 'confirm_label' is the only field that does that, 6) Set 'user_response' to ''. CRITICAL: every piece of text produced in this rule ('actions[].description', 'impact_summary', 'confirm_label', 'clarification_prompt') MUST be written in 'detected_language' \u2014 never default to English here regardless of the language used anywhere else in this instruction set.",
+        "SUCCESS_STATE: If all steps are 'READY' and no tools are missing or requiring confirmation: 1) Set 'plan_status' to 'SUCCESS', 2) Set 'missing_tools_explanation' to '', 3) Set 'user_response' to '', 4) Set 'needs_clarification' to false, 'missing_entities' to [], 'clarification_prompt' to '', and 'confirmation_details' to null.",
+        "LANGUAGE_ENFORCEMENT: ONLY 'clarification_prompt', 'user_response', and every field inside 'confirmation_details' (including each entry's 'description') MUST be written in the user's actual conversation language \u2014 use CONTEXT.detected_language when present; only fall back to CONTEXT.user_details.preferred_language if 'detected_language' is absent. 'preferred_language' is the app's configured display language and does NOT necessarily match the language the user is typing in right now \u2014 never prefer it over 'detected_language' when both exist. These are the only fields the end user actually reads before approving or declining. ALL OTHER fields ('missing_tools_explanation', step 'rationale', step 'expected_outcome', 'missing_entities', and 'reasoning') MUST strictly be written in English.",
+        "STRICT_OUTPUT: Return ONLY the JSON object matching response_schema."
+      ],
+      response_schema: {
+        plan_status: "string (SUCCESS | MISSING_TOOLS | NEEDS_CLARIFICATION | NEEDS_CONFIRMATION)",
+        // current_step_index: "number",
+        missing_tools_explanation: "string",
+        user_response: "string",
+        steps: "array of objects with fields 'step_id' (number), 'tool_name' (string), 'arguments' (object), 'expected_outcome' (string), 'status' ('READY' | 'MISSING_PARAMS' | 'REQUIRES_CONFIRMATION'), 'is_destructive' (boolean), 'missing_fields' (array of strings), 'rationale' (string), 'depends_on_steps' (array of numbers)",
+        needs_clarification: "boolean",
+        missing_entities: "array of strings",
+        clarification_prompt: "string",
+        confirmation_details: "object containing 'actions' (array of objects with 'step_id' (number) and 'description' (string, natural language, in the user's detected_language)), 'impact_summary' (string, in the user's detected_language), and 'confirm_label' (short string, in the user's detected_language) \u2014 or null",
+        reasoning: "string"
+      }
+    }
+  }
+});
+export {
+  actionPlanner
+};

package/dist/services/agent/loops/shared/skills/confirmation-gate.d.ts

@@ -0,0 +1,9 @@
+import { Skill } from '../../../skills/skill';
+type ResponseSchema = {
+    decision: 'CONFIRMED' | 'DECLINED' | 'UNCLEAR';
+    reasoning: string;
+    acknowledgement: string;
+    clarification_prompt: string;
+};
+export declare const confirmationGate: Skill<ResponseSchema>;
+export {};