openloops 0.1.9 → 0.1.11

package/dist/services/agent/modules/chats/entities/agent-action.entity.d.ts

@@ -0,0 +1,58 @@
+import { BaseEntity, BaseEntityProps } from '../../../../../common/core/base.entity.js';
+import { Tool, BaseParams } from '../../../tools/tool.js';
+export type ActionStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface ActionErrorProps {
+    message: string;
+    [key: string]: any;
+}
+export interface AgentActionProps extends BaseEntityProps {
+    name?: string;
+    stepId?: string;
+    args?: Record<string, any>;
+    dependsOn?: string[];
+    status?: ActionStatus;
+    output?: any;
+    error?: ActionErrorProps;
+    reasoning?: string;
+    retries?: number;
+    author?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+export declare class AgentAction extends BaseEntity {
+    private readonly props;
+    name?: string | undefined;
+    stepId?: string | undefined;
+    args?: Record<string, any> | undefined;
+    dependsOn?: string[] | undefined;
+    status?: ActionStatus | undefined;
+    output?: any | undefined;
+    error?: ActionErrorProps | undefined;
+    reasoning?: string | undefined;
+    retries?: number | undefined;
+    author?: string | undefined;
+    startedAt?: Date | undefined;
+    completedAt?: Date | undefined;
+    static factory(action: AgentActionProps): AgentAction;
+    static fromJSON(props: AgentActionProps): AgentAction;
+    constructor(props: AgentActionProps, name?: string | undefined, stepId?: string | undefined, args?: Record<string, any> | undefined, dependsOn?: string[] | undefined, status?: ActionStatus | undefined, output?: any | undefined, error?: ActionErrorProps | undefined, reasoning?: string | undefined, retries?: number | undefined, author?: string | undefined, startedAt?: Date | undefined, completedAt?: Date | undefined);
+    toJSON(): AgentActionProps;
+    get id(): string;
+    get isReady(): boolean;
+    get isTerminal(): boolean;
+    dependenciesSatisfiedBy(completedRefs: Set<string>): boolean;
+    markRunning(): void;
+    markCompleted(output: any): void;
+    markFailed(error: ActionErrorProps): void;
+    incrementRetries(): number;
+    resetForRetry(): void;
+    runTool(tool: Tool | undefined, args: Record<string, any>, baseParams: BaseParams): Promise<this>;
+}
+export interface ActionDescriptor {
+    name: string;
+    stepId?: string;
+    args?: Record<string, any>;
+    dependsOn?: string[];
+    reasoning?: string;
+    author?: string;
+}

package/dist/services/agent/modules/chats/entities/agent-action.entity.js

@@ -0,0 +1,151 @@
+"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 agent_action_entity_exports = {};
+__export(agent_action_entity_exports, {
+  AgentAction: () => AgentAction
+});
+module.exports = __toCommonJS(agent_action_entity_exports);
+var import_mongodb = require("mongodb");
+var import_base = require("../../../../../common/core/base.entity.js");
+class AgentAction extends import_base.BaseEntity {
+  constructor(props, name, stepId, args, dependsOn, status, output, error, reasoning, retries, author, startedAt, completedAt) {
+    super(props);
+    this.props = props;
+    this.name = name;
+    this.stepId = stepId;
+    this.args = args;
+    this.dependsOn = dependsOn;
+    this.status = status;
+    this.output = output;
+    this.error = error;
+    this.reasoning = reasoning;
+    this.retries = retries;
+    this.author = author;
+    this.startedAt = startedAt;
+    this.completedAt = completedAt;
+  }
+  props;
+  name;
+  stepId;
+  args;
+  dependsOn;
+  status;
+  output;
+  error;
+  reasoning;
+  retries;
+  author;
+  startedAt;
+  completedAt;
+  static factory(action) {
+    const actionId = action._id && import_mongodb.ObjectId.isValid(action._id) ? new import_mongodb.ObjectId(action._id) : new import_mongodb.ObjectId();
+    return AgentAction.fromJSON({ ...action, _id: actionId, status: action.status ?? "pending" });
+  }
+  static fromJSON(props) {
+    return new AgentAction(
+      props,
+      props.name,
+      props.stepId,
+      props.args,
+      props.dependsOn,
+      props.status,
+      props.output,
+      props.error,
+      props.reasoning,
+      props.retries,
+      props.author,
+      props.startedAt,
+      props.completedAt
+    );
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      name: this.name,
+      stepId: this.stepId,
+      args: this.args,
+      dependsOn: this.dependsOn,
+      status: this.status,
+      output: this.output,
+      error: this.error,
+      reasoning: this.reasoning,
+      retries: this.retries,
+      author: this.author,
+      startedAt: this.startedAt,
+      completedAt: this.completedAt
+    };
+  }
+  get id() {
+    return this._id.toString();
+  }
+  get isReady() {
+    return this.status === "pending";
+  }
+  get isTerminal() {
+    return this.status === "completed" || this.status === "failed";
+  }
+  dependenciesSatisfiedBy(completedRefs) {
+    if (!this.dependsOn?.length) return true;
+    return this.dependsOn.every((ref) => completedRefs.has(ref));
+  }
+  markRunning() {
+    this.status = "running";
+    this.startedAt = /* @__PURE__ */ new Date();
+  }
+  markCompleted(output) {
+    this.status = "completed";
+    this.output = output;
+    this.completedAt = /* @__PURE__ */ new Date();
+  }
+  markFailed(error) {
+    this.status = "failed";
+    this.error = error;
+    this.completedAt = /* @__PURE__ */ new Date();
+  }
+  incrementRetries() {
+    this.retries = (this.retries ?? 0) + 1;
+    return this.retries;
+  }
+  /** Vuelve a dejar la action en `pending` para un nuevo intento — usar junto a incrementRetries() */
+  resetForRetry() {
+    this.status = "pending";
+    this.error = void 0;
+    this.startedAt = void 0;
+    this.completedAt = void 0;
+  }
+  /** Corre una tool con los argumentos ya resueltos y registra el resultado en sí misma */
+  async runTool(tool, args, baseParams) {
+    if (!tool) {
+      this.markFailed({ message: `Tool "${this.name}" not found` });
+      return this;
+    }
+    this.markRunning();
+    try {
+      const result = await tool.run({ ...args, ...baseParams });
+      this.markCompleted(result?.data);
+    } catch (error) {
+      this.markFailed({ message: error?.message ?? String(error) });
+    }
+    return this;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentAction
+});

