stagent 0.10.0 → 0.11.1

package/src/lib/agents/runtime/launch-failure.ts

@@ -0,0 +1,101 @@
+import {
+  getRuntimeCatalogEntry,
+  type AgentRuntimeId,
+} from "@/lib/agents/runtime/catalog";
+
+export interface RuntimeLaunchProgress {
+  hasTurnStarted?: boolean;
+  hasToolUse?: boolean;
+  hasResult?: boolean;
+}
+
+export class RetryableRuntimeLaunchError extends Error {
+  runtimeId: AgentRuntimeId;
+  cause: unknown;
+
+  constructor(input: {
+    runtimeId: AgentRuntimeId;
+    message: string;
+    cause: unknown;
+  }) {
+    super(input.message);
+    this.name = "RetryableRuntimeLaunchError";
+    this.runtimeId = input.runtimeId;
+    this.cause = input.cause;
+  }
+}
+
+function isLikelyRuntimeUnavailableMessage(message: string): boolean {
+  const lower = message.toLowerCase();
+
+  return (
+    lower.includes("process exited with code") ||
+    lower.includes("command not found") ||
+    lower.includes("enoent") ||
+    lower.includes("not logged in") ||
+    lower.includes("authentication") ||
+    lower.includes("oauth") ||
+    lower.includes("token expired") ||
+    lower.includes("api key") ||
+    lower.includes("chatgpt sign-in is not configured") ||
+    lower.includes("failed to start") ||
+    lower.includes("runtime unavailable")
+  );
+}
+
+export function classifyTaskFailureReason(error: unknown): string {
+  if (!(error instanceof Error)) return "sdk_error";
+  if (error.name === "AbortError" || error.message.includes("aborted")) {
+    return "aborted";
+  }
+  const lower = error.message.toLowerCase();
+  if (
+    lower.includes("turn") &&
+    (lower.includes("limit") || lower.includes("exhausted") || lower.includes("max"))
+  ) {
+    return "turn_limit_exceeded";
+  }
+  if (lower.includes("timeout") || lower.includes("timed out")) return "timeout";
+  if (lower.includes("budget")) return "budget_exceeded";
+  if (
+    lower.includes("authentication") ||
+    lower.includes("oauth") ||
+    lower.includes("not logged in") ||
+    lower.includes("token expired")
+  ) {
+    return "auth_failed";
+  }
+  if (lower.includes("rate limit") || lower.includes("429")) {
+    return "rate_limited";
+  }
+  return "sdk_error";
+}
+
+export function toRetryableRuntimeLaunchError(input: {
+  runtimeId: AgentRuntimeId;
+  error: unknown;
+  progress: RuntimeLaunchProgress;
+}): RetryableRuntimeLaunchError | null {
+  if (!(input.error instanceof Error)) {
+    return null;
+  }
+
+  if (
+    input.progress.hasTurnStarted ||
+    input.progress.hasToolUse ||
+    input.progress.hasResult
+  ) {
+    return null;
+  }
+
+  if (!isLikelyRuntimeUnavailableMessage(input.error.message)) {
+    return null;
+  }
+
+  const label = getRuntimeCatalogEntry(input.runtimeId).label;
+  return new RetryableRuntimeLaunchError({
+    runtimeId: input.runtimeId,
+    message: `${label} failed to launch before task execution started: ${input.error.message}`,
+    cause: input.error,
+  });
+}

package/src/lib/agents/runtime/openai-codex.ts

@@ -23,6 +23,12 @@ import {
   readCodexAuthStateFromClient,
   resolveOpenAICodexAuthContext,
 } from "./openai-codex-auth";
+import {
+  classifyTaskFailureReason,
+  RetryableRuntimeLaunchError,
+  toRetryableRuntimeLaunchError,
+  type RuntimeLaunchProgress,
+} from "./launch-failure";
 import type {
   AgentRuntimeAdapter,
   RuntimeConnectionResult,
@@ -228,6 +234,14 @@ async function finalizeTaskUsage(
     startedAt: state.startedAt,
     finishedAt: new Date(),
   });
