veryfront 0.1.49 → 0.1.51

package/src/src/workflow/claude-code/event-publisher.ts

@@ -4,12 +4,16 @@
  * Provides different ways to publish Claude Code events for streaming.
  */
 
+import { logger as baseLogger } from "../../utils/index.js";
 import type {
   ClaudeCodeEvent,
   ClaudeCodeEventHandler,
   ClaudeCodeEventPublisher,
   ClaudeCodeEventSubscriber,
 } from "./types.js";
+import { INVALID_ARGUMENT } from "../../errors/index.js";
+
+const logger = baseLogger.component("redis-event-publisher");
 
 // =============================================================================
 // In-Memory Publisher (for testing/single-process)
@@ -127,6 +131,20 @@ export class RedisEventPublisher implements ClaudeCodeEventPublisher, ClaudeCode
     return `${this.config.channelPrefix}:events:${runId}`;
   }
 
+  private getPublishClient(): RedisClient {
+    if (!this.publishClient) {
+      throw new Error("Redis publish client not initialized");
+    }
+    return this.publishClient;
+  }
+
+  private getSubscribeClient(): RedisClient {
+    if (!this.subscribeClient) {
+      throw new Error("Redis subscribe client not initialized");
+    }
+    return this.subscribeClient;
+  }
+
   async publish(event: ClaudeCodeEvent): Promise<void> {
     await this.ensureInitialized();
 
@@ -136,10 +154,10 @@ export class RedisEventPublisher implements ClaudeCodeEventPublisher, ClaudeCode
 
     const message = JSON.stringify(event);
 
-    await this.publishClient.publish(channel, message);
+    await this.getPublishClient().publish(channel, message);
 
     if (this.config.debug) {
-      console.log(`[RedisEventPublisher] Published to ${channel}:`, event.type);
+      logger.info("Published event", { channel, eventType: event.type });
     }
   }
 
@@ -147,24 +165,27 @@ export class RedisEventPublisher implements ClaudeCodeEventPublisher, ClaudeCode
     await this.ensureInitialized();
 
     const channel = this.getChannel(runId);
+    const subscribeClient = this.getSubscribeClient();
 
     const listener = (message: string) => {
       try {
-        const event = JSON.parse(message) as ClaudeCodeEvent;
+        const parsed: unknown = JSON.parse(message);
+        if (!parsed || typeof parsed !== "object") return;
+        const event = parsed as ClaudeCodeEvent;
         handler(event);
       } catch (error) {
-        console.error("[RedisEventPublisher] Failed to parse event:", error);
+        logger.error("Failed to parse event", error);
       }
     };
 
-    await this.subscribeClient.subscribe(channel, listener);
+    await subscribeClient.subscribe(channel, listener);
 
     if (this.config.debug) {
-      console.log(`[RedisEventPublisher] Subscribed to ${channel}`);
+      logger.info("Subscribed to channel", { channel });
     }
 
     return async () => {
-      await this.subscribeClient.unsubscribe(channel);
+      await subscribeClient.unsubscribe(channel);
     };
   }
 
@@ -176,6 +197,8 @@ export class RedisEventPublisher implements ClaudeCodeEventPublisher, ClaudeCode
       this.subscribeClient?.quit(),
     ]);
 
+    this.publishClient = null;
+    this.subscribeClient = null;
     this.initialized = false;
   }
 }
@@ -298,13 +321,13 @@ export function createEventPublisher(
 
     case "redis":
       if (!options.redisUrl) {
-        throw new Error("Redis URL required for redis publisher");
+        throw INVALID_ARGUMENT.create({ detail: "Redis URL required for redis publisher" });
       }
       return new RedisEventPublisher({ url: options.redisUrl });
 
     case "callback":
       if (!options.callback) {
-        throw new Error("Callback required for callback publisher");
+        throw INVALID_ARGUMENT.create({ detail: "Callback required for callback publisher" });
       }
       return new CallbackEventPublisher(options.callback);
 
@@ -312,6 +335,6 @@ export function createEventPublisher(
       return new SSEEventPublisher();
 
     default:
-      throw new Error(`Unknown publisher type: ${options.type}`);
+      throw INVALID_ARGUMENT.create({ detail: `Unknown publisher type: ${options.type}` });
   }
 }

