openloops 0.1.8 → 0.1.10

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

@@ -0,0 +1,207 @@
+import "../../../../../chunk-XRJFNASX.mjs";
+import { ObjectId } from "mongodb";
+import { BaseEntity } from "@common/core/base.entity";
+import { AgentAction } from "./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 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 && ObjectId.isValid(task._id) ? new ObjectId(task._id) : new 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) => 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 = 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;
+  }
+}
+export {
+  AgentTask,
+  TaskStatus
+};

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

@@ -0,0 +1,70 @@
+"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 chat_context_entity_exports = {};
+__export(chat_context_entity_exports, {
+  ChatContext: () => ChatContext
+});
+module.exports = __toCommonJS(chat_context_entity_exports);
+class ChatContext {
+  constructor(props, items) {
+    this.props = props;
+    this.items = items;
+  }
+  props;
+  items;
+  MEMORY_CONTEXT_MAX_CHARS = 1e4;
+  static fromJSON(props) {
+    return new ChatContext(
+      props,
+      props.items
+    );
+  }
+  get length() {
+    return this.items ? JSON.stringify(this.items).length : 0;
+  }
+  get allMeta() {
+    return this.items?.map((item) => item.meta);
+  }
+  toJSON() {
+    return {
+      items: this.items
+    };
+  }
+  addContext(contextRecord) {
+    this.items ??= [];
+    this.items.push(contextRecord);
+  }
+  selectContext(filters) {
+    return this.items?.filter((item) => {
+      return (filters.taskId === void 0 || item.taskId === filters.taskId) && (filters.name === void 0 || item.meta.name === filters.name);
+    });
+  }
+  lastContext(filters) {
+    const matches = this.selectContext(filters);
+    return matches?.[matches.length - 1];
+  }
+  compress() {
+  }
+  pruneContext() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatContext
+});

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

@@ -0,0 +1,47 @@
+import "../../../../../chunk-XRJFNASX.mjs";
+class ChatContext {
+  constructor(props, items) {
+    this.props = props;
+    this.items = items;
+  }
+  props;
+  items;
+  MEMORY_CONTEXT_MAX_CHARS = 1e4;
+  static fromJSON(props) {
+    return new ChatContext(
+      props,
+      props.items
+    );
+  }
+  get length() {
+    return this.items ? JSON.stringify(this.items).length : 0;
+  }
+  get allMeta() {
+    return this.items?.map((item) => item.meta);
+  }
+  toJSON() {
+    return {
+      items: this.items
+    };
+  }
+  addContext(contextRecord) {
+    this.items ??= [];
+    this.items.push(contextRecord);
+  }
+  selectContext(filters) {
+    return this.items?.filter((item) => {
+      return (filters.taskId === void 0 || item.taskId === filters.taskId) && (filters.name === void 0 || item.meta.name === filters.name);
+    });
+  }
+  lastContext(filters) {
+    const matches = this.selectContext(filters);
+    return matches?.[matches.length - 1];
+  }
+  compress() {
+  }
+  pruneContext() {
+  }
+}
+export {
+  ChatContext
+};

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

@@ -0,0 +1,58 @@
+"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 chat_message_entity_exports = {};
+__export(chat_message_entity_exports, {
+  ChatMessage: () => ChatMessage
+});
+module.exports = __toCommonJS(chat_message_entity_exports);
+var import_mongodb = require("mongodb");
+var import_base = require("@common/core/base.entity");
+class ChatMessage extends import_base.BaseEntity {
+  constructor(props, role, content) {
+    super(props);
+    this.props = props;
+    this.role = role;
+    this.content = content;
+  }
+  props;
+  role;
+  content;
+  static factory(message) {
+    const messageId = message._id && import_mongodb.ObjectId.isValid(message._id) ? new import_mongodb.ObjectId(message._id) : new import_mongodb.ObjectId();
+    return ChatMessage.fromJSON({ ...message, _id: messageId });
+  }
+  static fromJSON(props) {
+    return new ChatMessage(
+      props,
+      props.role,
+      props.content
+    );
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      role: this.role,
+      content: this.content
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatMessage
+});

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