+
+  await db
+    .update(tasks)
+    .set({
+      effectiveModelId: state.modelId ?? null,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, state.taskId));
 }
 
 function buildTurnInput(prompt: string) {
@@ -373,6 +387,7 @@ async function markTaskFailed(taskId: string, title: string, message: string) {
     .set({
       status: "failed",
       result: message,
+      failureReason: classifyTaskFailureReason(new Error(message)),
       updatedAt: new Date(),
     })
     .where(eq(tasks.id, taskId));
@@ -690,6 +705,7 @@ async function executeOpenAICodexTask(
   let turnId: string | null = null;
   let agentOutput = "";
   let settled = false;
+  const launchProgress: RuntimeLaunchProgress = {};
   let resolveCompletion: (() => void) | null = null;
   let rejectCompletion: ((error: Error) => void) | null = null;
   const usageState = createTaskUsageState(task, Boolean(task.sessionId));
@@ -704,6 +720,18 @@ async function executeOpenAICodexTask(
     client = await auth.connect(cwd);
 
     client.onProcessError = (error) => {
+      const retryableLaunchError =
+        !options.resume
+          ? toRetryableRuntimeLaunchError({
+              runtimeId: "openai-codex-app-server",
+              error,
+              progress: launchProgress,
+            })
+          : null;
+      if (retryableLaunchError) {
+        rejectCompletion?.(retryableLaunchError);
+        return;
+      }
       if (settled) return;
       void settle(async () => {
         await markTaskFailed(taskId, task.title, error.message);
@@ -744,6 +772,7 @@ async function executeOpenAICodexTask(
 
             case "turn/started": {
               turnId = extractTurnId(params);
+              launchProgress.hasTurnStarted = true;
               setExecution(taskId, {
                 abortController,
                 sessionId: threadId,
@@ -782,6 +811,7 @@ async function executeOpenAICodexTask(
             }
 
             case "item/commandExecution/outputDelta": {
+              launchProgress.hasToolUse = true;
               await insertLog(taskId, "command_output_delta", {
                 threadId,
                 turnId,
@@ -803,6 +833,7 @@ async function executeOpenAICodexTask(
 
             case "turn/completed": {
               const { status, errorMessage } = extractTurnStatus(params);
+              launchProgress.hasResult = true;
 
               if (status === "completed") {
                 const finalResult =
@@ -917,6 +948,10 @@ async function executeOpenAICodexTask(
       return;
     }
 
+    if (error instanceof RetryableRuntimeLaunchError) {
+      throw error;
+    }
+
     const message = error instanceof Error ? error.message : String(error);
     await settle(async () => {
       await markTaskFailed(taskId, task.title, message);

package/src/lib/agents/runtime/openai-direct.ts

@@ -396,6 +396,14 @@ async function executeOpenAIDirectTask(taskId: string, isResume = false): Promis
       startedAt: usageState.startedAt,
       finishedAt: new Date(),
     });
+
+    await db
+      .update(tasks)
+      .set({
+        effectiveModelId: result.totalUsage.modelId ?? modelId,
+        updatedAt: new Date(),
+      })
+      .where(eq(tasks.id, taskId));
   } catch (err) {
     if (!abortController.signal.aborted) {
       const errorMsg = err instanceof Error ? err.message : String(err);

package/src/lib/agents/task-dispatch.ts

@@ -0,0 +1,220 @@
+import { db } from "@/lib/db";
+import { agentLogs, notifications, tasks } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { executeTaskWithRuntime, resumeTaskWithRuntime } from "@/lib/agents/runtime";
+import {
+  resolveResumeExecutionTarget,
+  resolveTaskExecutionTarget,
+  type ResolvedExecutionTarget,
+} from "@/lib/agents/runtime/execution-target";
+import {
+  classifyTaskFailureReason,
+  RetryableRuntimeLaunchError,
+} from "@/lib/agents/runtime/launch-failure";
+import { getRuntimeCatalogEntry } from "@/lib/agents/runtime/catalog";
+
+async function persistExecutionTarget(
+  taskId: string,
+  target: ResolvedExecutionTarget
+) {
+  await db
+    .update(tasks)
+    .set({
+      effectiveRuntimeId: target.effectiveRuntimeId,
+      effectiveModelId: target.effectiveModelId,
+      runtimeFallbackReason: target.fallbackReason,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, taskId));
+
+  if (target.fallbackApplied && target.fallbackReason) {
+    await db.insert(agentLogs).values({
+      id: crypto.randomUUID(),
+      taskId,
+      agentType: "runtime-router",
+      event: "runtime_fallback",
+      payload: JSON.stringify({
+        requestedRuntimeId: target.requestedRuntimeId,
+        effectiveRuntimeId: target.effectiveRuntimeId,
+        reason: target.fallbackReason,
+      }),
+      timestamp: new Date(),
+    });
+  }
+}
+
+async function logRuntimeLaunchFailure(
+  taskId: string,
+  error: RetryableRuntimeLaunchError
+) {
+  await db.insert(agentLogs).values({
+    id: crypto.randomUUID(),
+    taskId,
+    agentType: "runtime-router",
+    event: "runtime_launch_failed",
+    payload: JSON.stringify({
+      runtimeId: error.runtimeId,
+      error: error.message,
+    }),
+    timestamp: new Date(),
+  });
+}
+
+async function markTaskLaunchFailed(
+  taskId: string,
+  taskTitle: string,
+  error: unknown
+) {
+  const message = error instanceof Error ? error.message : String(error);
+  await db
+    .update(tasks)
+    .set({
+      status: "failed",
+      result: message,
+      failureReason: classifyTaskFailureReason(
+        error instanceof Error ? error : new Error(message)
+      ),
+      sessionId: null,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, taskId));
+
+  await db.insert(notifications).values({
+    id: crypto.randomUUID(),
+    taskId,
+    type: "task_failed",
+    title: `Task failed: ${taskTitle}`,
+    body: message.slice(0, 500),
+    createdAt: new Date(),
+  });
+}
+
+function buildLaunchFallbackTarget(input: {
+  originalTarget: ResolvedExecutionTarget;
+  retryTarget: ResolvedExecutionTarget;
+  launchError: RetryableRuntimeLaunchError;
+}): ResolvedExecutionTarget {
+  const effectiveLabel = getRuntimeCatalogEntry(
+    input.retryTarget.effectiveRuntimeId
+  ).label;
+
+  return {
+    ...input.retryTarget,
+    fallbackApplied: true,
+    fallbackReason: `${input.launchError.message}. Fell back to ${effectiveLabel}.`,
+    requestedRuntimeId:
+      input.retryTarget.requestedRuntimeId ?? input.originalTarget.requestedRuntimeId,
+    requestedModelId:
+      input.retryTarget.requestedModelId ?? input.originalTarget.requestedModelId,
+    effectiveModelId: input.retryTarget.effectiveModelId,
+    effectiveRuntimeId: input.retryTarget.effectiveRuntimeId,
+  };
+}
+
+async function retryTaskWithFallback(
+  task: typeof tasks.$inferSelect,
+  originalTarget: ResolvedExecutionTarget,
+  launchError: RetryableRuntimeLaunchError
+) {
+  await logRuntimeLaunchFailure(task.id, launchError);
+
+  let retryTarget: ResolvedExecutionTarget;
+  try {
+    retryTarget = await resolveTaskExecutionTarget({
+      title: task.title,
+      description: task.description,
+      requestedRuntimeId: originalTarget.requestedRuntimeId ?? task.assignedAgent,
+      profileId: task.agentProfile,
+      unavailableRuntimeIds: [launchError.runtimeId],
+      unavailableReasons: {
+        [launchError.runtimeId]: launchError.message,
+      },
+    });
+  } catch (error) {
+    await markTaskLaunchFailed(task.id, task.title, error);
+    throw error;
+  }
+
+  const fallbackTarget = buildLaunchFallbackTarget({
+    originalTarget,
+    retryTarget,
+    launchError,
+  });
+
+  await db
+    .update(tasks)
+    .set({
+      status: "running",
+      result: null,
+      failureReason: null,
+      sessionId: null,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, task.id));
+
+  await persistExecutionTarget(task.id, fallbackTarget);
+  try {
+    return await executeTaskWithRuntime(task.id, fallbackTarget.effectiveRuntimeId);
+  } catch (error) {
+    if (error instanceof RetryableRuntimeLaunchError) {
+      await markTaskLaunchFailed(task.id, task.title, error);
+    }
+    throw error;
+  }
+}
+
+export async function startTaskExecution(
+  taskId: string,
+  options?: { requestedRuntimeId?: string | null }
+) {
+  const [task] = await db.select().from(tasks).where(eq(tasks.id, taskId));
+  if (!task) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  const target = await resolveTaskExecutionTarget({
+    title: task.title,
+    description: task.description,
+    requestedRuntimeId: options?.requestedRuntimeId ?? task.assignedAgent,
+    profileId: task.agentProfile,
+  });
+
+  await db
+    .update(tasks)
+    .set({ status: "running", updatedAt: new Date() })
+    .where(eq(tasks.id, taskId));
+  await persistExecutionTarget(taskId, target);
+  try {
+    return await executeTaskWithRuntime(taskId, target.effectiveRuntimeId);
+  } catch (error) {
+    if (error instanceof RetryableRuntimeLaunchError) {
+      return retryTaskWithFallback(task, target, error);
+    }
+    throw error;
+  }
+}
+
+export async function resumeTaskExecution(
+  taskId: string,
+  options?: {
+    requestedRuntimeId?: string | null;
+    effectiveRuntimeId?: string | null;
+  }
+) {
+  const [task] = await db.select().from(tasks).where(eq(tasks.id, taskId));
+  if (!task) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  const target = await resolveResumeExecutionTarget({
+    requestedRuntimeId: options?.requestedRuntimeId ?? task.assignedAgent,
+    effectiveRuntimeId: options?.effectiveRuntimeId ?? task.effectiveRuntimeId,
+  });
+
+  await db
+    .update(tasks)
+    .set({ status: "running", updatedAt: new Date() })
+    .where(eq(tasks.id, taskId));
+  await persistExecutionTarget(taskId, target);
+  return resumeTaskWithRuntime(taskId, target.effectiveRuntimeId);
+}

package/src/lib/agents/tool-permissions.ts

@@ -12,6 +12,7 @@ import { notifications } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
 import type { CanUseToolPolicy } from "./profiles/types";
 import { isExaTool, isExaReadOnly } from "./browser-mcp";
+import { CLAUDE_SDK_READ_ONLY_FS_TOOLS } from "./runtime/claude-sdk";
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -120,7 +121,10 @@ export async function handleToolPermission(
 ): Promise<ToolPermissionResponse> {
   const isQuestion = toolName === "AskUserQuestion";
 
-  // Layer 1: Profile-level canUseToolPolicy — fastest check, no I/O
+  // Layer 1: Profile-level canUseToolPolicy — fastest check, no I/O.
+  // Runs BEFORE Layer 1.75's SDK filesystem auto-allow so `autoDeny: ["Read"]`
+  // still denies; `autoApprove` for Read/Grep/Glob is redundant (Layer 1.75
+  // would also allow) but harmless.
   if (!isQuestion && canUseToolPolicy) {
     if (canUseToolPolicy.autoApprove?.includes(toolName)) {
       return buildAllowedToolPermissionResponse(input);
@@ -135,6 +139,17 @@ export async function handleToolPermission(
     return buildAllowedToolPermissionResponse(input);
   }
 
+  // Layer 1.75: SDK filesystem read-only tools and Skill invocations —
+  // auto-approve without I/O. Mirrors the chat-side Phase 1a policy
+  // (src/lib/chat/engine.ts canUseTool). Read/Grep/Glob are non-destructive;
+  // Skill load is equivalent to using `claude` CLI directly — any tool the
+  // loaded skill subsequently invokes (Bash, Edit, etc.) goes through this
+  // same canUseTool check. See features/chat-claude-sdk-skills.md Error
+  // & Rescue Registry row "settingSources loads hostile skill."
+  if (!isQuestion && (CLAUDE_SDK_READ_ONLY_FS_TOOLS.has(toolName) || toolName === "Skill")) {
+    return buildAllowedToolPermissionResponse(input);
+  }
+
   // Layer 2: Saved user permissions — skip notification for pre-approved tools
   if (!isQuestion) {
     const { isToolAllowed } = await import("@/lib/settings/permissions");