package/src/src/workflow/claude-code/react/use-claude-code-stream.ts

@@ -8,6 +8,13 @@ import * as dntShim from "../../../../_dnt.shims.js";
 
 import { useCallback, useEffect, useRef, useState } from "react";
 import type { ClaudeCodeEvent, ClaudeCodeResult } from "../types.js";
+import { REQUEST_ERROR } from "../../../errors/index.js";
+
+/** Default delay before reconnecting after disconnect */
+const DEFAULT_RECONNECT_DELAY_MS = 1_000;
+
+/** Default maximum number of events to retain in history */
+const DEFAULT_MAX_EVENT_HISTORY = 100;
 
 /**
  * State for Claude Code streaming
@@ -147,9 +154,9 @@ export function useClaudeCodeStream(
     autoConnect = true,
     autoReconnect = true,
     maxReconnectAttempts = 5,
-    reconnectDelay = 1000,
+    reconnectDelay = DEFAULT_RECONNECT_DELAY_MS,
     keepEventHistory = false,
-    maxEventHistory = 100,
+    maxEventHistory = DEFAULT_MAX_EVENT_HISTORY,
     onEvent,
     onConnect,
     onDisconnect,
@@ -288,7 +295,9 @@ export function useClaudeCodeStream(
 
     eventSource.onmessage = (e) => {
       try {
-        const event = JSON.parse(e.data) as ClaudeCodeEvent;
+        const parsed: unknown = JSON.parse(e.data);
+        if (!parsed || typeof parsed !== "object") return;
+        const event = parsed as ClaudeCodeEvent;
         processEvent(event);
       } catch (error) {
         console.error("[useClaudeCodeStream] Failed to parse event:", error);
@@ -306,7 +315,7 @@ export function useClaudeCodeStream(
           connect();
         }, reconnectDelay * reconnectAttemptsRef.current);
       } else {
-        onError?.(new Error("Connection failed"));
+        onError?.(REQUEST_ERROR.create({ detail: "Connection failed" }));
       }
     };
 

package/src/src/workflow/claude-code/react/use-claude-code-websocket.ts

@@ -14,6 +14,13 @@ import type {
   ClaudeCodeResult,
   InputRequestEvent,
 } from "../types.js";
+import { NETWORK_ERROR, REQUEST_ERROR } from "../../../errors/index.js";
+
+/** Default delay before reconnecting after disconnect */
+const DEFAULT_RECONNECT_DELAY_MS = 1_000;
+
+/** Default interval for WebSocket ping messages */
+const DEFAULT_PING_INTERVAL_MS = 30_000;
 
 /**
  * Pending approval state
@@ -194,8 +201,8 @@ export function useClaudeCodeWebSocket(
     autoConnect = true,
     autoReconnect = true,
     maxReconnectAttempts = 5,
-    reconnectDelay = 1000,
-    pingInterval = 30000,
+    reconnectDelay = DEFAULT_RECONNECT_DELAY_MS,
+    pingInterval = DEFAULT_PING_INTERVAL_MS,
     onEvent,
     onConnect,
     onDisconnect,
@@ -386,7 +393,9 @@ export function useClaudeCodeWebSocket(
 
     socket.onmessage = (e) => {
       try {
-        const event = JSON.parse(e.data) as ClaudeCodeEventExtended;
+        const parsed: unknown = JSON.parse(e.data);
+        if (!parsed || typeof parsed !== "object") return;
+        const event = parsed as ClaudeCodeEventExtended;
         processEvent(event);
       } catch (error) {
         console.error("[useClaudeCodeWebSocket] Failed to parse event:", error);
@@ -413,12 +422,12 @@ export function useClaudeCodeWebSocket(
           connect();
         }, reconnectDelay * reconnectAttemptsRef.current);
       } else if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
-        onError?.(new Error("Connection failed after max retries"));
+        onError?.(REQUEST_ERROR.create({ detail: "Connection failed after max retries" }));
       }
     };
 
     socket.onerror = () => {
-      onError?.(new Error("WebSocket error"));
+      onError?.(NETWORK_ERROR.create({ detail: "WebSocket error" }));
     };
 
     socketRef.current = socket;

package/src/src/workflow/claude-code/tool.ts

@@ -18,10 +18,10 @@ const claudeCodeInputSchema = z.object({
 
   /** Tool mode */
   mode: z
