openloops 0.1.9 → 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.d.ts

@@ -0,0 +1,39 @@
+type ContextRecordType = 'message' | 'file' | 'entity' | 'tool_output' | 'artifact' | 'summary';
+export interface ContextRecord {
+    taskId: string;
+    meta: {
+        name: string;
+        type: ContextRecordType;
+        shortDescription: string;
+    };
+    content: any;
+}
+export interface ChatContextProps {
+    items?: ContextRecord[];
+}
+export declare class ChatContext {
+    private readonly props;
+    items?: ContextRecord[] | undefined;
+    private readonly MEMORY_CONTEXT_MAX_CHARS;
+    static fromJSON(props: ChatContextProps): ChatContext;
+    constructor(props: ChatContextProps, items?: ContextRecord[] | undefined);
+    get length(): number;
+    get allMeta(): {
+        name: string;
+        type: ContextRecordType;
+        shortDescription: string;
+    }[] | undefined;
+    toJSON(): ChatContextProps;
+    addContext(contextRecord: any): void;
+    selectContext(filters: {
+        taskId: string;
+        name: string;
+    }): ContextRecord[] | undefined;
+    lastContext(filters: {
+        taskId: string;
+        name: string;
+    }): ContextRecord | undefined;
+    compress(): void;
+    pruneContext(): void;
+}
+export {};

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.d.ts

@@ -0,0 +1,16 @@
+import { BaseEntity, BaseEntityProps } from '@common/core/base.entity';
+type Roles = 'user' | 'assistant';
+export interface ChatMessageProps extends BaseEntityProps {
+    role?: Roles;
+    content?: string;
+}
+export declare class ChatMessage extends BaseEntity {
+    private readonly props;
+    role?: Roles | undefined;
+    content?: string | undefined;
+    static factory(message: ChatMessageProps): ChatMessage;
+    static fromJSON(props: ChatMessageProps): ChatMessage;
+    constructor(props: ChatMessageProps, role?: Roles | undefined, content?: string | undefined);
+    toJSON(): ChatMessageProps;
+}
+export {};

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.d.ts

@@ -0,0 +1,17 @@
+export interface ChatSettingsProps {
+    notifyOnCompletion?: boolean;
+    modelName?: string;
+    loopName?: string;
+}
+export declare class ChatSettings {
+    private readonly props;
+    notifyOnCompletion?: boolean | undefined;
+    modelName?: string | undefined;
+    loopName?: string | undefined;
+    constructor(props: ChatSettingsProps, notifyOnCompletion?: boolean | undefined, modelName?: string | undefined, loopName?: string | undefined);
+    static fromJSON(props: ChatSettingsProps): ChatSettings;
+    toJSON(): ChatSettingsProps;
+    setLoopName(loopName: string): void;
+    setModelName(modelName: string): void;
+    setNotifyOnCompletion(notifyOnCompletion: boolean): void;
+}

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.d.ts

@@ -0,0 +1,50 @@
+import { BaseEntity, BaseEntityProps } from '@common/core/base.entity';
+import { AgentStateProps, AgentState } from '@services/agent/core/agent-state';
+import { ChatMessage, ChatMessageProps } from './chat-message.entity';
+import { ChatSettings, ChatSettingsProps } from './chat-settings.entity';
+import { ChatContext, ChatContextProps } from './chat-context.entity';
+import { AgentTask, AgentTaskProps } from './agent-task.entity';
+export interface ChatProps extends BaseEntityProps {
+    state?: AgentStateProps;
+    settings?: ChatSettingsProps;
+    messages?: ChatMessageProps[];
+    context?: ChatContextProps;
+    tasks?: AgentTaskProps[];
+    traces?: AgentTrace[];
+}
+export interface AgentTrace {
+    node: string;
+    reasoning?: string;
+    taskId?: string;
+    timestamp?: Date | string;
+}
+export declare class Chat extends BaseEntity {
+    private readonly props;
+    state?: AgentState | undefined;
+    settings?: ChatSettings | undefined;
+    messages?: ChatMessage[] | undefined;
+    context: ChatContext;
+    tasks: AgentTask[];
+    traces?: AgentTrace[] | undefined;
+    static withDefaults(loopName?: string): Chat;
+    static fromJSON(props: ChatProps): Chat;
+    constructor(props: ChatProps, state?: AgentState | undefined, settings?: ChatSettings | undefined, messages?: ChatMessage[] | undefined, context?: ChatContext, tasks?: AgentTask[], traces?: AgentTrace[] | undefined);
+    get lastAnswer(): string | undefined;
+    get activeTask(): AgentTask | undefined;
+    toJSON(): ChatProps;
+    pushMessage(message: ChatMessageProps): void;
+    lastHistoryMessages(count?: number): ChatMessage[] | undefined;
+    addTrace(entry: Omit<AgentTrace, 'timestamp'>): void;
+    setAgentState(contextState: AgentStateProps): void;
+    getTask(taskId: string): AgentTask | undefined;
+    lastCompletedTask(): AgentTask | undefined;
+    createTask(goal: string, opts?: {
+        continuesFrom?: string;
+    }): AgentTask;
+    reopenTask(taskId: string): AgentTask | undefined;
+    completeTask(taskId?: string, summary?: string): void;
+    failTask(taskId?: string): void;
+    cancelTask(taskId?: string): void;
+    private clearActiveTaskIdIfMatches;
+    switchLoop(loopName: string): void;
+}