@codemation/host 0.1.0 → 0.1.2

package/src/application/mapping/WorkflowDefinitionMapper.ts

@@ -1,12 +1,18 @@
-import type {
-  ChatModelConfig,
-  NodeDefinition,
-  ToolConfig,
-  WorkflowActivationPolicy,
-  WorkflowDefinition,
+import type { AgentNodeConfig, NodeDefinition, WorkflowActivationPolicy, WorkflowDefinition } from "@codemation/core";
+import {
+  AgentConfigInspector,
+  AgentConnectionNodeCollector,
+  CoreTokens,
+  inject,
+  injectable,
+  type AgentConnectionNodeDescriptor,
 } from "@codemation/core";
-import { AgentConfigInspector, ConnectionNodeIdFactory, CoreTokens, inject, injectable } from "@codemation/core";
-import type { WorkflowDto, WorkflowNodeDto, WorkflowSummary } from "../contracts/WorkflowViewContracts";
+import type {
+  WorkflowDto,
+  WorkflowEdgeDto,
+  WorkflowNodeDto,
+  WorkflowSummary,
+} from "../contracts/WorkflowViewContracts";
 import type { DataMapper } from "./DataMapper";
 import { WorkflowPolicyUiPresentationFactory } from "./WorkflowPolicyUiPresentationFactory";
 
@@ -55,17 +61,23 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
     return map;
   }
 