-    .enum(["code", "analysis", "full", "custom"])
+    .enum(["code", "analysis", "custom"])
     .optional()
     .default("code")
-    .describe("Tool mode: code (read-write), analysis (read-only), full (all tools)"),
+    .describe("Tool mode: code (read-write), analysis (read-only), custom (user-specified)"),
 
   /** Maximum turns */
   maxTurns: z
@@ -102,7 +102,7 @@ export const claudeCodeTool: Tool<ClaudeCodeInput, ClaudeCodeResult> = {
       task: { type: "string", description: "The task for the agent" },
       mode: {
         type: "string",
-        enum: ["code", "analysis", "full", "custom"],
+        enum: ["code", "analysis", "custom"],
         default: "code",
       },
       maxTurns: { type: "number", default: 20 },

package/src/src/workflow/claude-code/types.ts

@@ -10,7 +10,6 @@
 export type ClaudeCodeMode =
   | "code" // read-write (maps to SDK acceptEdits)
   | "analysis" // read-only (maps to SDK plan)
-  | "full" // all tools (maps to SDK bypassPermissions)
   | "custom"; // user-specified (maps to SDK default)
 
 /**
@@ -273,7 +272,7 @@ export type ClientCommandType =
 /**
  * Base client command interface
  */
-export interface ClientCommandBase {
+interface ClientCommandBase {
   type: ClientCommandType;
   timestamp: number;
   runId: string;
@@ -290,7 +289,7 @@ export interface CancelCommand extends ClientCommandBase {
 /**
  * Approve a pending tool call
  */
-export interface ApproveCommand extends ClientCommandBase {
+interface ApproveCommand extends ClientCommandBase {
   type: "approve";
   toolCallId: string;
 }
@@ -298,7 +297,7 @@ export interface ApproveCommand extends ClientCommandBase {
 /**
  * Reject a pending tool call
  */
-export interface RejectCommand extends ClientCommandBase {
+interface RejectCommand extends ClientCommandBase {
   type: "reject";
   toolCallId: string;
   reason?: string;
@@ -337,7 +336,7 @@ export type ClientCommandHandler = (command: ClientCommand) => void | Promise<vo
 /**
  * Extended event type including bidirectional events
  */
-export type ClaudeCodeEventTypeExtended =
+type ClaudeCodeEventTypeExtended =
   | ClaudeCodeEventType
   | "approval_request"
   | "input_request"
@@ -347,7 +346,7 @@ export type ClaudeCodeEventTypeExtended =
 /**
  * Base interface for extended events (bidirectional communication)
  */
-export interface ClaudeCodeEventBaseExtended {
+interface ClaudeCodeEventBaseExtended {
   type: ClaudeCodeEventTypeExtended;
   timestamp: number;
   runId?: string;

package/src/src/workflow/claude-code/websocket-publisher.ts

@@ -6,6 +6,7 @@
 import * as dntShim from "../../../_dnt.shims.js";
 
 
+import { logger as baseLogger } from "../../utils/index.js";
 import type {
   BidirectionalPublisher,
   CancelledEvent,
@@ -15,6 +16,18 @@ import type {
   ClientCommandHandler,
   PongEvent,
 } from "./types.js";
+import { ORCHESTRATION_ERROR, TIMEOUT_ERROR } from "../../errors/index.js";
+
+const logger = baseLogger.component("websocket-publisher");
+
+/** Default interval for WebSocket ping/keepalive messages */
+const DEFAULT_PING_INTERVAL_MS = 30_000;
+
+/** Default timeout for tool call approval requests */
+const DEFAULT_APPROVAL_TIMEOUT_MS = 60_000;
+
+/** Default timeout for user input requests (5 minutes) */
+const DEFAULT_INPUT_TIMEOUT_MS = 300_000;
 
 /**
  * WebSocket publisher configuration
@@ -51,7 +64,7 @@ export class WebSocketPublisher implements BidirectionalPublisher {
   constructor(config: WebSocketPublisherConfig) {
     this.config = {
       debug: false,
-      pingInterval: 30000,
+      pingInterval: DEFAULT_PING_INTERVAL_MS,
       ...config,
     };
 
@@ -64,11 +77,13 @@ export class WebSocketPublisher implements BidirectionalPublisher {
 
     socket.onmessage = (event) => {
       try {
-        const command = JSON.parse(event.data) as ClientCommand;
+        const parsed: unknown = JSON.parse(event.data);
+        if (!parsed || typeof parsed !== "object") return;
+        const command = parsed as ClientCommand;
         this.handleCommand(command);
       } catch (error) {
         if (this.config.debug) {
-          console.error("[WebSocketPublisher] Failed to parse command:", error);
+          logger.error("Failed to parse command", error);
         }
       }
     };
@@ -78,9 +93,9 @@ export class WebSocketPublisher implements BidirectionalPublisher {
       this.stopPingInterval();
     };
 
-    socket.onerror = (error) => {
+    socket.onerror = (event) => {
       if (this.config.debug) {
-        console.error("[WebSocketPublisher] Socket error:", error);
+        logger.error("Socket error", { event: String(event) });
       }
       // Stop ping interval on error to prevent resource leak
       // The socket may or may not close after an error, but we should
@@ -91,7 +106,7 @@ export class WebSocketPublisher implements BidirectionalPublisher {
 
   private handleCommand(command: ClientCommand): void {
     if (this.config.debug) {
-      console.log("[WebSocketPublisher] Received command:", command.type);
+      logger.info("Received command", { commandType: command.type });
     }
 
     // Handle ping internally
@@ -106,7 +121,7 @@ export class WebSocketPublisher implements BidirectionalPublisher {
         handler(command);
       } catch (error) {
         if (this.config.debug) {
-          console.error("[WebSocketPublisher] Handler error:", error);
+          logger.error("Handler error", error);
         }
       }
     }
@@ -167,7 +182,7 @@ export class WebSocketPublisher implements BidirectionalPublisher {
     const { socket } = this.config;
     if (socket.readyState !== WebSocket.OPEN) {
       if (this.config.debug) {
-        console.warn("[WebSocketPublisher] Socket not open, dropping event");
+        logger.warn("Socket not open, dropping event");
       }
       return;
     }
@@ -175,7 +190,7 @@ export class WebSocketPublisher implements BidirectionalPublisher {
     socket.send(JSON.stringify(event));
 
     if (this.config.debug) {
-      console.log("[WebSocketPublisher] Sent event:", event.type);
+      logger.info("Sent event", { eventType: event.type });
     }
   }
 
@@ -231,7 +246,7 @@ export class WebSocketPublisher implements BidirectionalPublisher {
  * - Events are published to Redis, then broadcast to connected WebSockets
  * - Commands from WebSocket are published to Redis for the worker to receive
  */
-export interface RedisWebSocketBridgeConfig {
+interface RedisWebSocketBridgeConfig {
   /** Redis URL */
   redisUrl: string;
 
@@ -347,14 +362,14 @@ export class AgentController {
     // Reject all pending approvals
     for (const [, pending] of this.pendingApprovals) {
       if (pending.timeout) clearTimeout(pending.timeout);
-      pending.reject(new Error("Cancelled"));
+      pending.reject(ORCHESTRATION_ERROR.create({ detail: "Cancelled" }));
     }
     this.pendingApprovals.clear();
 
     // Reject all pending inputs
     for (const pending of this.inputResolvers) {
       if (pending.timeout) clearTimeout(pending.timeout);
-      pending.reject(new Error("Cancelled"));
+      pending.reject(ORCHESTRATION_ERROR.create({ detail: "Cancelled" }));
     }
     this.inputResolvers = [];
   }
@@ -397,10 +412,10 @@ export class AgentController {
     reason: string,
   ): Promise<boolean> {
     if (this.cancelled) {
-      return Promise.reject(new Error("Agent cancelled"));
+      return Promise.reject(ORCHESTRATION_ERROR.create({ detail: "Agent cancelled" }));
     }
 
-    const timeout = this.config.approvalTimeout || 60000;
+    const timeout = this.config.approvalTimeout || DEFAULT_APPROVAL_TIMEOUT_MS;
 
     // Send approval request to client
     this.publisher.send({
@@ -433,10 +448,10 @@ export class AgentController {
    */
   requestInput(prompt: string, defaultValue?: string): Promise<string> {
     if (this.cancelled) {
-      return Promise.reject(new Error("Agent cancelled"));
+      return Promise.reject(ORCHESTRATION_ERROR.create({ detail: "Agent cancelled" }));
     }
 
-    const timeout = this.config.inputTimeout || 300000; // 5 minutes
+    const timeout = this.config.inputTimeout || DEFAULT_INPUT_TIMEOUT_MS;
 
     // Send input request to client
     this.publisher.send({
@@ -456,7 +471,7 @@ export class AgentController {
         if (defaultValue !== undefined) {
           resolve(defaultValue);
         } else {
-          reject(new Error("Input timeout"));
+          reject(TIMEOUT_ERROR.create({ detail: "Input timeout" }));
         }
       }, timeout);
 

package/src/src/workflow/claude-code/workspace-sync.ts

@@ -12,9 +12,16 @@
 import * as dntShim from "../../../_dnt.shims.js";
 
 
+import { logger as baseLogger } from "../../utils/index.js";
 import { api } from "../api.js";
 import type { CapturedTenantContext } from "../types.js";
 import { join, relative, resolve } from "../../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { INITIALIZATION_ERROR, INVALID_ARGUMENT, SECURITY_VIOLATION } from "../../errors/index.js";
+
+const logger = baseLogger.component("workspace-sync");
+
+/** Maximum file size for workspace sync (10 MB) */
+const MAX_WORKSPACE_FILE_SIZE = 10 * 1024 * 1024;
 
 /**
  * Workspace configuration
@@ -144,14 +151,14 @@ export class WorkspaceSync {
   constructor(config: WorkspaceConfig) {
     // SECURITY: Validate runId to prevent path traversal
     if (!/^[a-zA-Z0-9_-]+$/.test(config.runId)) {
-      throw new Error(
-        `Invalid runId: must contain only alphanumeric, underscore, or hyphen characters`,
-      );
+      throw INVALID_ARGUMENT.create({
+        detail: `Invalid runId: must contain only alphanumeric, underscore, or hyphen characters`,
+      });
     }
 
     this.config = {
       baseDir: "/tmp/veryfront-workspaces",
-      maxFileSize: 10 * 1024 * 1024, // 10MB
+      maxFileSize: MAX_WORKSPACE_FILE_SIZE,
       debug: false,
       ...config,
     };
@@ -174,7 +181,7 @@ export class WorkspaceSync {
     let bytesDownloaded = 0;
 
     if (this.config.debug) {
-      console.log(`[WorkspaceSync] Initializing workspace: ${this.workspaceDir}`);
+      logger.info("Initializing workspace", { workspaceDir: this.workspaceDir });
     }
 
     // Create workspace directory
@@ -184,7 +191,7 @@ export class WorkspaceSync {
     const files = await api.files.listAll();
 
     if (this.config.debug) {
-      console.log(`[WorkspaceSync] Found ${files.length} files in project`);
+      logger.info("Found files in project", { count: files.length });
     }
 
     // Download each file
@@ -213,7 +220,7 @@ export class WorkspaceSync {
         if (content.length > this.config.maxFileSize) {
           skippedFiles.push(path);
           if (this.config.debug) {
-            console.log(`[WorkspaceSync] Skipping large file: ${path} (${content.length} bytes)`);
+            logger.info("Skipping large file", { path, size: content.length });
           }
           continue;
         }
@@ -232,11 +239,11 @@ export class WorkspaceSync {
         bytesDownloaded += content.length;
 
         if (this.config.debug) {
-          console.log(`[WorkspaceSync] Downloaded: ${path}`);
+          logger.info("Downloaded file", { path });
         }
       } catch (error) {
         if (this.config.debug) {
-          console.error(`[WorkspaceSync] Failed to download ${path}:`, error);
+          logger.error("Failed to download file", { path }, error);
         }
         skippedFiles.push(path);
       }
@@ -253,7 +260,8 @@ export class WorkspaceSync {
     };
 
     if (this.config.debug) {
-      console.log(`[WorkspaceSync] Initialized in ${result.duration}ms`, {
+      logger.info("Workspace initialized", {
+        duration: result.duration,
         filesDownloaded,
         bytesDownloaded,
         skipped: skippedFiles.length,
@@ -270,7 +278,9 @@ export class WorkspaceSync {
     const changes: FileChange[] = [];
 
     if (!this.initialized) {
-      throw new Error("Workspace not initialized. Call initialize() first.");
+      throw INITIALIZATION_ERROR.create({
+        detail: "Workspace not initialized. Call initialize() first.",
+      });
     }
 
     // Walk the workspace directory
@@ -287,7 +297,7 @@ export class WorkspaceSync {
       try {
         const localPath = this.resolveSafePath(path);
         await dntShim.Deno.stat(localPath);
-      } catch {
+      } catch (_) {
         // File was deleted
         changes.push({
           path,
@@ -298,7 +308,7 @@ export class WorkspaceSync {
     }
 
     if (this.config.debug) {
-      console.log(`[WorkspaceSync] Detected ${changes.length} changes`);
+      logger.info("Detected changes", { count: changes.length });
     }
 
     return changes;
@@ -389,7 +399,7 @@ export class WorkspaceSync {
         } else {
           // No upload handler - just log the change
           if (this.config.debug) {
-            console.log(`[WorkspaceSync] Would upload: ${change.path} (${change.type})`);
+            logger.info("Would upload file", { path: change.path, type: change.type });
           }
           // Mark as uploaded for tracking, even though we didn't actually upload
           uploaded.push(change);
@@ -422,7 +432,7 @@ export class WorkspaceSync {
     // Verify the resolved path is within the workspace
     const relativePath = relative(this.workspaceDir, fullPath);
     if (relativePath.startsWith("..") || !relativePath || relativePath === "..") {
-      throw new Error(`Path traversal detected: ${path}`);
+      throw SECURITY_VIOLATION.create({ detail: `Path traversal detected: ${path}` });
     }
 
     return fullPath;
@@ -465,7 +475,8 @@ export class WorkspaceSync {
       const localPath = this.resolveSafePath(path);
       await dntShim.Deno.stat(localPath);
       return true;
-    } catch {
+    } catch (_) {
+      /* expected: file may not exist */
       return false;
     }
   }
@@ -475,14 +486,14 @@ export class WorkspaceSync {
    */
   async cleanup(): Promise<void> {
     if (this.config.debug) {
-      console.log(`[WorkspaceSync] Cleaning up workspace: ${this.workspaceDir}`);
+      logger.info("Cleaning up workspace", { workspaceDir: this.workspaceDir });
     }
 
     try {
       await dntShim.Deno.remove(this.workspaceDir, { recursive: true });
     } catch (error) {
       if (this.config.debug) {
-        console.error(`[WorkspaceSync] Cleanup failed:`, error);
+        logger.error("Cleanup failed", error);
       }
     }
 

package/src/src/workflow/dsl/branch.ts

@@ -6,6 +6,7 @@ import type {
   WorkflowNode,
 } from "../types.js";
 import { validateNodeId } from "./validation.js";
+import { INVALID_ARGUMENT } from "../../errors/index.js";
 
 export interface BranchOptions extends Omit<BaseNodeConfig, "checkpoint"> {
   condition: (context: WorkflowContext) => boolean | Promise<boolean>;
@@ -30,8 +31,12 @@ function prefixNodes(id: string, branch: "then" | "else", nodes: WorkflowNode[])
 export function branch(id: string, options: BranchOptions): WorkflowNode {
   validateNodeId(id);
 
-  if (!options.condition) throw new Error(`Branch "${id}" must specify a condition`);
-  if (!options.then?.length) throw new Error(`Branch "${id}" must have at least one 'then' node`);
+  if (!options.condition) {
+    throw INVALID_ARGUMENT.create({ detail: `Branch "${id}" must specify a condition` });
+  }
+  if (!options.then?.length) {
+    throw INVALID_ARGUMENT.create({ detail: `Branch "${id}" must have at least one 'then' node` });
+  }
 
   const config: BranchNodeConfig = {
     type: "branch",

package/src/src/workflow/dsl/loop.ts

@@ -1,5 +1,12 @@
 import type { BaseNodeConfig, RetryConfig, WorkflowContext, WorkflowNode } from "../types.js";
 import { validateNodeId } from "./validation.js";
+import { INVALID_ARGUMENT } from "../../errors/index.js";
+
+/** Default maximum number of loop iterations */
+const DEFAULT_MAX_ITERATIONS = 10;
+
+/** Absolute upper bound on loop iterations to prevent runaway loops */
+const MAX_ITERATIONS_LIMIT = 100;
 
 export interface LoopContext {
   iteration: number;
@@ -48,24 +55,27 @@ export function loop(id: string, options: LoopOptions): WorkflowNode {
   validateNodeId(id);
 
   if (typeof options.while !== "function") {
-    throw new Error(`Loop "${id}" must have a 'while' condition function`);
+    throw INVALID_ARGUMENT.create({
+      detail: `Loop "${id}" must have a 'while' condition function`,
+    });
   }
 
   if (!options.steps) {
-    throw new Error(`Loop "${id}" must have 'steps' configured`);
+    throw INVALID_ARGUMENT.create({ detail: `Loop "${id}" must have 'steps' configured` });
   }
 
-  const maxIterations = options.maxIterations ?? 10;
+  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
 
   if (maxIterations < 1) {
-    throw new Error(`Loop "${id}" maxIterations must be at least 1`);
+    throw INVALID_ARGUMENT.create({ detail: `Loop "${id}" maxIterations must be at least 1` });
   }
 
-  if (maxIterations > 100) {
-    throw new Error(
-      `Loop "${id}" maxIterations cannot exceed 100 (got ${maxIterations}). ` +
+  if (maxIterations > MAX_ITERATIONS_LIMIT) {
+    throw INVALID_ARGUMENT.create({
+      detail:
+        `Loop "${id}" maxIterations cannot exceed ${MAX_ITERATIONS_LIMIT} (got ${maxIterations}). ` +
         `For higher limits, consider restructuring your workflow.`,
-    );
+    });
   }
 
   return {