@dudousxd/nestjs-agent-core 0.26.0 → 0.27.0

package/dist/index.cjs

@@ -67,6 +67,7 @@ __export(src_exports, {
   DefaultRolesPolicy: () => DefaultRolesPolicy,
   ELICITATION_INPUT_TYPES: () => ELICITATION_INPUT_TYPES,
   GLOBAL_SCOPE: () => GLOBAL_SCOPE,
+  InMemoryAgentStore: () => InMemoryAgentStore,
   MAX_ASK_QUESTIONS: () => MAX_ASK_QUESTIONS,
   OutputRejectedError: () => OutputRejectedError,
   ProcessorFailedError: () => ProcessorFailedError,
@@ -2680,13 +2681,12 @@ var DefaultRolesPolicy = class {
     __name(this, "DefaultRolesPolicy");
   }
   defaultRoles;
-  constructor(defaultRoles = [
-    "ADMIN"
-  ]) {
+  constructor(defaultRoles = []) {
     this.defaultRoles = defaultRoles;
   }
   can(actor, tool) {
     const allowed = tool.roles ?? this.defaultRoles;
+    if (allowed.length === 0) return true;
     return (actor.roles ?? []).some((role) => allowed.includes(role));
   }
 };
@@ -4833,6 +4833,681 @@ ${block}`;
   };
 }
 __name(runAgentLoop, "runAgentLoop");
+
+// src/in-memory-store.ts
+var InMemoryAgentStore = class {
+  static {
+    __name(this, "InMemoryAgentStore");
+  }
+  threads = /* @__PURE__ */ new Map();
+  toolCalls = /* @__PURE__ */ new Map();
+  usage = [];
+  runs = /* @__PURE__ */ new Map();
+  now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async createThread(input) {
+    const id = crypto.randomUUID();
+    const ts = this.now();
+    const row = {
+      id,
+      actorRef: input.actor.id,
+      title: input.title ?? "New chat",
+      transient: input.transient ?? false,
+      createdAt: ts,
+      updatedAt: ts,
+      messages: []
+    };
+    this.threads.set(id, row);
+    return this.toSummary(row);
+  }
+  async getThread(threadId) {
+    const row = this.threads.get(threadId);
+    if (row === void 0) {
+      return null;
+    }
+    return {
+      ...this.toSummary(row),
+      messages: row.messages.map((message) => this.withApprovals(message)),
+      ...row.activeStreamId !== void 0 ? {
+        activeStreamId: row.activeStreamId
+      } : {}
+    };
+  }
+  /** A message with the approval record of every call on it that was put to a person. */
+  withApprovals(message) {
+    const approvals = [];
+    for (const call of this.toolCalls.values()) {
+      if (call.messageId !== message.id) {
+        continue;
+      }
+      const approval = toolCallApprovalFromRow({
+        toolCallId: call.toolCallId,
+        status: call.status,
+        approver: call.approver,
+        expiresAt: call.expiresAt,
+        remember: call.remember,
+        executedByRef: call.executedByRef,
+        decidedVia: call.decidedVia,
+        error: call.error
+      });
+      if (approval !== null) {
+        approvals.push(approval);
+      }
+    }
+    return approvals.length > 0 ? {
+      ...message,
+      approvals
+    } : message;
+  }
+  async rememberedApprovals(threadId) {
+    const names = /* @__PURE__ */ new Set();
+    for (const call of this.toolCalls.values()) {
+      if (call.threadId === threadId && call.remember === true) {
+        names.add(call.toolName);
+      }
+    }
+    return [
+      ...names
+    ];
+  }
+  async toolCallInput(toolCallId) {
+    return this.toolCalls.get(toolCallId)?.input ?? null;
+  }
+  async toolCallApproval(toolCallId) {
+    const call = this.toolCalls.get(toolCallId);
+    if (call === void 0) {
+      return null;
+    }
+    return {
+      status: call.status,
+      approver: call.approver ?? null,
+      expiresAt: call.expiresAt ?? null
+    };
+  }
+  async listThreads(actorRef, limit = 50) {
+    return [
+      ...this.threads.values()
+    ].filter((row) => row.actorRef === actorRef && !row.transient).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit).map((row) => this.toSummary(row));
+  }
+  async softDeleteThread(threadId) {
+    this.threads.delete(threadId);
+  }
+  async forkThread(threadId, fromMessageId) {
+    const source = this.threads.get(threadId);
+    if (source === void 0) {
+      throw new Error(`thread ${threadId} not found`);
+    }
+    const cutoff = source.messages.findIndex((message) => message.id === fromMessageId);
+    const kept = cutoff >= 0 ? source.messages.slice(0, cutoff + 1) : [
+      ...source.messages
+    ];
+    const id = crypto.randomUUID();
+    const ts = this.now();
+    const row = {
+      id,
+      actorRef: source.actorRef,
+      title: source.title,
+      transient: false,
+      createdAt: ts,
+      updatedAt: ts,
+      // Feedback rates a message in ITS thread; a fork starts unrated.
+      messages: kept.map(({ feedback: _feedback, ...message }) => ({
+        ...message
+      })),
+      ...source.defaultAgent != null ? {
+        defaultAgent: source.defaultAgent
+      } : {},
+      ...source.model != null ? {
+        model: source.model
+      } : {}
+    };
+    this.threads.set(id, row);
+    return this.toSummary(row);
+  }
+  async ownerOfThread(threadId) {
+    return this.threads.get(threadId)?.actorRef ?? null;
+  }
+  async ownerOfToolCall(toolCallId) {
+    const call = this.toolCalls.get(toolCallId);
+    if (call === void 0) {
+      return null;
+    }
+    return this.threads.get(call.threadId)?.actorRef ?? null;
+  }
+  async runForToolCall(toolCallId) {
+    const call = this.toolCalls.get(toolCallId);
+    if (call === void 0) {
+      return null;
+    }
+    return call.runId ?? this.threads.get(call.threadId)?.activeStreamId ?? null;
+  }
+  async ownerOfActiveStream(runId) {
+    for (const row of this.threads.values()) {
+      if (row.activeStreamId === runId) {
+        return row.actorRef;
+      }
+    }
+    return null;
+  }
+  async setTitle(threadId, title) {
+    const row = this.threads.get(threadId);
+    if (row !== void 0) {
+      row.title = title;
+      row.updatedAt = this.now();
+    }
+  }
+  async updateThread(threadId, patch) {
+    const row = this.threads.get(threadId);
+    if (row === void 0) {
+      return;
+    }
+    if (patch.title !== void 0) {
+      row.title = patch.title;
+    }
+    if (patch.defaultAgent !== void 0) {
+      row.defaultAgent = patch.defaultAgent;
+    }
+    if (patch.model !== void 0) {
+      row.model = patch.model;
+    }
+    row.updatedAt = this.now();
+  }
+  async activeRunForThread(threadId) {
+    return this.threads.get(threadId)?.activeStreamId ?? null;
+  }
+  /**
+  * The thread's default agent, projected. A map lookup here, but the SQL adapters answer this with
+  * a one-column read instead of materializing the whole transcript — so the caller that only needs
+  * this scalar has a method to ask for it.
+  */
+  async defaultAgentForThread(threadId) {
+    return this.threads.get(threadId)?.defaultAgent ?? null;
+  }
+  /** The thread's pinned model, projected like {@link defaultAgentForThread}. */
+  async modelForThread(threadId) {
+    return this.threads.get(threadId)?.model ?? null;
+  }
+  /**
+  * Persist the start of a run (turn). Replay-safe: called under a durable localStep.
+  *
+  * Takes the SPI's own {@link RecordRunStartInput} rather than a hand-copied shape: a field added
+  * to the input is otherwise accepted and dropped, silently, by every adapter that re-declares it.
+  */
+  async recordRunStart(run) {
+    this.runs.set(run.runId, {
+      runId: run.runId,
+      threadId: run.threadId,
+      actorRef: run.actorRef,
+      status: "running",
+      retries: 0,
+      startedAt: this.now(),
+      ...run.agentName !== void 0 ? {
+        agentName: run.agentName
+      } : {},
+      ...run.parentRunId !== void 0 ? {
+        parentRunId: run.parentRunId
+      } : {},
+      ...run.promptHash !== void 0 ? {
+        promptHash: run.promptHash
+      } : {}
+    });
+  }
+  /** Settle a run's outcome. A no-op when the run is unknown (mirrors `setTitle`/`updateThread`). */
+  async recordRunEnd(end) {
+    const row = this.runs.get(end.runId);
+    if (row === void 0) {
+      return;
+    }
+    row.status = end.status;
+    row.settledAt = this.now();
+    if (end.durationMs !== void 0) {
+      row.durationMs = end.durationMs;
+    }
+    if (end.errorCode !== void 0) {
+      row.errorCode = end.errorCode;
+    }
+    if (end.errorMessage !== void 0) {
+      row.errorMessage = end.errorMessage;
+    }
+  }
+  /** Bump the run's llm-step retry counter. */
+  async bumpRunRetries(runId) {
+    const row = this.runs.get(runId);
+    if (row !== void 0) {
+      row.retries += 1;
+    }
+  }
+  async promoteThread(threadId) {
+    const row = this.threads.get(threadId);
+    if (row?.transient) {
+      row.transient = false;
+      row.updatedAt = this.now();
+    }
+  }
+  async setActiveStream(threadId, runId) {
+    const row = this.threads.get(threadId);
+    if (row !== void 0) {
+      if (runId === null) {
+        delete row.activeStreamId;
+      } else {
+        row.activeStreamId = runId;
+      }
+    }
+  }
+  async appendMessage(input) {
+    const row = this.threads.get(input.threadId);
+    if (row === void 0) {
+      throw new Error(`thread ${input.threadId} not found`);
+    }
+    const message = {
+      id: crypto.randomUUID(),
+      role: input.role,
+      content: input.content,
+      createdAt: this.now(),
+      ...input.toolCalls !== void 0 ? {
+        toolCalls: input.toolCalls
+      } : {},
+      ...input.toolResults !== void 0 ? {
+        toolResults: input.toolResults
+      } : {},
+      ...input.attachments !== void 0 ? {
+        attachments: input.attachments
+      } : {},
+      ...input.followUps !== void 0 ? {
+        followUps: input.followUps
+      } : {},
+      ...input.usage !== void 0 ? {
+        usage: input.usage
+      } : {},
+      ...input.agentName !== void 0 ? {
+        agentName: input.agentName
+      } : {},
+      ...input.runId !== void 0 ? {
+        runId: input.runId
+      } : {},
+      ...input.reasoning !== void 0 ? {
+        reasoning: input.reasoning
+      } : {},
+      ...input.reasoningMs !== void 0 ? {
+        reasoningMs: input.reasoningMs
+      } : {},
+      ...input.ui !== void 0 ? {
+        ui: input.ui
+      } : {}
+    };
+    row.messages.push(message);
+    row.updatedAt = message.createdAt;
+    return message;
+  }
+  async setMessageToolResults(messageId, results) {
+    for (const row of this.threads.values()) {
+      const message = row.messages.find((candidate) => candidate.id === messageId);
+      if (message !== void 0) {
+        message.toolResults = results;
+        return;
+      }
+    }
+  }
+  async setMessageUi(messageId, ui) {
+    for (const row of this.threads.values()) {
+      const index = row.messages.findIndex((candidate) => candidate.id === messageId);
+      const message = row.messages[index];
+      if (message !== void 0) {
+        const { ui: _previous, ...rest } = message;
+        row.messages[index] = ui.length > 0 ? {
+          ...rest,
+          ui
+        } : rest;
+        return;
+      }
+    }
+  }
+  async threadOfMessage(messageId) {
+    return this.threadIdForMessage(messageId) ?? null;
+  }
+  async setMessageFeedback(messageId, feedback) {
+    for (const row of this.threads.values()) {
+      const index = row.messages.findIndex((candidate) => candidate.id === messageId);
+      const message = row.messages[index];
+      if (message !== void 0) {
+        const { feedback: _previous, ...rest } = message;
+        row.messages[index] = feedback !== null ? {
+          ...rest,
+          feedback
+        } : rest;
+        return;
+      }
+    }
+  }
+  async truncateFrom(threadId, messageId) {
+    const row = this.threads.get(threadId);
+    if (row === void 0) {
+      return;
+    }
+    const cutoff = row.messages.findIndex((message) => message.id === messageId);
+    if (cutoff >= 0) {
+      row.messages = row.messages.slice(0, cutoff);
+    }
+  }
+  /**
+  * Of `mediaIds`, the ones a surviving message in one of this actor's threads still carries.
+  * Re-derived from the messages each call, so a media whose message was truncated away reads as
+  * unreferenced again.
+  */
+  async referencedMediaIds(actorRef, mediaIds) {
+    if (mediaIds.length === 0) {
+      return [];
+    }
+    const wanted = new Set(mediaIds);
+    const found = /* @__PURE__ */ new Set();
+    for (const thread of this.threads.values()) {
+      if (thread.actorRef !== actorRef) {
+        continue;
+      }
+      for (const message of thread.messages) {
+        for (const attachment of message.attachments ?? []) {
+          if (wanted.has(attachment.mediaId)) {
+            found.add(attachment.mediaId);
+          }
+        }
+      }
+    }
+    return [
+      ...wanted
+    ].filter((mediaId) => found.has(mediaId));
+  }
+  async recordToolCall(input) {
+    this.toolCalls.set(input.toolCallId, {
+      toolCallId: input.toolCallId,
+      messageId: input.messageId,
+      threadId: this.threadIdForMessage(input.messageId) ?? "",
+      toolName: input.toolName,
+      toolType: input.toolType,
+      input: input.input,
+      status: input.status,
+      createdAt: this.now(),
+      ...input.runId !== void 0 ? {
+        runId: input.runId
+      } : {},
+      ...input.approver !== void 0 ? {
+        approver: input.approver
+      } : {},
+      ...input.expiresAt !== void 0 ? {
+        expiresAt: input.expiresAt
+      } : {}
+    });
+  }
+  async updateToolCall(input) {
+    const row = this.toolCalls.get(input.toolCallId);
+    if (row === void 0) {
+      return;
+    }
+    row.status = input.status;
+    if (input.output !== void 0) {
+      row.output = input.output;
+    }
+    if (input.error !== void 0) {
+      row.error = input.error;
+    }
+    if (input.executionMs !== void 0) {
+      row.executionMs = input.executionMs;
+    }
+    if (input.executedByRef !== void 0) {
+      row.executedByRef = input.executedByRef;
+    }
+    if (input.remember !== void 0) {
+      row.remember = input.remember;
+    }
+    if (input.decidedVia !== void 0) {
+      row.decidedVia = input.decidedVia;
+    }
+  }
+  async recordUsage(input) {
+    const createdAt = this.now();
+    this.usage.push({
+      actorRef: input.actorRef,
+      threadId: input.threadId,
+      modelId: input.modelId,
+      inputTokens: input.usage.inputTokens,
+      outputTokens: input.usage.outputTokens,
+      day: createdAt.slice(0, 10),
+      createdAt,
+      ...input.usage.cacheWriteTokens !== void 0 ? {
+        cacheWriteTokens: input.usage.cacheWriteTokens
+      } : {},
+      ...input.usage.cacheReadTokens !== void 0 ? {
+        cacheReadTokens: input.usage.cacheReadTokens
+      } : {},
+      ...input.costUsd !== void 0 ? {
+        costUsd: input.costUsd
+      } : {}
+    });
+  }
+  async quotaToday(actorRef, day) {
+    return this.usageBetween(actorRef, day, day);
+  }
+  async usageBetween(actorRef, fromDay, toDay) {
+    const rows = this.usage.filter((row) => row.actorRef === actorRef && row.day >= fromDay && row.day <= toDay);
+    const usedTokens = rows.reduce((sum, row) => sum + row.inputTokens + row.outputTokens, 0);
+    const costUsd = rows.reduce((sum, row) => sum + (row.costUsd ?? 0), 0);
+    return {
+      usedTokens,
+      costUsd
+    };
+  }
+  /** Test helper: read the recorded usage rows (modelId + token totals). */
+  usageRows() {
+    return this.usage.map((row) => ({
+      actorRef: row.actorRef,
+      tokens: row.inputTokens + row.outputTokens,
+      modelId: row.modelId
+    }));
+  }
+  /** Governance read-model feed: recorded usage rows with the input/output split + thread/day. */
+  governanceUsage() {
+    return this.usage.map((row) => ({
+      actorRef: row.actorRef,
+      threadId: row.threadId,
+      modelId: row.modelId,
+      inputTokens: row.inputTokens,
+      outputTokens: row.outputTokens,
+      day: row.day,
+      createdAt: row.createdAt,
+      ...row.cacheWriteTokens !== void 0 ? {
+        cacheWriteTokens: row.cacheWriteTokens
+      } : {},
+      ...row.cacheReadTokens !== void 0 ? {
+        cacheReadTokens: row.cacheReadTokens
+      } : {},
+      ...row.costUsd !== void 0 ? {
+        costUsd: row.costUsd
+      } : {}
+    }));
+  }
+  /** Governance read-model feed: recorded tool calls with the resolved thread + timestamp. */
+  governanceToolCalls() {
+    return [
+      ...this.toolCalls.values()
+    ].map((row) => ({
+      toolCallId: row.toolCallId,
+      toolName: row.toolName,
+      toolType: row.toolType,
+      status: row.status,
+      threadId: row.threadId,
+      messageId: row.messageId,
+      createdAt: row.createdAt,
+      ...row.executionMs !== void 0 ? {
+        executionMs: row.executionMs
+      } : {},
+      ...row.error !== void 0 ? {
+        error: row.error
+      } : {},
+      ...row.runId !== void 0 ? {
+        runId: row.runId
+      } : {}
+    }));
+  }
+  /** Governance read-model feed: every stored message, thread-resolved, for the thread drill-down. */
+  governanceMessages() {
+    const rows = [];
+    for (const thread of this.threads.values()) {
+      for (const message of thread.messages) {
+        rows.push({
+          messageId: message.id,
+          threadId: thread.id,
+          role: message.role,
+          content: message.content,
+          createdAt: message.createdAt,
+          ...message.agentName !== void 0 ? {
+            agentName: message.agentName
+          } : {}
+        });
+      }
+    }
+    return rows;
+  }
+  /**
+  * Governance read-model feed: tool calls sitting `pending_approval`, joined to their thread
+  * (title/actorRef) and the message that requested them (`agentName`, when the message has one).
+  */
+  governancePendingApprovals() {
+    const rows = [];
+    for (const call of this.toolCalls.values()) {
+      if (call.status !== "pending_approval") {
+        continue;
+      }
+      const thread = this.threads.get(call.threadId);
+      if (thread === void 0) {
+        continue;
+      }
+      const message = thread.messages.find((candidate) => candidate.id === call.messageId);
+      rows.push({
+        toolCallId: call.toolCallId,
+        toolName: call.toolName,
+        input: call.input,
+        threadId: call.threadId,
+        threadTitle: thread.title,
+        actorRef: thread.actorRef,
+        requestedAt: call.createdAt,
+        ...message?.agentName !== void 0 ? {
+          agentName: message.agentName
+        } : {},
+        ...call.runId !== void 0 ? {
+          runId: call.runId
+        } : {}
+      });
+    }
+    return rows;
+  }
+  /** Governance read-model feed: thread metadata (title/actor/message count/last activity). */
+  governanceThreads() {
+    return [
+      ...this.threads.values()
+    ].map((row) => ({
+      threadId: row.id,
+      title: row.title,
+      actorRef: row.actorRef,
+      messageCount: row.messages.length,
+      updatedAt: row.updatedAt
+    }));
+  }
+  /** Governance read-model feed: recorded run outcomes (the reliability surfaces). */
+  governanceRuns() {
+    return [
+      ...this.runs.values()
+    ].map((row) => ({
+      runId: row.runId,
+      threadId: row.threadId,
+      actorRef: row.actorRef,
+      status: row.status,
+      retries: row.retries,
+      startedAt: row.startedAt,
+      ...row.agentName !== void 0 ? {
+        agentName: row.agentName
+      } : {},
+      ...row.parentRunId !== void 0 ? {
+        parentRunId: row.parentRunId
+      } : {},
+      ...row.durationMs !== void 0 ? {
+        durationMs: row.durationMs
+      } : {},
+      ...row.errorCode !== void 0 ? {
+        errorCode: row.errorCode
+      } : {},
+      ...row.errorMessage !== void 0 ? {
+        errorMessage: row.errorMessage
+      } : {},
+      ...row.settledAt !== void 0 ? {
+        settledAt: row.settledAt
+      } : {},
+      ...row.promptHash !== void 0 ? {
+        promptHash: row.promptHash
+      } : {}
+    }));
+  }
+  threadIdForMessage(messageId) {
+    for (const [threadId, row] of this.threads) {
+      if (row.messages.some((message) => message.id === messageId)) {
+        return threadId;
+      }
+    }
+    return void 0;
+  }
+  /** Test helper: read the recorded tool-call rows. */
+  toolCallRows() {
+    return [
+      ...this.toolCalls.values()
+    ].map((row) => ({
+      toolCallId: row.toolCallId,
+      toolName: row.toolName,
+      toolType: row.toolType,
+      status: row.status,
+      input: row.input,
+      ...row.output !== void 0 ? {
+        output: row.output
+      } : {},
+      ...row.error !== void 0 ? {
+        error: row.error
+      } : {},
+      ...row.runId !== void 0 ? {
+        runId: row.runId
+      } : {},
+      ...row.executedByRef !== void 0 ? {
+        executedByRef: row.executedByRef
+      } : {},
+      ...row.approver !== void 0 ? {
+        approver: row.approver
+      } : {},
+      ...row.expiresAt !== void 0 ? {
+        expiresAt: row.expiresAt
+      } : {},
+      ...row.remember !== void 0 ? {
+        remember: row.remember
+      } : {},
+      ...row.decidedVia !== void 0 ? {
+        decidedVia: row.decidedVia
+      } : {}
+    }));
+  }
+  toSummary(row) {
+    const last = row.messages[row.messages.length - 1];
+    return {
+      id: row.id,
+      title: row.title,
+      transient: row.transient,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      ...last !== void 0 ? {
+        lastMessagePreview: last.content.slice(0, 120)
+      } : {},
+      defaultAgent: row.defaultAgent ?? null,
+      ...row.model != null ? {
+        model: row.model
+      } : {}
+    };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_ACTOR_DIRECTORY,
@@ -4881,6 +5556,7 @@ __name(runAgentLoop, "runAgentLoop");
   DefaultRolesPolicy,
   ELICITATION_INPUT_TYPES,
   GLOBAL_SCOPE,
+  InMemoryAgentStore,
   MAX_ASK_QUESTIONS,
   OutputRejectedError,
   ProcessorFailedError,