veryfront 0.1.49 → 0.1.50

package/src/src/utils/redis-client.ts

@@ -1,5 +1,6 @@
 import { getEnv } from "../platform/compat/process.js";
 import { logger as baseLogger } from "./logger/logger.js";
+import { DEPENDENCY_MISSING, INITIALIZATION_ERROR } from "../errors/index.js";
 
 const logger = baseLogger.component("redis");
 
@@ -18,7 +19,7 @@ export interface RedisClient {
   isOpen?: boolean;
 }
 
-export interface RedisClientOptions {
+interface RedisClientOptions {
   url?: string;
   connectTimeout?: number;
   autoReconnect?: boolean;
@@ -36,7 +37,9 @@ export async function getRedisClient(options: RedisClientOptions = {}): Promise<
   if (sharedClient && sharedClient.isOpen !== false) return sharedClient;
 
   if (connectionFailed && Date.now() - lastConnectionAttempt < RECONNECT_DELAY_MS) {
-    throw new Error("[Redis] Connection recently failed, waiting before retry");
+    throw INITIALIZATION_ERROR.create({
+      detail: "[Redis] Connection recently failed, waiting before retry",
+    });
   }
 
   if (isConnecting && connectionPromise) return connectionPromise;
@@ -67,10 +70,12 @@ async function createClient(options: RedisClientOptions): Promise<RedisClient> {
     const redisClientModule = "npm:@redis/client@1.5.8";
     const mod = await import(redisClientModule);
     createClientFn = mod.createClient as (opts: { url?: string }) => RedisClient;
-  } catch {
-    throw new Error(
-      "[Redis] Failed to load @redis/client. Install with: deno add npm:@redis/client@1.5.8",
-    );
+  } catch (error) {
+    logger.debug("Failed to load @redis/client module", { error });
+    throw DEPENDENCY_MISSING.create({
+      detail:
+        "[Redis] Failed to load @redis/client. Install with: deno add npm:@redis/client@1.5.8",
+    });
   }
 
   const client = createClientFn({ url: options.url ?? getEnv("REDIS_URL") });
@@ -95,33 +100,6 @@ async function createClient(options: RedisClientOptions): Promise<RedisClient> {
   return client;
 }
 
-export function isRedisAvailable(): boolean {
-  return sharedClient !== null && sharedClient.isOpen !== false && !connectionFailed;
-}
-
 export function isRedisConfigured(): boolean {
   return Boolean(getEnv("REDIS_URL"));
 }
-
-export async function disconnectRedis(): Promise<void> {
-  if (sharedClient) {
-    try {
-      await sharedClient.disconnect();
-    } catch {
-      // Ignore disconnect errors
-    }
-    sharedClient = null;
-  }
-
-  connectionFailed = false;
-  isConnecting = false;
-  connectionPromise = null;
-}
-
-export function resetRedisState(): void {
-  sharedClient = null;
-  connectionFailed = false;
-  isConnecting = false;
-  connectionPromise = null;
-  lastConnectionAttempt = 0;
-}

package/src/src/utils/route-path-utils.ts

@@ -12,7 +12,7 @@ export const PAGE_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js", ".mdx", ".md"] as
 export const COMPONENT_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"] as const;
 
 /** Regex for matching and removing file extensions */
-export const EXTENSION_REGEX = /\.(tsx|jsx|ts|js|mdx|md)$/;
+const EXTENSION_REGEX = /\.(tsx|jsx|ts|js|mdx|md)$/;
 
 /** Patterns for dynamic segment detection */
 const DYNAMIC_SEGMENT_PATTERNS = {
@@ -74,7 +74,7 @@ export function extractParamName(segment: string): string {
 /**
  * Router type detection result
  */
-export interface RouterBasePath {
+interface RouterBasePath {
   type: "app" | "pages" | null;
   relativePath: string | null;
 }
@@ -100,7 +100,7 @@ export function extractRouterBasePath(pageEntityId: string): RouterBasePath {
 /**
  * Result of route parameter extraction
  */
-export interface ExtractedRouteParams {
+interface ExtractedRouteParams {
   params: Record<string, string | string[]>;
   matched: boolean;
 }

package/src/src/workflow/api.ts

@@ -18,12 +18,12 @@
  * };
  * ```
  */
-import * as dntShim from "../../_dnt.shims.js";
-
 
 import { getWorkflowTenant } from "./executor/step-executor.js";
 import { getCurrentRequestContext } from "../platform/adapters/fs/veryfront/multi-project-adapter.js";
 import { VeryfrontApiClient } from "../platform/adapters/veryfront-api-client/client.js";
+import { INITIALIZATION_ERROR, INPUT_VALIDATION_FAILED } from "../errors/index.js";
+import { getHostEnv } from "../platform/compat/process.js";
 
 /**
  * Validate that a project slug is safe and well-formed.
@@ -58,21 +58,21 @@ function getTenant() {
   const tenant = getWorkflowTenant() ?? getCurrentRequestContext();
 
   if (!tenant) {
-    throw new Error(
-      "No tenant context available. " +
+    throw INITIALIZATION_ERROR.create({
+      detail: "No tenant context available. " +
         "This API must be called within a request or workflow execution. " +
         "If you're calling this from a standalone script, you need to wrap " +
         "your code with runWithContext() first.",
-    );
+    });
   }
 
   // Validate tenant fields to prevent injection attacks
   if (!isValidProjectSlug(tenant.projectSlug)) {
-    throw new Error(
-      `Invalid project slug: "${tenant.projectSlug}". ` +
+    throw INPUT_VALIDATION_FAILED.create({
+      detail: `Invalid project slug: "${tenant.projectSlug}". ` +
         "Project slugs must be 1-128 characters, start with alphanumeric, " +
         "and contain only alphanumeric characters, hyphens, or underscores.",
-    );
+    });
   }
 
   return tenant;
@@ -86,7 +86,7 @@ function getClient(): VeryfrontApiClient {
   const tenant = getTenant();
 
   const client = new VeryfrontApiClient({
-    apiBaseUrl: dntShim.Deno.env.get("VERYFRONT_API_URL") || "https://api.veryfront.com",
+    apiBaseUrl: getHostEnv("VERYFRONT_API_URL") || "https://api.veryfront.com",
     proxyMode: true,
     projectId: tenant.projectId,
     projectSlug: tenant.projectSlug,

package/src/src/workflow/backends/memory.ts

@@ -18,19 +18,20 @@ import type {
 } from "../types.js";
 import type { BackendConfig, WorkflowBackend } from "./types.js";
 import { requeueRun } from "./shared/requeue-run.js";
+import { ORCHESTRATION_ERROR, RESOURCE_NOT_FOUND } from "../../errors/index.js";
 
 const logger = baseLogger.component("memory-backend");
 
 /**
  * Memory backend configuration
  */
-export interface MemoryBackendConfig extends BackendConfig {
+interface MemoryBackendConfig extends BackendConfig {
   /** Maximum queue size (default: 10000) */
   maxQueueSize?: number;
 }
 
 /** Default max queue size */
-const DEFAULT_MAX_QUEUE_SIZE = 10000;
+const DEFAULT_MAX_QUEUE_SIZE = 10_000;
 
 export class MemoryBackend implements WorkflowBackend {
   private runs = new Map<string, WorkflowRun>();
@@ -67,7 +68,7 @@ export class MemoryBackend implements WorkflowBackend {
 
   updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void> {
     const run = this.runs.get(runId);
-    if (!run) throw new Error(`Run not found: ${runId}`);
+    if (!run) throw RESOURCE_NOT_FOUND.create({ detail: `Run not found: ${runId}` });
 
     logger.debug(`Updating run: ${runId}`, patch);
 
@@ -211,10 +212,14 @@ export class MemoryBackend implements WorkflowBackend {
     decision: ApprovalDecision,
   ): Promise<void> {
     const approvals = this.approvals.get(runId);
-    if (!approvals) throw new Error(`No approvals found for run: ${runId}`);
+    if (!approvals) {
+      throw RESOURCE_NOT_FOUND.create({ detail: `No approvals found for run: ${runId}` });
+    }
 
     const approval = approvals.find((a) => a.id === approvalId);
-    if (!approval) throw new Error(`Approval not found: ${approvalId}`);
+    if (!approval) {
+      throw RESOURCE_NOT_FOUND.create({ detail: `Approval not found: ${approvalId}` });
+    }
 
     logger.debug("Updating approval", { approvalId, decision });
     approval.status = decision.approved ? "approved" : "rejected";
@@ -267,7 +272,9 @@ export class MemoryBackend implements WorkflowBackend {
     const maxSize = this.config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
     if (this.queue.length >= maxSize) {
       return Promise.reject(
-        new Error(`Queue full (max: ${maxSize}). Cannot enqueue job: ${job.runId}`),
+        ORCHESTRATION_ERROR.create({
+          detail: `Queue full (max: ${maxSize}). Cannot enqueue job: ${job.runId}`,
+        }),
       );
     }
 

package/src/src/workflow/backends/redis/index.ts

@@ -21,6 +21,7 @@ import type {
 import type { WorkflowBackend } from "../types.js";
 import { agentLogger } from "../../../utils/index.js";
 import { requeueRun } from "../shared/requeue-run.js";
+import { INITIALIZATION_ERROR, INVALID_ARGUMENT, RESOURCE_NOT_FOUND } from "../../../errors/index.js";
 
 import type { RedisAdapter } from "../../../platform/adapters/redis/index.js";
 import {
@@ -105,9 +106,13 @@ export class RedisBackend implements WorkflowBackend {
   }
 
   private deserializeRun(data: Record<string, string>): WorkflowRun {
-    if (!data.id) throw new Error("Invalid workflow run data: missing 'id' field");
+    if (!data.id) {
+      throw INVALID_ARGUMENT.create({ detail: "Invalid workflow run data: missing 'id' field" });
+    }
     if (!data.workflowId) {
-      throw new Error(`Invalid workflow run data for run "${data.id}": missing 'workflowId' field`);
+      throw INVALID_ARGUMENT.create({
+        detail: `Invalid workflow run data for run "${data.id}": missing 'workflowId' field`,
+      });
     }
 
     const validStatuses: WorkflowStatus[] = [
@@ -121,10 +126,11 @@ export class RedisBackend implements WorkflowBackend {
 
     const status = data.status as WorkflowStatus;
     if (data.status && !validStatuses.includes(status)) {
-      throw new Error(
-        `Invalid workflow run data for run "${data.id}": unknown status "${data.status}". ` +
+      throw INVALID_ARGUMENT.create({
+        detail:
+          `Invalid workflow run data for run "${data.id}": unknown status "${data.status}". ` +
           `Expected one of: ${validStatuses.join(", ")}`,
-      );
+      });
     }
 
     function safeJsonParse<T>(
@@ -137,10 +143,12 @@ export class RedisBackend implements WorkflowBackend {
       try {
         return JSON.parse(value) as T;
       } catch (e) {
-        throw new Error(
-          `Invalid workflow run data for run "${runId}": failed to parse '${field}' as JSON. ` +
+        throw INVALID_ARGUMENT.create({
+          detail:
+            `Invalid workflow run data for run "${runId}": failed to parse '${field}' as JSON. ` +
             `Error: ${e instanceof Error ? e.message : String(e)}`,
-        );
+          cause: e instanceof Error ? e : undefined,
+        });
       }
     }
 
@@ -210,7 +218,7 @@ export class RedisBackend implements WorkflowBackend {
       return this.client;
     }
 
-    throw new Error("No Redis client available for this runtime.");
+    throw INITIALIZATION_ERROR.create({ detail: "No Redis client available for this runtime." });
   }
 
   async initialize(): Promise<void> {
@@ -433,10 +441,14 @@ export class RedisBackend implements WorkflowBackend {
       return data.id === approvalId;
     });
 
-    if (targetIndex === -1) throw new Error(`Approval not found: ${approvalId}`);
+    if (targetIndex === -1) {
+      throw RESOURCE_NOT_FOUND.create({ detail: `Approval not found: ${approvalId}` });
+    }
 
     const rawTarget = rawList[targetIndex];
-    if (!rawTarget) throw new Error(`Approval data not found: ${approvalId}`);
+    if (!rawTarget) {
+      throw RESOURCE_NOT_FOUND.create({ detail: `Approval data not found: ${approvalId}` });
+    }
 
     const data = JSON.parse(rawTarget);
     data.status = decision.approved ? "approved" : "rejected";
@@ -620,15 +632,20 @@ export class RedisBackend implements WorkflowBackend {
       const client = await this.ensureClient();
       await client.set("__health_check__", "ok", { ex: 1 });
       return true;
-    } catch {
+    } catch (error) {
+      logger.debug("Redis health check failed", { error });
       return false;
     }
   }
 
-  destroy(): Promise<void> {
+  async destroy(): Promise<void> {
     if (this.client) {
-      if (typeof this.client.quit === "function") this.client.quit();
-      else if (typeof this.client.disconnect === "function") this.client.disconnect();
+      try {
+        if (typeof this.client.quit === "function") await this.client.quit();
+        else if (typeof this.client.disconnect === "function") await this.client.disconnect();
+      } catch {
+        // Ignore errors during cleanup — connection may already be closed
+      }
       this.client = null;
     }
 
@@ -636,6 +653,5 @@ export class RedisBackend implements WorkflowBackend {
     this.initialized = false;
 
     if (this.config.debug) logger.debug("[RedisBackend] Destroyed");
-    return Promise.resolve();
   }
 }

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

@@ -24,6 +24,18 @@ export interface AgentConfig {
   /** Tool mode — maps to SDK permission modes */
   mode?: ClaudeCodeMode;
 
+  /**
+   * Explicitly opt in to `bypassPermissions` mode (unrestricted filesystem
+   * and shell access with no interactive prompts).
+   *
+   * When `true`, the agent runs with `permissionMode: "bypassPermissions"`
+   * regardless of `mode`. This is a server-side-only flag — it cannot be
+   * set from tool input schemas.
+   *
+   * @default false
+   */
+  bypassPermissions?: boolean;
+
   /** Maximum conversation turns before stopping */
   maxTurns?: number;
 
@@ -52,18 +64,27 @@ export interface AgentConfig {
 const DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
 
 /**
- * Map tool mode to SDK permission mode
+ * Map tool mode to SDK permission mode.
+ *
+ * `bypassPermissions` is only available when explicitly opted in via
+ * `config.bypassPermissions = true` — it cannot be selected from
+ * user-facing tool input schemas.
  */
 function resolvePermissionMode(
-  mode?: ClaudeCodeMode,
+  config: AgentConfig,
 ): "default" | "acceptEdits" | "bypassPermissions" | "plan" {
-  switch (mode) {
+  if (config.bypassPermissions === true) {
+    logger.warn(
+      "Agent running with bypassPermissions — unrestricted filesystem and shell access",
+    );
+    return "bypassPermissions";
+  }
+
+  switch (config.mode) {
     case "analysis":
       return "plan"; // read-only
     case "code":
       return "acceptEdits"; // can write files + run commands
-    case "full":
-      return "bypassPermissions"; // all tools, no prompts
     case "custom":
       return "default"; // user controls via allowedTools
     default:
@@ -113,7 +134,7 @@ export async function executeAgent(
         cwd: config.cwd || cwd(),
         maxTurns: config.maxTurns,
         maxBudgetUsd: config.maxBudgetUsd,
-        permissionMode: resolvePermissionMode(config.mode),
+        permissionMode: resolvePermissionMode(config),
         allowedTools: config.allowedTools,
         additionalDirectories: config.additionalDirectories,
         systemPrompt: config.systemPrompt
@@ -219,6 +240,10 @@ export async function executeAgent(
 /**
  * Create a reusable agent function with preset configuration.
  *
+ * **Security note:** `overrides` cannot set `bypassPermissions` — it is
+ * stripped before execution. Only `defaults` can enable bypass mode, so keep
+ * `defaults` server-controlled and never derived from untrusted input.
+ *
  * @example
  * ```typescript
  * const reviewer = createAgent({
@@ -232,6 +257,8 @@ export async function executeAgent(
 export function createAgent(
   defaults: AgentConfig = {},
 ): (task: string, overrides?: AgentConfig) => Promise<ClaudeCodeResult> {
-  return (task: string, overrides: AgentConfig = {}) =>
-    executeAgent(task, { ...defaults, ...overrides });
+  return (task: string, overrides: AgentConfig = {}) => {
+    const { bypassPermissions: _, ...safeOverrides } = overrides;
+    return executeAgent(task, { ...defaults, ...safeOverrides });
+  };
 }

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 },