@codemation/host 0.1.0 → 0.1.2

package/src/domain/credentials/WorkflowCredentialNodeResolver.ts

@@ -1,8 +1,9 @@
 import type { CredentialRequirement, WorkflowDefinition } from "@codemation/core";
 import {
   AgentConfigInspector,
+  AgentConnectionNodeCollector,
+  type AgentConnectionNodeDescriptor,
   ConnectionNodeIdFactory,
-  WorkflowExecutableNodeClassifierFactory,
 } from "@codemation/core";
 
 import { injectable } from "@codemation/core";
@@ -27,48 +28,18 @@ export class WorkflowCredentialNodeResolver {
     if (direct) {
       return direct.name ?? direct.config.name ?? direct.id;
     }
-    if (ConnectionNodeIdFactory.isLanguageModelConnectionNodeId(nodeId)) {
-      const parentId = this.parseParentForLanguageModelConnectionNodeId(nodeId);
-      const parent = parentId ? workflow.nodes.find((n) => n.id === parentId) : undefined;
-      const agentLabel = parent?.name ?? parentId ?? "Agent";
-      return `${agentLabel} › Language model`;
+    const recursive = this.findRecursiveConnectionNode(workflow, nodeId);
+    if (!recursive) {
+      return nodeId;
     }
-    if (ConnectionNodeIdFactory.isToolConnectionNodeId(nodeId)) {
-      const parsed = this.parseToolConnectionNodeId(nodeId);
-      if (!parsed) {
-        return nodeId;
-      }
-      const parent = workflow.nodes.find((n) => n.id === parsed.parentNodeId);
-      const agentLabel = parent?.name ?? parsed.parentNodeId;
-      const toolConfig =
-        parent && AgentConfigInspector.isAgentNodeConfig(parent.config)
-          ? parent.config.tools?.find(
-              (tool) => ConnectionNodeIdFactory.normalizeToolName(tool.name) === parsed.normalizedToolName,
-            )
-          : undefined;
-      const toolLabel = toolConfig?.presentation?.label ?? toolConfig?.name ?? parsed.normalizedToolName;
-      return `${agentLabel} › ${toolLabel}`;
-    }
-    return nodeId;
+    return this.buildRecursiveDisplayLabel(recursive.rootAgentLabel, recursive.entry, recursive.entriesById);
   }
 
   isCredentialNodeIdInWorkflow(workflow: WorkflowDefinition, nodeId: string): boolean {
     if (workflow.nodes.some((n) => n.id === nodeId)) {
       return true;
     }
-    if (ConnectionNodeIdFactory.isLanguageModelConnectionNodeId(nodeId)) {
-      const parent = this.parseParentForLanguageModelConnectionNodeId(nodeId);
-      if (parent && workflow.nodes.some((n) => n.id === parent)) {
-        return true;
-      }
-    }
-    if (ConnectionNodeIdFactory.isToolConnectionNodeId(nodeId)) {
-      const parsed = this.parseToolConnectionNodeId(nodeId);
-      if (parsed && workflow.nodes.some((n) => n.id === parsed.parentNodeId)) {
-        return true;
-      }
-    }
-    return false;
+    return this.findRecursiveConnectionNode(workflow, nodeId) !== undefined;
   }
 
   findRequirement(
@@ -80,83 +51,33 @@ export class WorkflowCredentialNodeResolver {
     if (direct) {
       return direct;
     }
-    if (ConnectionNodeIdFactory.isLanguageModelConnectionNodeId(nodeId)) {
-      const parent = this.parseParentForLanguageModelConnectionNodeId(nodeId);
-      if (parent) {
-        const fromConn = this.findLanguageModelRequirement(workflow, parent, slotKey);
-        if (fromConn) {
-          return fromConn;
-        }
-      }
-    }
-    if (ConnectionNodeIdFactory.isToolConnectionNodeId(nodeId)) {
-      const parsed = this.parseToolConnectionNodeId(nodeId);
-      if (parsed) {
-        const fromConn = this.findToolRequirement(workflow, parsed.parentNodeId, parsed.normalizedToolName, slotKey);
-        if (fromConn) {
-          return fromConn;
-        }
-      }
+    const recursive = this.findRecursiveConnectionNode(workflow, nodeId);
+    if (!recursive) {
+      return undefined;
     }
-    return undefined;
+    const requirement = recursive.entry.credentialSource
+      .getCredentialRequirements?.()
+      ?.find((entry) => entry.slotKey === slotKey);
+    return requirement ? { nodeName: recursive.entry.name, requirement } : undefined;
   }
 
   listSlots(workflow: WorkflowDefinition): ReadonlyArray<WorkflowCredentialSlotRef> {
-    const slots: WorkflowCredentialSlotRef[] = [];
-    const classifier = WorkflowExecutableNodeClassifierFactory.create(workflow);
-    const hasConnectionMetadata = (workflow.connections?.length ?? 0) > 0;
+    const slotsByKey = new Map<string, WorkflowCredentialSlotRef>();
 
     for (const node of workflow.nodes) {
-      if (classifier.isConnectionOwnedNodeId(node.id)) {
-        for (const requirement of node.config.getCredentialRequirements?.() ?? []) {
-          slots.push({
-            workflowId: workflow.id,
-            nodeId: node.id,
-            nodeName: node.name ?? node.config.name ?? node.id,
-            requirement,
-          });
-        }
-        continue;
-      }
-
       if (AgentConfigInspector.isAgentNodeConfig(node.config)) {
-        if (!hasConnectionMetadata) {
-          const lmNodeId = ConnectionNodeIdFactory.languageModelConnectionNodeId(node.id);
-          const lmLabel = node.config.chatModel.presentation?.label ?? node.config.chatModel.name;
-          for (const requirement of node.config.chatModel.getCredentialRequirements?.() ?? []) {
-            slots.push({
-              workflowId: workflow.id,
-              nodeId: lmNodeId,
-              nodeName: lmLabel,
-              requirement,
-            });
-          }
-          for (const toolConfig of node.config.tools ?? []) {
-            const toolNodeId = ConnectionNodeIdFactory.toolConnectionNodeId(node.id, toolConfig.name);
-            const toolLabel = toolConfig.presentation?.label ?? toolConfig.name;
-            for (const requirement of toolConfig.getCredentialRequirements?.() ?? []) {
-              slots.push({
-                workflowId: workflow.id,
-                nodeId: toolNodeId,
-                nodeName: toolLabel,
-                requirement,
-              });
-            }
-          }
-        }
+        this.addRecursiveAgentSlots(workflow.id, node.id, node.config, slotsByKey);
         continue;
       }
-
-      for (const requirement of node.config.getCredentialRequirements?.() ?? []) {
-        slots.push({
-          workflowId: workflow.id,
-          nodeId: node.id,
-          nodeName: node.name ?? node.config.name ?? node.id,
-          requirement,
-        });
-      }
-    }
-    return slots;
+      this.addSlotsForRequirements(
+        workflow.id,
+        node.id,
+        node.name ?? node.config.name ?? node.id,
+        node.config.getCredentialRequirements?.() ?? [],
+        slotsByKey,
+      );
+    }
+    return [...slotsByKey.values()];
   }
 
   private findDirectRequirement(
@@ -175,72 +96,106 @@ export class WorkflowCredentialNodeResolver {
     return { nodeName: node.name ?? node.config.name ?? node.id, requirement };
   }
 
-  private findLanguageModelRequirement(
-    workflow: WorkflowDefinition,
-    parentNodeId: string,
-    slotKey: string,
-  ): Readonly<{ nodeName: string; requirement: CredentialRequirement }> | undefined {
-    const parent = workflow.nodes.find((entry) => entry.id === parentNodeId);
-    if (!parent || !AgentConfigInspector.isAgentNodeConfig(parent.config)) {
-      return undefined;
+  private addRecursiveAgentSlots(
+    workflowId: string,
+    rootAgentNodeId: string,
+    agentConfig: Parameters<typeof AgentConnectionNodeCollector.collect>[1],
+    slotsByKey: Map<string, WorkflowCredentialSlotRef>,
+  ): void {
+    for (const entry of AgentConnectionNodeCollector.collect(rootAgentNodeId, agentConfig)) {
+      this.addSlotsForRequirements(
+        workflowId,
+        entry.nodeId,
+        entry.name,
+        entry.credentialSource.getCredentialRequirements?.() ?? [],
+        slotsByKey,
+      );
     }
-    const requirement = parent.config.chatModel
-      .getCredentialRequirements?.()
-      ?.find((entry) => entry.slotKey === slotKey);
-    if (!requirement) {
-      return undefined;
+  }
+
+  private addSlotsForRequirements(
+    workflowId: string,
+    nodeId: string,
+    nodeName: string,
+    requirements: ReadonlyArray<CredentialRequirement>,
+    slotsByKey: Map<string, WorkflowCredentialSlotRef>,
+  ): void {
+    for (const requirement of requirements) {
+      const key = `${nodeId}\0${requirement.slotKey}`;
+      if (slotsByKey.has(key)) {
+        continue;
+      }
+      slotsByKey.set(key, {
+        workflowId,
+        nodeId,
+        nodeName,
+        requirement,
+      });
     }
-    const nodeName =
-      parent.config.chatModel.presentation?.label ?? parent.config.chatModel.name ?? parent.name ?? parent.id;
-    return { nodeName, requirement };
   }
 
-  private findToolRequirement(
+  private findRecursiveConnectionNode(
     workflow: WorkflowDefinition,
-    parentNodeId: string,
-    normalizedToolName: string,
-    slotKey: string,
-  ): Readonly<{ nodeName: string; requirement: CredentialRequirement }> | undefined {
-    const parent = workflow.nodes.find((entry) => entry.id === parentNodeId);
-    if (!parent || !AgentConfigInspector.isAgentNodeConfig(parent.config)) {
-      return undefined;
-    }
-    const toolConfig = parent.config.tools?.find(
-      (tool) => ConnectionNodeIdFactory.normalizeToolName(tool.name) === normalizedToolName,
-    );
-    if (!toolConfig) {
+    nodeId: string,
+  ):
+    | Readonly<{
+        rootAgentNodeId: string;
+        rootAgentLabel: string;
+        entry: AgentConnectionNodeDescriptor;
+        entriesById: ReadonlyMap<string, AgentConnectionNodeDescriptor>;
+      }>
+    | undefined {
+    if (
+      !ConnectionNodeIdFactory.isLanguageModelConnectionNodeId(nodeId) &&
+      !ConnectionNodeIdFactory.isToolConnectionNodeId(nodeId)
+    ) {
       return undefined;
     }
-    const requirement = toolConfig.getCredentialRequirements?.()?.find((entry) => entry.slotKey === slotKey);
-    if (!requirement) {
-      return undefined;
+    for (const node of workflow.nodes) {
+      if (!AgentConfigInspector.isAgentNodeConfig(node.config)) {
+        continue;
+      }
+      const entries = AgentConnectionNodeCollector.collect(node.id, node.config);
+      const entriesById = new Map(entries.map((entry) => [entry.nodeId, entry]));
+      const entry = entriesById.get(nodeId);
+      if (!entry) {
+        continue;
+      }
+      return {
+        rootAgentNodeId: node.id,
+        rootAgentLabel: node.name ?? node.config.name ?? node.id,
+        entry,
+        entriesById,
+      };
     }
-    const nodeName = toolConfig.presentation?.label ?? toolConfig.name ?? parent.name ?? parent.id;
-    return { nodeName, requirement };
+    return undefined;
   }
 
-  private parseParentForLanguageModelConnectionNodeId(nodeId: string): string | undefined {
-    if (!ConnectionNodeIdFactory.isLanguageModelConnectionNodeId(nodeId)) {
-      return undefined;
-    }
-    const suffix = `${ConnectionNodeIdFactory.connectionSegment}llm`;
-    return nodeId.slice(0, -suffix.length);
+  private buildRecursiveDisplayLabel(
+    rootAgentLabel: string,
+    entry: AgentConnectionNodeDescriptor,
+    entriesById: ReadonlyMap<string, AgentConnectionNodeDescriptor>,
+  ): string {
+    const labels = [rootAgentLabel, ...this.collectAncestorToolLabels(entry.parentNodeId, entriesById)];
+    labels.push(entry.role === "languageModel" ? "Language model" : entry.name);
+    return labels.join(" › ");
   }
 
-  private parseToolConnectionNodeId(nodeId: string): { parentNodeId: string; normalizedToolName: string } | undefined {
-    if (!ConnectionNodeIdFactory.isToolConnectionNodeId(nodeId)) {
-      return undefined;
-    }
-    const marker = `${ConnectionNodeIdFactory.connectionSegment}tool${ConnectionNodeIdFactory.connectionSegment}`;
-    const idx = nodeId.indexOf(marker);
-    if (idx < 0) {
-      return undefined;
-    }
-    const parentNodeId = nodeId.slice(0, idx);
-    const normalizedToolName = nodeId.slice(idx + marker.length);
-    if (!parentNodeId || !normalizedToolName) {
-      return undefined;
+  private collectAncestorToolLabels(
+    parentNodeId: string,
+    entriesById: ReadonlyMap<string, AgentConnectionNodeDescriptor>,
+  ): ReadonlyArray<string> {
+    const labels: string[] = [];
+    let currentNodeId = parentNodeId;
+    while (true) {
+      const parentEntry = entriesById.get(currentNodeId);
+      if (!parentEntry) {
+        return labels.reverse();
+      }
+      if (parentEntry.role === "tool" || parentEntry.role === "nestedAgent") {
+        labels.push(parentEntry.name);
+      }
+      currentNodeId = parentEntry.parentNodeId;
     }
-    return { parentNodeId, normalizedToolName };
   }
 }

package/src/domain/runs/WorkflowRunRepository.ts

@@ -1,11 +1,17 @@
-import type { PersistedRunState, RunId, RunSummary } from "@codemation/core";
+import type { PersistedRunState, RunId, RunPruneCandidate, RunSummary, WorkflowRunDetailDto } from "@codemation/core";
 
 export interface WorkflowRunRepository {
   load(runId: string): Promise<PersistedRunState | undefined>;
 
+  loadRunDetail?(runId: string): Promise<WorkflowRunDetailDto | undefined>;
+
   save(state: PersistedRunState): Promise<void>;
 
   listRuns(args: Readonly<{ workflowId?: string; limit?: number }>): Promise<ReadonlyArray<RunSummary>>;
 
+  listRunsOlderThan?(args: Readonly<{ beforeIso: string; limit?: number }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+
+  listBinaryStorageKeys?(runId: RunId): Promise<ReadonlyArray<string>>;
+
   deleteRun(runId: RunId): Promise<void>;
 }

package/src/infrastructure/persistence/InMemoryWorkflowRunRepository.ts

@@ -3,10 +3,14 @@ import {
   type NodeId,
   type NodeOutputs,
   type ParentExecutionRef,
+  type PersistedRunSchedulingState,
   type PersistedRunState,
   type RunId,
   type RunPruneCandidate,
   type RunSummary,
+  type ExecutionInstanceDto,
+  type SlotExecutionStateDto,
+  type WorkflowRunDetailDto,
   type WorkflowExecutionRepository,
   type WorkflowId,
 } from "@codemation/core";
@@ -34,6 +38,7 @@ export class InMemoryWorkflowRunRepository implements WorkflowRunRepository, Wor
       runId: args.runId,
       workflowId: args.workflowId,
       startedAt: args.startedAt,
+      revision: 0,
       parent: args.parent,
       executionOptions: args.executionOptions,
       control: args.control,
@@ -53,8 +58,90 @@ export class InMemoryWorkflowRunRepository implements WorkflowRunRepository, Wor
     return this.runs.get(decodeURIComponent(runId) as RunId);
   }
 
+  async loadSchedulingState(runId: string): Promise<PersistedRunSchedulingState | undefined> {
+    const state = await this.load(runId);
+    if (!state) {
+      return undefined;
+    }
+    return {
+      pending: state.pending ? { ...state.pending } : undefined,
+      queue: state.queue.map((entry) => ({ ...entry })),
+    };
+  }
+
   async save(state: PersistedRunState): Promise<void> {
-    this.runs.set(state.runId, state);
+    this.runs.set(state.runId, { ...state, revision: (state.revision ?? 0) + 1 });
+  }
+
+  async loadRunDetail(runId: string): Promise<WorkflowRunDetailDto | undefined> {
+    const state = await this.load(runId);
+    if (!state) {
+      return undefined;
+    }
+    const slotStates: SlotExecutionStateDto[] = Object.entries(state.nodeSnapshotsByNodeId).map(
+      ([slotNodeId, snapshot]) => ({
+        slotNodeId,
+        latestInstanceId: snapshot.activationId
+          ? `${state.runId}:node:${slotNodeId}:${snapshot.activationId}`
+          : undefined,
+        latestTerminalInstanceId:
+          snapshot.status === "completed" || snapshot.status === "failed"
+            ? snapshot.activationId
+              ? `${state.runId}:node:${slotNodeId}:${snapshot.activationId}`
+              : undefined
+            : undefined,
+        latestRunningInstanceId:
+          snapshot.status === "queued" || snapshot.status === "running"
+            ? snapshot.activationId
+              ? `${state.runId}:node:${slotNodeId}:${snapshot.activationId}`
+              : undefined
+            : undefined,
+        status: snapshot.status,
+        invocationCount: (state.connectionInvocations ?? []).filter((inv) => inv.connectionNodeId === slotNodeId)
+          .length,
+        runCount: 1,
+      }),
+    );
+    const executionInstances: ExecutionInstanceDto[] = Object.entries(state.nodeSnapshotsByNodeId).map(
+      ([slotNodeId, snapshot]) => ({
+        instanceId: `${state.runId}:node:${slotNodeId}:${snapshot.activationId ?? "na"}`,
+        slotNodeId,
+        workflowNodeId: slotNodeId,
+        kind: "workflowNodeActivation",
+        runIndex: 1,
+        batchId: state.pending?.batchId ?? "batch_1",
+        activationId: snapshot.activationId,
+        status: snapshot.status,
+        queuedAt: snapshot.queuedAt,
+        startedAt: snapshot.startedAt,
+        finishedAt: snapshot.finishedAt,
+        itemCount: Object.values(snapshot.inputsByPort ?? {}).reduce((count, items) => count + items.length, 0),
+        inputJson: snapshot.inputsByPort as never,
+        outputJson: snapshot.outputs as never,
+        error: snapshot.error,
+      }),
+    );
+    return {
+      runId: state.runId,
+      workflowId: state.workflowId,
+      startedAt: state.startedAt,
+      finishedAt: state.finishedAt,
+      status: state.status,
+      workflowSnapshot: state.workflowSnapshot,
+      mutableState: state.mutableState,
+      slotStates,
+      executionInstances,
+    };
+  }
+
+  async listBinaryStorageKeys(runId: RunId): Promise<ReadonlyArray<string>> {
+    const state = await this.load(runId);
+    if (!state) {
+      return [];
+    }
+    const keys = new Set<string>();
+    this.collectBinaryKeysFromRunState(state, keys);
+    return [...keys].sort((left, right) => left.localeCompare(right));
   }
 
   async deleteRun(runId: RunId): Promise<void> {
@@ -91,4 +178,39 @@ export class InMemoryWorkflowRunRepository implements WorkflowRunRepository, Wor
     out.sort((a, b) => a.finishedAt.localeCompare(b.finishedAt));
     return out.slice(0, limit);
   }
+
+  private collectBinaryKeysFromRunState(state: PersistedRunState, keys: Set<string>): void {
+    for (const outputs of Object.values(state.outputsByNode)) {
+      for (const items of Object.values(outputs)) {
+        this.collectBinaryKeysFromItems(items, keys);
+      }
+    }
+    for (const snapshot of Object.values(state.nodeSnapshotsByNodeId)) {
+      for (const items of Object.values(snapshot.inputsByPort ?? {})) {
+        this.collectBinaryKeysFromItems(items, keys);
+      }
+      for (const items of Object.values(snapshot.outputs ?? {})) {
+        this.collectBinaryKeysFromItems(items, keys);
+      }
+    }
+    for (const nodeState of Object.values(state.mutableState?.nodesById ?? {})) {
+      for (const items of Object.values(nodeState.pinnedOutputsByPort ?? {})) {
+        this.collectBinaryKeysFromItems(items, keys);
+      }
+      this.collectBinaryKeysFromItems(nodeState.lastDebugInput, keys);
+    }
+  }
+
+  private collectBinaryKeysFromItems(
+    items: PersistedRunState["outputsByNode"][string][string] | undefined,
+    keys: Set<string>,
+  ): void {
+    for (const item of items ?? []) {
+      for (const attachment of Object.values(item.binary ?? {})) {
+        if (attachment.storageKey.length > 0) {
+          keys.add(attachment.storageKey);
+        }
+      }
+    }
+  }
 }