package/dist/services/agent/modules/chats/entities/agent-action.entity.mjs

@@ -0,0 +1,128 @@
+import "../../../../../chunk-XRJFNASX.mjs";
+import { ObjectId } from "mongodb";
+import { BaseEntity } from "../../../../../common/core/base.entity.js";
+class AgentAction extends BaseEntity {
+  constructor(props, name, stepId, args, dependsOn, status, output, error, reasoning, retries, author, startedAt, completedAt) {
+    super(props);
+    this.props = props;
+    this.name = name;
+    this.stepId = stepId;
+    this.args = args;
+    this.dependsOn = dependsOn;
+    this.status = status;
+    this.output = output;
+    this.error = error;
+    this.reasoning = reasoning;
+    this.retries = retries;
+    this.author = author;
+    this.startedAt = startedAt;
+    this.completedAt = completedAt;
+  }
+  props;
+  name;
+  stepId;
+  args;
+  dependsOn;
+  status;
+  output;
+  error;
+  reasoning;
+  retries;
+  author;
+  startedAt;
+  completedAt;
+  static factory(action) {
+    const actionId = action._id && ObjectId.isValid(action._id) ? new ObjectId(action._id) : new ObjectId();
+    return AgentAction.fromJSON({ ...action, _id: actionId, status: action.status ?? "pending" });
+  }
+  static fromJSON(props) {
+    return new AgentAction(
+      props,
+      props.name,
+      props.stepId,
+      props.args,
+      props.dependsOn,
+      props.status,
+      props.output,
+      props.error,
+      props.reasoning,
+      props.retries,
+      props.author,
+      props.startedAt,
+      props.completedAt
+    );
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      name: this.name,
+      stepId: this.stepId,
+      args: this.args,
+      dependsOn: this.dependsOn,
+      status: this.status,
+      output: this.output,
+      error: this.error,
+      reasoning: this.reasoning,
+      retries: this.retries,
+      author: this.author,
+      startedAt: this.startedAt,
+      completedAt: this.completedAt
+    };
+  }
+  get id() {
+    return this._id.toString();
+  }
+  get isReady() {
+    return this.status === "pending";
+  }
+  get isTerminal() {
+    return this.status === "completed" || this.status === "failed";
+  }
+  dependenciesSatisfiedBy(completedRefs) {
+    if (!this.dependsOn?.length) return true;
+    return this.dependsOn.every((ref) => completedRefs.has(ref));
+  }
+  markRunning() {
+    this.status = "running";
+    this.startedAt = /* @__PURE__ */ new Date();
+  }
+  markCompleted(output) {
+    this.status = "completed";
+    this.output = output;
+    this.completedAt = /* @__PURE__ */ new Date();
+  }
+  markFailed(error) {
+    this.status = "failed";
+    this.error = error;
+    this.completedAt = /* @__PURE__ */ new Date();
+  }
+  incrementRetries() {
+    this.retries = (this.retries ?? 0) + 1;
+    return this.retries;
+  }
+  /** Vuelve a dejar la action en `pending` para un nuevo intento — usar junto a incrementRetries() */
+  resetForRetry() {
+    this.status = "pending";
+    this.error = void 0;
+    this.startedAt = void 0;
+    this.completedAt = void 0;
+  }
+  /** Corre una tool con los argumentos ya resueltos y registra el resultado en sí misma */
+  async runTool(tool, args, baseParams) {
+    if (!tool) {
+      this.markFailed({ message: `Tool "${this.name}" not found` });
+      return this;
+    }
+    this.markRunning();
+    try {
+      const result = await tool.run({ ...args, ...baseParams });
+      this.markCompleted(result?.data);
+    } catch (error) {
+      this.markFailed({ message: error?.message ?? String(error) });
+    }
+    return this;
+  }
+}
+export {
+  AgentAction
+};

