stagent 0.9.6 → 0.11.0

package/src/components/notifications/permission-response-actions.tsx

@@ -1,10 +1,11 @@
 "use client";
 
 import { useState } from "react";
-import { Check, ShieldCheck, X } from "lucide-react";
+import { Check, Send, ShieldCheck, X } from "lucide-react";
 import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
+import { Textarea } from "@/components/ui/textarea";
 import { cn } from "@/lib/utils";
 import {
   buildPermissionPattern,
@@ -12,6 +13,28 @@ import {
   type PermissionToolInput,
 } from "@/lib/notifications/permissions";
 
+interface AskUserQuestionOption {
+  label: string;
+  description?: string;
+}
+
+function parseQuestionOptions(toolInput: PermissionToolInput): AskUserQuestionOption[] {
+  const raw = (toolInput as { options?: unknown }).options;
+  if (!Array.isArray(raw)) return [];
+  const out: AskUserQuestionOption[] = [];
+  for (const item of raw) {
+    if (item && typeof item === "object" && typeof (item as { label?: unknown }).label === "string") {
+      const entry: AskUserQuestionOption = {
+        label: (item as { label: string }).label,
+      };
+      const desc = (item as { description?: unknown }).description;
+      if (typeof desc === "string") entry.description = desc;
+      out.push(entry);
+    }
+  }
+  return out;
+}
+
 interface PermissionResponseActionsProps {
   taskId?: string | null;
   notificationId: string;
@@ -87,6 +110,19 @@ export function PermissionResponseActions({
     }
   }
 
+  if (toolName === "AskUserQuestion" || toolName === "ask_user_question") {
+    return (
+      <QuestionReplyActions
+        taskId={taskId}
+        notificationId={notificationId}
+        toolInput={toolInput}
+        onResponded={onResponded}
+        className={className}
+        buttonSize={buttonSize}
+      />
+    );
+  }
+
   return (
     <div
       className={cn(
@@ -124,3 +160,121 @@ export function PermissionResponseActions({
     </div>
   );
 }
+
+interface QuestionReplyActionsProps {
+  taskId?: string | null;
+  notificationId: string;
+  toolInput: PermissionToolInput;
+  onResponded?: () => void;
+  className?: string;
+  buttonSize?: "sm" | "default";
+}
+
+/**
+ * Renders the response UI for an `AskUserQuestion` notification:
+ * - If `toolInput.options` is a non-empty array → card-cluster radiogroup (one click = answer).
+ * - Otherwise → free-form textarea + Send.
+ *
+ * Posts to /api/tasks/[id]/respond with `{ behavior: "allow", updatedInput: { answer } }`.
+ * The task runtime's `waitForToolPermissionResponse()` unblocks and returns `{ answer }`
+ * to the agent.
+ */
+function QuestionReplyActions({
+  taskId,
+  notificationId,
+  toolInput,
+  onResponded,
+  className,
+  buttonSize = "sm",
+}: QuestionReplyActionsProps) {
+  const [loading, setLoading] = useState(false);
+  const [draft, setDraft] = useState("");
+  const options = parseQuestionOptions(toolInput);
+
+  async function sendAnswer(answer: string) {
+    if (!answer.trim()) return;
+    setLoading(true);
+    try {
+      const res = await fetch(`/api/tasks/${taskId ?? "_checkpoint"}/respond`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          notificationId,
+          behavior: "allow",
+          updatedInput: { answer: answer.trim() },
+        }),
+      });
+
+      if (!res.ok) {
+        const data = (await res.json().catch(() => null)) as
+          | { error?: string }
+          | null;
+        throw new Error(data?.error ?? "Failed to send answer");
+      }
+
+      onResponded?.();
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : "Failed to send answer"
+      );
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  if (options.length > 0) {
+    return (
+      <div
+        role="radiogroup"
+        aria-label="Choose a response"
+        className={cn("grid gap-2 sm:grid-cols-1", className)}
+      >
+        {options.map((option) => (
+          <button
+            key={option.label}
+            type="button"
+            role="radio"
+            aria-checked={false}
+            onClick={() => sendAnswer(option.label)}
+            disabled={loading}
+            className="rounded-lg border border-border/60 bg-background/60 p-3 text-left transition-colors hover:bg-accent/40 focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:outline-none disabled:opacity-60"
+          >
+            <div className="text-sm font-medium text-foreground">{option.label}</div>
+            {option.description && (
+              <div className="mt-1 text-xs text-muted-foreground">{option.description}</div>
+            )}
+          </button>
+        ))}
+      </div>
+    );
+  }
+
+  return (
+    <div className={cn("flex flex-col gap-2", className)}>
+      <Textarea
+        value={draft}
+        onChange={(e) => setDraft(e.target.value)}
+        placeholder="Type your reply…"
+        rows={3}
+        disabled={loading}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+            e.preventDefault();
+            sendAnswer(draft);
+          }
+        }}
+      />
+      <div className="flex items-center justify-between gap-2">
+        <span className="text-xs text-muted-foreground">⌘/Ctrl + Enter to send</span>
+        <Button
+          size={buttonSize}
+          onClick={() => sendAnswer(draft)}
+          disabled={loading || !draft.trim()}
+        >
+          <Send className="h-3.5 w-3.5" />
+          Send
+        </Button>
+      </div>
+    </div>
+  );
+}