-  private agentHasConnectionMetadata(workflow: WorkflowDefinition, agentNodeId: string): boolean {
-    return (workflow.connections ?? []).some((c) => c.parentNodeId === agentNodeId);
-  }
-
   private toNodes(workflow: WorkflowDefinition): ReadonlyArray<WorkflowNodeDto> {
     const connectionChildMeta = this.buildConnectionChildMeta(workflow);
+    const materializedConnectionNodeIds = new Set(connectionChildMeta.keys());
     const nodes: WorkflowNodeDto[] = [];
     for (const node of workflow.nodes) {
       const conn = connectionChildMeta.get(node.id);
       if (conn) {
-        const role = conn.connectionName === "llm" ? "languageModel" : "tool";
+        const parentNode = workflow.nodes.find((n) => n.id === conn.parentNodeId);
+        let role: string = conn.connectionName === "llm" ? "languageModel" : "tool";
+        if (parentNode && AgentConfigInspector.isAgentNodeConfig(parentNode.config)) {
+          const descriptor = AgentConnectionNodeCollector.collect(conn.parentNodeId, parentNode.config).find(
+            (d) => d.nodeId === node.id,
+          );
+          if (descriptor) {
+            role = descriptor.role;
+          }
+        }
         nodes.push({
           id: node.id,
           kind: node.kind,
@@ -89,71 +101,98 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
         retryPolicySummary: this.policyUi.nodeRetrySummary(node.config),
         hasNodeErrorHandler: this.policyUi.nodeHasErrorHandler(node.config),
       });
-      if (AgentConfigInspector.isAgentNodeConfig(node.config) && !this.agentHasConnectionMetadata(workflow, node.id)) {
-        nodes.push(this.createLanguageModelNode(node, node.config.chatModel));
-        for (const toolConfig of node.config.tools ?? []) {
-          nodes.push(this.createToolNode(node, toolConfig));
-        }
+      if (AgentConfigInspector.isAgentNodeConfig(node.config)) {
+        this.appendVirtualConnectionNodes(node.id, node.config, materializedConnectionNodeIds, nodes);
       }
     }
     return nodes;
   }
 
   private toEdges(workflow: WorkflowDefinition): WorkflowDto["edges"] {
-    const edges = [...workflow.edges];
+    const connectionChildMeta = this.buildConnectionChildMeta(workflow);
+    const materializedConnectionNodeIds = new Set(connectionChildMeta.keys());
+    const edges: WorkflowEdgeDto[] = [...workflow.edges];
+    const edgeKeys = new Set(edges.map((edge) => this.edgeKey(edge.from.nodeId, edge.to.nodeId, edge.to.input)));
+    this.appendMaterializedConnectionEdges(workflow, edgeKeys, edges);
     for (const node of workflow.nodes) {
       if (!AgentConfigInspector.isAgentNodeConfig(node.config)) {
         continue;
       }
-      if (this.agentHasConnectionMetadata(workflow, node.id)) {
-        for (const c of workflow.connections ?? []) {
-          if (c.parentNodeId !== node.id) {
-            continue;
-          }
-          for (const childId of c.childNodeIds) {
-            edges.push({
-              from: { nodeId: node.id, output: "main" },
-              to: { nodeId: childId, input: "in" },
-            });
-          }
+      this.appendVirtualConnectionEdges(node.id, node.config, materializedConnectionNodeIds, edgeKeys, edges);
+    }
+    return edges;
+  }
+
+  private appendMaterializedConnectionEdges(
+    workflow: WorkflowDefinition,
+    edgeKeys: Set<string>,
+    edges: WorkflowEdgeDto[],
+  ): void {
+    for (const connection of workflow.connections ?? []) {
+      for (const childNodeId of connection.childNodeIds) {
+        const key = this.edgeKey(connection.parentNodeId, childNodeId, "in");
+        if (edgeKeys.has(key)) {
+          continue;
         }
+        edges.push({
+          from: { nodeId: connection.parentNodeId, output: "main" },
+          to: { nodeId: childNodeId, input: "in" },
+        });
+        edgeKeys.add(key);
+      }
+    }
+  }
+
+  private appendVirtualConnectionNodes(
+    rootAgentNodeId: string,
+    agentConfig: AgentNodeConfig<any, any>,
+    materializedConnectionNodeIds: ReadonlySet<string>,
+    nodes: WorkflowNodeDto[],
+  ): void {
+    for (const connectionNode of AgentConnectionNodeCollector.collect(rootAgentNodeId, agentConfig)) {
+      if (materializedConnectionNodeIds.has(connectionNode.nodeId)) {
+        continue;
+      }
+      nodes.push(this.createConnectionNode(connectionNode));
+    }
+  }
+
+  private appendVirtualConnectionEdges(
+    rootAgentNodeId: string,
+    agentConfig: AgentNodeConfig<any, any>,
+    materializedConnectionNodeIds: ReadonlySet<string>,
+    edgeKeys: Set<string>,
+    edges: WorkflowEdgeDto[],
+  ): void {
+    for (const connectionNode of AgentConnectionNodeCollector.collect(rootAgentNodeId, agentConfig)) {
+      if (materializedConnectionNodeIds.has(connectionNode.nodeId)) {
+        continue;
+      }
+      const key = this.edgeKey(connectionNode.parentNodeId, connectionNode.nodeId, "in");
+      if (edgeKeys.has(key)) {
         continue;
       }
       edges.push({
-        from: { nodeId: node.id, output: "main" },
-        to: { nodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(node.id), input: "in" },
+        from: { nodeId: connectionNode.parentNodeId, output: "main" },
+        to: { nodeId: connectionNode.nodeId, input: "in" },
       });
-      for (const toolConfig of node.config.tools ?? []) {
-        edges.push({
-          from: { nodeId: node.id, output: "main" },
-          to: { nodeId: ConnectionNodeIdFactory.toolConnectionNodeId(node.id, toolConfig.name), input: "in" },
-        });
-      }
+      edgeKeys.add(key);
     }
-    return edges;
   }
 
-  private createLanguageModelNode(node: NodeDefinition, chatModel: ChatModelConfig): WorkflowNodeDto {
-    return {
-      id: ConnectionNodeIdFactory.languageModelConnectionNodeId(node.id),
-      kind: "node",
-      name: chatModel.presentation?.label ?? chatModel.name,
-      type: chatModel.name,
-      role: "languageModel",
-      icon: chatModel.presentation?.icon,
-      parentNodeId: node.id,
-    };
+  private edgeKey(fromNodeId: string, toNodeId: string, toInput: string): string {
+    return `${fromNodeId}\0${toNodeId}\0${toInput}`;
   }
 
-  private createToolNode(node: NodeDefinition, toolConfig: ToolConfig): WorkflowNodeDto {
+  private createConnectionNode(connectionNode: AgentConnectionNodeDescriptor): WorkflowNodeDto {
     return {
-      id: ConnectionNodeIdFactory.toolConnectionNodeId(node.id, toolConfig.name),
+      id: connectionNode.nodeId,
       kind: "node",
-      name: toolConfig.presentation?.label ?? toolConfig.name,
-      type: toolConfig.name,
-      role: "tool",
-      icon: toolConfig.presentation?.icon,
-      parentNodeId: node.id,
+      name: connectionNode.name,
+      type: connectionNode.typeName,
+      role: connectionNode.role,
+      icon: connectionNode.icon,
+      parentNodeId: connectionNode.parentNodeId,
     };
   }
 

package/src/application/mapping/WorkflowPolicyUiPresentationFactory.ts

@@ -1,4 +1,4 @@
-import type { NodeDefinition, RetryPolicySpec, WorkflowDefinition } from "@codemation/core";
+import type { NodeDefinition, RetryPolicySpec, WorkflowDefinition } from "@codemation/core/browser";
 
 /** UI-facing policy labels derived from workflow/node definitions (live or hydrated snapshot). */
 export class WorkflowPolicyUiPresentationFactory {

package/src/application/queries/GetWorkflowRunDetailQuery.ts

@@ -0,0 +1,8 @@
+import type { WorkflowRunDetailDto } from "@codemation/core";
+import { Query } from "../bus/Query";
+
+export class GetWorkflowRunDetailQuery extends Query<WorkflowRunDetailDto | undefined> {
+  constructor(public readonly runId: string) {
+    super();
+  }
+}

package/src/application/queries/GetWorkflowRunDetailQueryHandler.ts

@@ -0,0 +1,24 @@
+import type { WorkflowRunDetailDto } from "@codemation/core";
+import { inject } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import { HandlesQuery } from "../../infrastructure/di/HandlesQueryRegistry";
+import { QueryHandler } from "../bus/QueryHandler";
+import { GetWorkflowRunDetailQuery } from "./GetWorkflowRunDetailQuery";
+
+@HandlesQuery.for(GetWorkflowRunDetailQuery)
+export class GetWorkflowRunDetailQueryHandler extends QueryHandler<
+  GetWorkflowRunDetailQuery,
+  WorkflowRunDetailDto | undefined
+> {
+  constructor(
+    @inject(ApplicationTokens.WorkflowRunRepository)
+    private readonly workflowRunRepository: WorkflowRunRepository,
+  ) {
+    super();
+  }
+
+  async execute(query: GetWorkflowRunDetailQuery): Promise<WorkflowRunDetailDto | undefined> {
+    return await this.workflowRunRepository.loadRunDetail?.(query.runId);
+  }
+}

package/src/application/queries/WorkflowQueryHandlers.ts

@@ -1,5 +1,6 @@
 export { GetRunBinaryAttachmentQueryHandler } from "./GetRunBinaryAttachmentQueryHandler";
 export { GetRunStateQueryHandler } from "./GetRunStateQueryHandler";
+export { GetWorkflowRunDetailQueryHandler } from "./GetWorkflowRunDetailQueryHandler";
 export { GetWorkflowDebuggerOverlayQueryHandler } from "./GetWorkflowDebuggerOverlayQueryHandler";
 export { GetWorkflowDetailQueryHandler } from "./GetWorkflowDetailQueryHandler";
 export { GetWorkflowOverlayBinaryAttachmentQueryHandler } from "./GetWorkflowOverlayBinaryAttachmentQueryHandler";

package/src/application/runs/WorkflowRunRetentionPruneScheduler.ts

@@ -1,8 +1,7 @@
 import type { BinaryStorage, Clock, RunId, WorkflowId } from "@codemation/core";
-import { CoreTokens, RunFinishedAtFactory } from "@codemation/core";
+import { CoreTokens } from "@codemation/core";
 import { inject, injectable } from "@codemation/core";
 import type { Logger } from "../logging/Logger";
-import { RunStateBinaryStorageKeysCollector } from "../binary/RunStateBinaryStorageKeysCollector";
 import { ApplicationTokens } from "../../applicationTokens";
 import type { AppConfig } from "../../presentation/config/AppConfig";
 import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
@@ -17,7 +16,6 @@ import { ServerLoggerFactory } from "../../infrastructure/logging/ServerLoggerFa
 export class WorkflowRunRetentionPruneScheduler {
   private timer: ReturnType<typeof setInterval> | undefined;
   private readonly logger: Logger;
-  private readonly binaryKeysCollector = new RunStateBinaryStorageKeysCollector();
 
   constructor(
     @inject(ApplicationTokens.Clock) private readonly clock: Clock,
@@ -54,36 +52,24 @@ export class WorkflowRunRetentionPruneScheduler {
   /** Exposed for tests; production path is the interval started by {@link start}. */
   async runOnce(): Promise<void> {
     this.logger.debug("Run retention prune: starting check");
-
     const defaultRetentionSec = Number(this.appConfig.env.CODEMATION_RUN_RETENTION_DEFAULT_SECONDS ?? 86_400);
-    const summaries = await this.runs.listRuns({ limit: 500 });
-    const nowMs = this.clock.now().getTime();
+    const beforeIso = new Date(this.clock.now().getTime() - defaultRetentionSec * 1000).toISOString();
+    const summaries = await this.runs.listRunsOlderThan?.({ beforeIso, limit: 500 });
+    const candidates =
+      summaries ??
+      (await this.runs.listRuns({ limit: 500 })).filter(
+        (summary) => summary.status === "completed" || summary.status === "failed",
+      );
 
     let foundCount = 0;
     let prunedCount = 0;
-    for (const s of summaries) {
-      if (s.status !== "completed" && s.status !== "failed") {
-        continue;
-      }
-      const state = await this.runs.load(s.runId);
-      if (!state) {
-        continue;
-      }
-      const retentionSec = state.policySnapshot?.retentionSeconds ?? defaultRetentionSec;
-      const finishedAt = RunFinishedAtFactory.resolveIso(state) ?? s.finishedAt;
-      if (!finishedAt) {
-        continue;
-      }
-      const ageMs = nowMs - Date.parse(finishedAt);
-      if (ageMs <= retentionSec * 1000) {
-        continue;
-      }
-
-      const runId = s.runId as RunId;
-      const workflowId = s.workflowId as WorkflowId;
+    for (const candidate of candidates) {
+      const runId = candidate.runId as RunId;
+      const workflowId = candidate.workflowId as WorkflowId;
       foundCount += 1;
 
-      const storageKeys = this.binaryKeysCollector.collectFromRunState(state);
+      const storageKeys =
+        (await this.runs.listBinaryStorageKeys?.(runId)) ?? (await this.loadStorageKeysFromRunStateFallback(runId));
       for (const key of storageKeys) {
         await this.binaryStorage.delete(key);
       }
@@ -95,4 +81,43 @@ export class WorkflowRunRetentionPruneScheduler {
     this.logger.info(`Run retention prune: found ${foundCount} run(s) to prune`);
     this.logger.info(`Run retention prune: pruned ${prunedCount} run(s)`);
   }
+
+  private async loadStorageKeysFromRunStateFallback(runId: RunId): Promise<ReadonlyArray<string>> {
+    const state = await this.runs.load(runId);
+    if (!state) {
+      return [];
+    }
+    const keys = new Set<string>();
+    this.collectStorageKeysFromValue(state.outputsByNode, keys);
+    this.collectStorageKeysFromValue(state.nodeSnapshotsByNodeId, keys);
+    this.collectStorageKeysFromValue(state.mutableState, keys);
+    return [...keys];
+  }
+
+  private collectStorageKeysFromValue(value: unknown, keys: Set<string>): void {
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        this.collectStorageKeysFromValue(entry, keys);
+      }
+      return;
+    }
+    if (!value || typeof value !== "object") {
+      return;
+    }
+    const record = value as Record<string, unknown>;
+    if (
+      typeof record.id === "string" &&
+      typeof record.storageKey === "string" &&
+      typeof record.mimeType === "string" &&
+      typeof record.size === "number"
+    ) {
+      if (record.storageKey.length > 0) {
+        keys.add(record.storageKey);
+      }
+      return;
+    }
+    for (const child of Object.values(record)) {
+      this.collectStorageKeysFromValue(child, keys);
+    }
+  }
 }