package/dist/services/agent/modules/chats/entities/agent-task.entity.d.ts

@@ -0,0 +1,59 @@
+import { BaseEntity, BaseEntityProps } from '../../../../../common/core/base.entity.js';
+import { AgentAction, AgentActionProps, ActionDescriptor } from './agent-action.entity';
+import { ChatContext } from './chat-context.entity';
+import { Tool, BaseParams } from '../../../tools/tool.js';
+export declare enum TaskStatus {
+    PENDING = "pending",
+    IN_PROGRESS = "in_progress",
+    AWAITING_USER = "awaiting_user",
+    COMPLETED = "completed",
+    PAUSED = "paused",
+    ABANDONED = "abandoned",
+    CANCELLED = "cancelled",
+    FAILED = "failed"
+}
+export interface AgentTaskProps extends BaseEntityProps {
+    status?: TaskStatus;
+    goal?: string;
+    nextNode?: string;
+    threadId?: string;
+    previousTaskId?: string;
+    summary?: string;
+    loopName?: string;
+    actions?: AgentActionProps[];
+}
+export declare class AgentTask extends BaseEntity {
+    private readonly props;
+    status?: TaskStatus | undefined;
+    goal?: string | undefined;
+    nextNode?: string | undefined;
+    threadId?: string | undefined;
+    previousTaskId?: string | undefined;
+    summary?: string | undefined;
+    loopName?: string | undefined;
+    actions: AgentAction[];
+    static factory(task: AgentTaskProps): AgentTask;
+    static fromJSON(props: AgentTaskProps): AgentTask;
+    constructor(props: AgentTaskProps, status?: TaskStatus | undefined, goal?: string | undefined, nextNode?: string | undefined, threadId?: string | undefined, previousTaskId?: string | undefined, summary?: string | undefined, loopName?: string | undefined, actions?: AgentAction[]);
+    toJSON(): AgentTaskProps;
+    get id(): string;
+    addAction(descriptor: ActionDescriptor): AgentAction;
+    getAction(ref: string): AgentAction | undefined;
+    findLastByName(name: string): AgentAction | undefined;
+    get readyActions(): AgentAction[];
+    get failedActions(): AgentAction[];
+    get lastExecutedAction(): AgentAction | undefined;
+    setNextNode(node?: string): void;
+    complete(summary?: string): void;
+    fail(): void;
+    cancel(): void;
+    pause(): void;
+    reopen(): void;
+    resolveArgs(action: AgentAction, context: ChatContext): any;
+    private resolveValue;
+    private findActionByRef;
+    private readContextValue;
+    runTool(descriptor: ActionDescriptor, tool: Tool | undefined, context: ChatContext, baseParams: BaseParams): Promise<AgentAction>;
+    runReadyAction(actionRef: string, tool: Tool | undefined, context: ChatContext, baseParams: BaseParams): Promise<AgentAction>;
+    private executeToolAction;
+}