package/src/components/schedules/schedule-create-sheet.tsx

@@ -11,6 +11,7 @@ import {
 import { Calendar } from "lucide-react";
 import { toast } from "sonner";
 import { ScheduleForm, type ScheduleFormValues } from "./schedule-form";
+import type { CronCollisionWarning } from "@/lib/schedules/collision-check";
 
 interface ScheduleCreateSheetProps {
   projects: { id: string; name: string }[];
@@ -27,6 +28,7 @@ export function ScheduleCreateSheet({
 }: ScheduleCreateSheetProps) {
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [warnings, setWarnings] = useState<CronCollisionWarning[]>([]);
 
   async function handleSubmit(values: ScheduleFormValues) {
     setLoading(true);
@@ -58,10 +60,15 @@ export function ScheduleCreateSheet({
       });
 
       if (res.ok) {
+        const { warnings: newWarnings } = await res.json();
         setError(null);
-        onOpenChange(false);
+        setWarnings(newWarnings ?? []);
         toast.success("Schedule created");
         onCreated();
+        if (!newWarnings || newWarnings.length === 0) {
+          onOpenChange(false);
+        }
+        // Keep sheet open if there are warnings so the user sees the banner
       } else {
         const data = await res.json().catch(() => null);
         setError(data?.error ?? `Failed to create schedule (${res.status})`);
@@ -89,6 +96,17 @@ export function ScheduleCreateSheet({
 
         {/* Body — px-6 pb-6 per project convention (SheetContent has NO body padding) */}
         <div className="px-6 pb-6 overflow-y-auto">
+          {warnings.length > 0 && (
+            <div className="mb-4 rounded-lg border border-amber-500/40 bg-amber-50 p-3 text-sm">
+              <p className="font-medium text-amber-900">
+                Overlap detected with: {warnings[0].overlappingSchedules.join(", ")}
+              </p>
+              <p className="text-amber-800">
+                Combined load: ~{warnings[0].estimatedConcurrentSteps} agent steps.
+                Schedules will take turns; the last to run may be delayed.
+              </p>
+            </div>
+          )}
           <ScheduleForm
             projects={projects}
             onSubmit={handleSubmit}

package/src/components/schedules/schedule-edit-sheet.tsx

@@ -16,6 +16,7 @@ import {
   type ScheduleFormValues,
   type ScheduleFormInitialValues,
 } from "./schedule-form";
+import type { CronCollisionWarning } from "@/lib/schedules/collision-check";
 
 interface ScheduleEditSheetProps {
   scheduleId: string | null;
@@ -49,6 +50,7 @@ export function ScheduleEditSheet({
   const [loaded, setLoaded] = useState(false);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [warnings, setWarnings] = useState<CronCollisionWarning[]>([]);
 
   const fetchSchedule = useCallback(async () => {
     if (!scheduleId) return;
@@ -63,6 +65,7 @@ export function ScheduleEditSheet({
       setSchedule(null);
       setLoaded(false);
       setError(null);
+      setWarnings([]);
       return;
     }
     fetchSchedule();
@@ -102,9 +105,14 @@ export function ScheduleEditSheet({
       });
 
       if (res.ok) {
+        const { warnings: newWarnings } = await res.json();
+        setWarnings(newWarnings ?? []);
         toast.success("Schedule updated");
-        onOpenChange(false);
         onUpdated();
+        if (!newWarnings || newWarnings.length === 0) {
+          onOpenChange(false);
+        }
+        // Keep sheet open if there are warnings so the user sees the banner
       } else {
         const data = await res.json().catch(() => null);
         setError(data?.error ?? `Failed to update schedule (${res.status})`);
@@ -131,6 +139,17 @@ export function ScheduleEditSheet({
 
         {/* Body — px-6 pb-6 per project convention (SheetContent has NO body padding) */}
         <div className="px-6 pb-6 overflow-y-auto">
+          {warnings.length > 0 && (
+            <div className="mb-4 rounded-lg border border-amber-500/40 bg-amber-50 p-3 text-sm">
+              <p className="font-medium text-amber-900">
+                Overlap detected with: {warnings[0].overlappingSchedules.join(", ")}
+              </p>
+              <p className="text-amber-800">
+                Combined load: ~{warnings[0].estimatedConcurrentSteps} agent steps.
+                Schedules will take turns; the last to run may be delayed.
+              </p>
+            </div>
+          )}
           {!loaded ? (
             <div className="space-y-4">
               <Skeleton className="h-8 w-full" />

package/src/components/schedules/schedule-form.tsx

@@ -63,6 +63,7 @@ export interface ScheduleFormValues {
   activeTimezone: string;
   heartbeatBudgetPerDay: number | "";
   documentIds: string[];
+  maxTurns: number | null;
 }
 
 export interface ScheduleFormInitialValues {
@@ -76,6 +77,7 @@ export interface ScheduleFormInitialValues {
   recurs: boolean;
   maxFirings: number | null;
   expiresAt: string | null;
+  maxTurns?: number | null;
 }
 
 interface ScheduleFormProps {
@@ -140,6 +142,7 @@ export function ScheduleForm({
   const [expiresInHours, setExpiresInHours] = useState<number | "">(
     initialValues ? "" : ""
   );
+  const [maxTurns, setMaxTurns] = useState<number | null>(initialValues?.maxTurns ?? null);
   const [profiles, setProfiles] = useState<ProfileOption[]>([]);
 
   // NL schedule input state
@@ -279,6 +282,7 @@ export function ScheduleForm({
       activeTimezone,
       heartbeatBudgetPerDay,
       documentIds: [...selectedDocIds],
+      maxTurns,
     });
   }
 
@@ -507,6 +511,13 @@ export function ScheduleForm({
             ? "Extra instructions appended to the heartbeat evaluation"
             : "Instructions for each execution"}
         </p>
+        {scheduleType === "scheduled" && (
+          <p className="text-muted-foreground text-xs">
+            Note: writing &quot;MAX N turns&quot; in your prompt is a hint to the model,
+            not a runtime limit. Use <strong>Max agent steps</strong> below to enforce
+            a budget.
+          </p>
+        )}
       </div>
 
       {/* Natural Language Schedule Input */}
@@ -640,6 +651,26 @@ export function ScheduleForm({
         )}
       </div>
 
+      {/* Max agent steps */}
+      <div className="space-y-2">
+        <Label htmlFor="max-turns">Max agent steps per run</Label>
+        <Input
+          id="max-turns"
+          type="number"
+          min={1}
+          max={10000}
+          placeholder="Inherits global default"
+          value={maxTurns ?? ""}
+          onChange={(e) =>
+            setMaxTurns(e.target.value ? parseInt(e.target.value, 10) : null)
+          }
+        />
+        <p className="text-muted-foreground text-xs">
+          One step = one agent action (message, tool call, or sub-response). Most
+          schedules use 50–500 steps; heavy research runs 2,000+.
+        </p>
+      </div>
+
       {/* Project */}
       {projects.length > 0 && (
         <div className="space-y-2">

package/src/components/settings/__tests__/providers-runtimes-section.test.tsx

@@ -0,0 +1,149 @@
+import { render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ProvidersAndRuntimesSection } from "@/components/settings/providers-runtimes-section";
+
+describe("providers and runtimes section", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.stubGlobal("open", vi.fn());
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = String(input);
+        const method = init?.method ?? "GET";
+
+        if (url === "/api/settings/providers" && method === "GET") {
+          return {
+            ok: true,
+            json: async () => ({
+              providers: {
+                anthropic: {
+                  configured: false,
+                  authMethod: "api_key",
+                  hasKey: false,
+                  apiKeySource: "unknown",
+                  dualBilling: false,
+                  runtimes: [
+                    {
+                      runtimeId: "claude-code",
+                      label: "Claude Code",
+                      providerId: "anthropic",
+                      configured: false,
+                      authMethod: "none",
+                      apiKeySource: "unknown",
+                      billingMode: "usage",
+                    },
+                    {
+                      runtimeId: "anthropic-direct",
+                      label: "Anthropic Direct API",
+                      providerId: "anthropic",
+                      configured: false,
+                      authMethod: "none",
+                      apiKeySource: "unknown",
+                      billingMode: "usage",
+                    },
+                  ],
+                },
+                openai: {
+                  configured: true,
+                  authMethod: "oauth",
+                  hasKey: true,
+                  apiKeySource: "env",
+                  oauthConnected: false,
+                  account: null,
+                  rateLimits: null,
+                  login: {
+                    phase: "idle",
+                    loginId: null,
+                    authUrl: null,
+                    account: null,
+                    rateLimits: null,
+                    error: null,
+                    startedAt: null,
+                    updatedAt: new Date("2026-04-10T15:00:00.000Z").toISOString(),
+                  },
+                  dualBilling: false,
+                  runtimes: [
+                    {
+                      runtimeId: "openai-codex-app-server",
+                      label: "OpenAI Codex App Server",
+                      providerId: "openai",
+                      configured: false,
+                      authMethod: "oauth",
+                      apiKeySource: "oauth",
+                      billingMode: "usage",
+                    },
+                    {
+                      runtimeId: "openai-direct",
+                      label: "OpenAI Direct API",
+                      providerId: "openai",
+                      configured: true,
+                      authMethod: "api_key",
+                      apiKeySource: "env",
+                      billingMode: "usage",
+                    },
+                  ],
+                },
+              },
+              routingPreference: "quality",
+              configuredProviderCount: 1,
+            }),
+          };
+        }
+
+        if (url === "/api/settings/openai/login" && method === "POST") {
+          return {
+            ok: true,
+            json: async () => ({
+              phase: "pending",
+              loginId: "login-1",
+              authUrl: "https://auth.openai.com/log-in",
+              account: null,
+              rateLimits: null,
+              error: null,
+              startedAt: new Date("2026-04-10T15:01:00.000Z").toISOString(),
+              updatedAt: new Date("2026-04-10T15:01:00.000Z").toISOString(),
+            }),
+          };
+        }
+
+        throw new Error(`Unexpected fetch: ${url}`);
+      })
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("shows partial OpenAI setup state when ChatGPT auth is selected but not connected", async () => {
+    render(<ProvidersAndRuntimesSection />);
+
+    await waitFor(() => {
+      expect(screen.getByText("Direct API only")).toBeInTheDocument();
+    });
+
+    expect(
+      screen.getByText("Codex App Server needs ChatGPT sign-in. OpenAI Direct API remains active.")
+    ).toBeInTheDocument();
+    expect(screen.getAllByText("Sign in with ChatGPT")).toHaveLength(2);
+  });
+
+  it("updates the provider row immediately when ChatGPT sign-in starts", async () => {
+    render(<ProvidersAndRuntimesSection />);
+
+    const signInButton = await screen.findByRole("button", {
+      name: "Sign in with ChatGPT",
+    });
+    signInButton.click();
+
+    await waitFor(() => {
+      expect(
+        screen.getByText("Waiting for ChatGPT sign-in. OpenAI Direct API remains active.")
+      ).toBeInTheDocument();
+    });
+
+    expect(screen.getAllByText("Waiting for ChatGPT sign-in")).toHaveLength(2);
+  });
+});

package/src/components/settings/auth-method-selector.tsx

@@ -4,13 +4,22 @@ import { Key, Shield } from "lucide-react";
 import { cn } from "@/lib/utils";
 import type { AuthMethod } from "@/lib/constants/settings";
 
+interface AuthMethodOption {
+  id: AuthMethod;
+  icon: typeof Key;
+  title: string;
+  description: string;
+}
+
 interface AuthMethodSelectorProps {
   value: AuthMethod;
   onChange: (method: AuthMethod) => void;
   recommendedMethod?: AuthMethod | null;
+  label?: string;
+  options?: AuthMethodOption[];
 }
 
-const methods = [
+const defaultMethods = [
   {
     id: "api_key" as const,
     icon: Key,
@@ -25,12 +34,18 @@ const methods = [
   },
 ];
 
-export function AuthMethodSelector({ value, onChange, recommendedMethod }: AuthMethodSelectorProps) {
+export function AuthMethodSelector({
+  value,
+  onChange,
+  recommendedMethod,
+  label = "Authentication Method",
+  options = defaultMethods,
+}: AuthMethodSelectorProps) {
   return (
     <div className="space-y-2">
-      <p className="text-sm font-medium">Authentication Method</p>
+      <p className="text-sm font-medium">{label}</p>
       <div className="grid grid-cols-2 gap-3">
-        {methods.map((method) => {
+        {options.map((method) => {
           const Icon = method.icon;
           const isSelected = value === method.id;
           return (

package/src/components/settings/auth-status-badge.tsx

@@ -1,21 +1,30 @@
 "use client";
 
 import { Badge } from "@/components/ui/badge";
-import type { ApiKeySource } from "@/lib/constants/settings";
+import type { ApiKeySource, AuthMethod } from "@/lib/constants/settings";
 
 interface AuthStatusBadgeProps {
   connected: boolean;
   apiKeySource: ApiKeySource;
+  authMethod?: AuthMethod | "none";
+  oauthLabel?: string;
+  oauthConnected?: boolean;
 }
 
 const sourceLabels: Record<ApiKeySource, string> = {
   db: "Managed API Key",
   env: "Environment Variable",
-  oauth: "OAuth (Claude Max/Pro)",
+  oauth: "OAuth",
   unknown: "Unknown",
 };
 
-export function AuthStatusBadge({ connected, apiKeySource }: AuthStatusBadgeProps) {
+export function AuthStatusBadge({
+  connected,
+  apiKeySource,
+  authMethod,
+  oauthLabel = "OAuth",
+  oauthConnected,
+}: AuthStatusBadgeProps) {
   if (!connected && apiKeySource === "unknown") {
     return (
       <Badge variant="outline" className="border-warning/50 text-warning">
@@ -32,6 +41,22 @@ export function AuthStatusBadge({ connected, apiKeySource }: AuthStatusBadgeProp
     );
   }
 
+  if (connected && authMethod === "oauth" && oauthConnected === false) {
+    return (
+      <Badge variant="outline" className="border-status-warning/50 text-status-warning">
+        Direct API only
+      </Badge>
+    );
+  }
+
+  if (connected && authMethod === "oauth" && (oauthConnected ?? true)) {
+    return (
+      <Badge variant="outline" className="border-success/50 text-success">
+        Connected via {oauthLabel}
+      </Badge>
+    );
+  }
+
   if (apiKeySource === "unknown") {
     return (
       <Badge variant="outline" className="border-success/50 text-success">