@@ -0,0 +1,35 @@
+import "../../../../../chunk-XRJFNASX.mjs";
+import { ObjectId } from "mongodb";
+import { BaseEntity } from "@common/core/base.entity";
+class ChatMessage extends BaseEntity {
+  constructor(props, role, content) {
+    super(props);
+    this.props = props;
+    this.role = role;
+    this.content = content;
+  }
+  props;
+  role;
+  content;
+  static factory(message) {
+    const messageId = message._id && ObjectId.isValid(message._id) ? new ObjectId(message._id) : new ObjectId();
+    return ChatMessage.fromJSON({ ...message, _id: messageId });
+  }
+  static fromJSON(props) {
+    return new ChatMessage(
+      props,
+      props.role,
+      props.content
+    );
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      role: this.role,
+      content: this.content
+    };
+  }
+}
+export {
+  ChatMessage
+};

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

@@ -0,0 +1,63 @@
+"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 chat_settings_entity_exports = {};
+__export(chat_settings_entity_exports, {
+  ChatSettings: () => ChatSettings
+});
+module.exports = __toCommonJS(chat_settings_entity_exports);
+class ChatSettings {
+  constructor(props, notifyOnCompletion, modelName, loopName) {
+    this.props = props;
+    this.notifyOnCompletion = notifyOnCompletion;
+    this.modelName = modelName;
+    this.loopName = loopName;
+  }
+  props;
+  notifyOnCompletion;
+  modelName;
+  loopName;
+  static fromJSON(props) {
+    return new ChatSettings(
+      props,
+      props.notifyOnCompletion,
+      props.modelName,
+      props.loopName
+    );
+  }
+  toJSON() {
+    return {
+      notifyOnCompletion: this.notifyOnCompletion,
+      modelName: this.modelName,
+      loopName: this.loopName
+    };
+  }
+  setLoopName(loopName) {
+    this.loopName = loopName;
+  }
+  setModelName(modelName) {
+    this.modelName = modelName;
+  }
+  setNotifyOnCompletion(notifyOnCompletion) {
+    this.notifyOnCompletion = notifyOnCompletion;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatSettings
+});

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

@@ -0,0 +1,40 @@
+import "../../../../../chunk-XRJFNASX.mjs";
+class ChatSettings {
+  constructor(props, notifyOnCompletion, modelName, loopName) {
+    this.props = props;
+    this.notifyOnCompletion = notifyOnCompletion;
+    this.modelName = modelName;
+    this.loopName = loopName;
+  }
+  props;
+  notifyOnCompletion;
+  modelName;
+  loopName;
+  static fromJSON(props) {
+    return new ChatSettings(
+      props,
+      props.notifyOnCompletion,
+      props.modelName,
+      props.loopName
+    );
+  }
+  toJSON() {
+    return {
+      notifyOnCompletion: this.notifyOnCompletion,
+      modelName: this.modelName,
+      loopName: this.loopName
+    };
+  }
+  setLoopName(loopName) {
+    this.loopName = loopName;
+  }
+  setModelName(modelName) {
+    this.modelName = modelName;
+  }
+  setNotifyOnCompletion(notifyOnCompletion) {
+    this.notifyOnCompletion = notifyOnCompletion;
+  }
+}
+export {
+  ChatSettings
+};

package/dist/services/agent/modules/chats/entities/chat.entity.js