package/dist/services/agent/modules/chats/entities/agent-task.entity.js

@@ -0,0 +1,231 @@
+"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 agent_task_entity_exports = {};
+__export(agent_task_entity_exports, {
+  AgentTask: () => AgentTask,
+  TaskStatus: () => TaskStatus
+});
+module.exports = __toCommonJS(agent_task_entity_exports);
+var import_mongodb = require("mongodb");
+var import_base = require("../../../../../common/core/base.entity.js");
+var import_agent_action = require("./agent-action.entity");
+var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
+  TaskStatus2["PENDING"] = "pending";
+  TaskStatus2["IN_PROGRESS"] = "in_progress";
+  TaskStatus2["AWAITING_USER"] = "awaiting_user";
+  TaskStatus2["COMPLETED"] = "completed";
+  TaskStatus2["PAUSED"] = "paused";
+  TaskStatus2["ABANDONED"] = "abandoned";
+  TaskStatus2["CANCELLED"] = "cancelled";
+  TaskStatus2["FAILED"] = "failed";
+  return TaskStatus2;
+})(TaskStatus || {});
+const STEP_REF = /^\{\{step_([\w-]+)\.output\}\}$/;
+const STEP_REF_GLOBAL = /\{\{step_([\w-]+)\.output\}\}/g;
+const CONTEXT_REF = /^\{\{context\.([\w.-]+)\}\}$/;
+const CONTEXT_REF_GLOBAL = /\{\{context\.([\w.-]+)\}\}/g;
+function stringifyValue(value) {
+  return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+class AgentTask extends import_base.BaseEntity {
+  constructor(props, status, goal, nextNode, threadId, previousTaskId, summary, loopName, actions = []) {
+    super(props);
+    this.props = props;
+    this.status = status;
+    this.goal = goal;
+    this.nextNode = nextNode;
+    this.threadId = threadId;
+    this.previousTaskId = previousTaskId;
+    this.summary = summary;
+    this.loopName = loopName;
+    this.actions = actions;
+  }
+  props;
+  status;
+  goal;
+  nextNode;
+  threadId;
+  previousTaskId;
+  summary;
+  loopName;
+  actions;
+  static factory(task) {
+    const taskId = task._id && import_mongodb.ObjectId.isValid(task._id) ? new import_mongodb.ObjectId(task._id) : new import_mongodb.ObjectId();
+    return AgentTask.fromJSON({
+      ...task,
+      _id: taskId,
+      status: task.status ?? "in_progress" /* IN_PROGRESS */
+    });
+  }
+  static fromJSON(props) {
+    return new AgentTask(
+      props,
+      props.status,
+      props.goal,
+      props.nextNode,
+      props.threadId,
+      props.previousTaskId,
+      props.summary,
+      props.loopName,
+      props.actions?.map((a) => import_agent_action.AgentAction.factory(a)) ?? []
+    );
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      status: this.status,
+      goal: this.goal,
+      nextNode: this.nextNode,
+      threadId: this.threadId,
+      previousTaskId: this.previousTaskId,
+      summary: this.summary,
+      loopName: this.loopName,
+      actions: this.actions.map((a) => a.toJSON())
+    };
+  }
+  get id() {
+    return this._id.toString();
+  }
+  addAction(descriptor) {
+    const action = import_agent_action.AgentAction.factory({
+      name: descriptor.name,
+      stepId: descriptor.stepId,
+      args: descriptor.args,
+      dependsOn: descriptor.dependsOn,
+      reasoning: descriptor.reasoning,
+      author: descriptor.author
+    });
+    this.actions.push(action);
+    return action;
+  }
+  getAction(ref) {
+    return this.actions.find((a) => a.id === ref || a.stepId === ref);
+  }
+  findLastByName(name) {
+    return this.actions.slice().reverse().find((a) => a.name === name);
+  }
+  /** Actions en `pending` cuyas dependencias (por stepId o id) ya están `completed` */
+  get readyActions() {
+    const completedRefs = new Set(
+      this.actions.filter((a) => a.status === "completed").flatMap((a) => [a.id, a.stepId].filter(Boolean))
+    );
+    return this.actions.filter((a) => a.isReady && a.dependenciesSatisfiedBy(completedRefs));
+  }
+  get failedActions() {
+    return this.actions.filter((a) => a.status === "failed");
+  }
+  get lastExecutedAction() {
+    return this.actions.slice().reverse().find((a) => a.isTerminal);
+  }
+  setNextNode(node) {
+    this.nextNode = node;
+  }
+  complete(summary) {
+    this.status = "completed" /* COMPLETED */;
+    if (summary) this.summary = summary;
+    this.nextNode = void 0;
+  }
+  fail() {
+    this.status = "failed" /* FAILED */;
+    this.nextNode = void 0;
+  }
+  cancel() {
+    this.status = "cancelled" /* CANCELLED */;
+    this.nextNode = void 0;
+  }
+  pause() {
+    if (this.status === "in_progress" /* IN_PROGRESS */ || this.status === "awaiting_user" /* AWAITING_USER */) {
+      this.status = "paused" /* PAUSED */;
+    }
+  }
+  reopen() {
+    this.status = "in_progress" /* IN_PROGRESS */;
+    this.nextNode = void 0;
+  }
+  resolveArgs(action, context) {
+    return this.resolveValue(action.args, context);
+  }
+  resolveValue(value, context) {
+    if (typeof value === "string") {
+      const stepMatch = value.match(STEP_REF);
+      if (stepMatch) {
+        const target = this.findActionByRef(stepMatch[1]);
+        return target?.output !== void 0 ? target.output : value;
+      }
+      const contextMatch = value.match(CONTEXT_REF);
+      if (contextMatch) {
+        const resolved = this.readContextValue(contextMatch[1], context);
+        return resolved !== void 0 ? resolved : value;
+      }
+      return value.replace(STEP_REF_GLOBAL, (_, ref) => {
+        const target = this.findActionByRef(ref);
+        return target?.output !== void 0 ? stringifyValue(target.output) : "";
+      }).replace(CONTEXT_REF_GLOBAL, (_, name) => {
+        const resolved = this.readContextValue(name, context);
+        return resolved !== void 0 ? stringifyValue(resolved) : "";
+      });
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.resolveValue(item, context));
+    }
+    if (value !== null && typeof value === "object") {
+      const resolved = {};
+      for (const key of Object.keys(value)) {
+        resolved[key] = this.resolveValue(value[key], context);
+      }
+      return resolved;
+    }
+    return value;
+  }
+  findActionByRef(ref) {
+    return this.actions.find((a) => a.stepId === ref || a.id === ref);
+  }
+  readContextValue(name, context) {
+    const matches = context.selectContext({ taskId: this.id, name });
+    return matches?.[0]?.content;
+  }
+  /** Crea una action nueva y la corre de inmediato (estilo reactivo) */
+  async runTool(descriptor, tool, context, baseParams) {
+    const action = this.addAction(descriptor);
+    return this.executeToolAction(action, tool, context, baseParams);
+  }
+  /** Corre una action ya encolada (estilo por lotes: actionPlanner encola, esto ejecuta cuando está `ready`) */
+  async runReadyAction(actionRef, tool, context, baseParams) {
+    const action = this.getAction(actionRef);
+    if (!action) throw new Error(`[AgentTask] Action "${actionRef}" not found`);
+    return this.executeToolAction(action, tool, context, baseParams);
+  }
+  async executeToolAction(action, tool, context, baseParams) {
+    const resolvedArgs = this.resolveArgs(action, context);
+    const executed = await action.runTool(tool, resolvedArgs, baseParams);
+    if (executed.status === "completed" && executed.name) {
+      context.addContext({
+        taskId: this.id,
+        meta: { name: executed.name, type: "tool_output", shortDescription: `Output of ${executed.name}` },
+        content: executed.output
+      });
+    }
+    return executed;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentTask,
+  TaskStatus
+});