@@ -0,0 +1,163 @@
+"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 chat_entity_exports = {};
+__export(chat_entity_exports, {
+  Chat: () => Chat
+});
+module.exports = __toCommonJS(chat_entity_exports);
+var import_base = require("@common/core/base.entity");
+var import_agent_state = require("@services/agent/core/agent-state");
+var import_chat_message = require("./chat-message.entity");
+var import_chat_settings = require("./chat-settings.entity");
+var import_chat_context = require("./chat-context.entity");
+var import_agent_task = require("./agent-task.entity");
+class Chat extends import_base.BaseEntity {
+  constructor(props, state, settings, messages, context = import_chat_context.ChatContext.fromJSON({}), tasks = [], traces) {
+    super(props);
+    this.props = props;
+    this.state = state;
+    this.settings = settings;
+    this.messages = messages;
+    this.context = context;
+    this.tasks = tasks;
+    this.traces = traces;
+  }
+  props;
+  state;
+  settings;
+  messages;
+  context;
+  tasks;
+  traces;
+  static withDefaults(loopName) {
+    const agentState = new import_agent_state.AgentState();
+    agentState.cleanContext();
+    return Chat.fromJSON({
+      state: agentState.toJSON(),
+      settings: { loopName }
+    });
+  }
+  static fromJSON(props) {
+    return new Chat(
+      props,
+      props.state && import_agent_state.AgentState.fromJSON(props.state),
+      props.settings && import_chat_settings.ChatSettings.fromJSON(props.settings),
+      props.messages?.map((message) => import_chat_message.ChatMessage.factory(message)),
+      import_chat_context.ChatContext.fromJSON(props.context ?? {}),
+      props.tasks?.map((task) => import_agent_task.AgentTask.fromJSON(task)) ?? [],
+      props.traces
+    );
+  }
+  get lastAnswer() {
+    return this.messages?.slice().reverse().find((message) => message.role === "assistant")?.content;
+  }
+  get activeTask() {
+    if (!this.state?.activeTaskId) return void 0;
+    return this.tasks.find((t) => t.id === this.state?.activeTaskId);
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      state: this.state?.toJSON(),
+      settings: this.settings?.toJSON(),
+      messages: this.messages?.map((message) => message.toJSON()),
+      context: this.context.toJSON(),
+      tasks: this.tasks.map((task) => task.toJSON()),
+      traces: this.traces
+    };
+  }
+  pushMessage(message) {
+    this.messages ??= [];
+    this.messages.push(import_chat_message.ChatMessage.factory(message));
+  }
+  lastHistoryMessages(count = 6) {
+    return this.messages?.slice(-count, -1);
+  }
+  addTrace(entry) {
+    this.traces ??= [];
+    this.traces.push({
+      ...entry,
+      taskId: entry.taskId ?? this.activeTask?.id,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  setAgentState(contextState) {
+    this.state = import_agent_state.AgentState.fromJSON(contextState);
+  }
+  getTask(taskId) {
+    return this.tasks.find((t) => t.id === taskId);
+  }
+  lastCompletedTask() {
+    return this.tasks.slice().reverse().find((t) => t.status === import_agent_task.TaskStatus.COMPLETED && t.loopName === this.settings?.loopName);
+  }
+  createTask(goal, opts) {
+    if (this.activeTask?.status === import_agent_task.TaskStatus.IN_PROGRESS) {
+      this.activeTask.pause();
+    }
+    const continuesFromTask = opts?.continuesFrom ? this.getTask(opts.continuesFrom) : void 0;
+    const newTask = import_agent_task.AgentTask.factory({
+      goal,
+      threadId: continuesFromTask?.threadId,
+      previousTaskId: opts?.continuesFrom,
+      loopName: this.settings?.loopName
+    });
+    newTask.threadId ??= newTask.id;
+    this.tasks.push(newTask);
+    this.state?.setActiveTaskId(newTask.id);
+    return newTask;
+  }
+  reopenTask(taskId) {
+    const task = this.getTask(taskId);
+    if (!task) return void 0;
+    task.reopen();
+    this.state?.setActiveTaskId(task.id);
+    return task;
+  }
+  completeTask(taskId, summary) {
+    const task = taskId ? this.getTask(taskId) : this.activeTask;
+    task?.complete(summary);
+    this.clearActiveTaskIdIfMatches(task);
+  }
+  failTask(taskId) {
+    const task = taskId ? this.getTask(taskId) : this.activeTask;
+    task?.fail();
+    this.clearActiveTaskIdIfMatches(task);
+  }
+  cancelTask(taskId) {
+    const task = taskId ? this.getTask(taskId) : this.activeTask;
+    task?.cancel();
+    this.clearActiveTaskIdIfMatches(task);
+  }
+  clearActiveTaskIdIfMatches(task) {
+    if (task?.id === this.state?.activeTaskId) {
+      this.state?.setActiveTaskId(void 0);
+    }
+  }
+  switchLoop(loopName) {
+    if (this.settings?.loopName && this.settings.loopName !== loopName) {
+      this.activeTask?.pause();
+      this.state?.setActiveTaskId(void 0);
+    }
+    this.settings?.setLoopName(loopName);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Chat
+});