@candor-ui/react 1.5.0 → 1.7.0

package/dist/adapters/ag-ui.d.ts

@@ -8,14 +8,14 @@ export type CandorAgUiEvent =
     type: "candor_user";
     id: string;
     text: string;
-    references?: EntityRef[];
+    references?: EntityRef[] | undefined;
 }
 /** A person answered an interrupt; the next run resumes with it. */
  | {
     type: "candor_answer";
     interruptId: string;
     approved: boolean;
-    reason?: string;
+    reason?: string | undefined;
 }
 /** The run failed outside the protocol's own events (the request, the stream). */
  | {
@@ -30,38 +30,38 @@ export type AgUiApproval = {
     /** The agent's machine-readable reason, e.g. "tool_approval". */
     reason: string;
     /** The agent's own sentence for the request, when it sent one. */
-    message?: string;
+    message?: string | undefined;
     /** A sentence to show: the agent's message, or a plain one naming the tool. */
     title: string;
     /** Set when the interrupt asks to run a tool call. */
-    toolCallId?: string;
+    toolCallId?: string | undefined;
     /** The tool's name, when the tool call is in the thread. */
-    tool?: string;
+    tool?: string | undefined;
     /** The tool call's arguments, when they arrived and parse. */
     input?: unknown;
     /** When the agent stops waiting (ISO 8601). */
-    expiresAt?: string;
+    expiresAt?: string | undefined;
     /** The shape the agent expects an answer in, when it says. */
-    responseSchema?: Record<string, unknown>;
+    responseSchema?: Record<string, unknown> | undefined;
 };
 /** Tokens the runs reported, summed. A count no run reported stays unknown. AG-UI reports no cost. */
 export type AgUiUsage = {
-    inputTokens?: number;
-    outputTokens?: number;
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
 };
 export type FromAgUiOptions = {
     /** Who the agent is. Candor always names the agent. */
     agent: AgentIdentity;
     /** A run is open now: the last reply is still streaming, and no interrupt can be answered yet. */
-    running?: boolean;
+    running?: boolean | undefined;
     /** A plain-words title for a tool call: "Read notes.md". `input` is undefined until the arguments arrive. */
-    toolTitle?: (tool: string, input: unknown) => string | undefined;
+    toolTitle?: ((tool: string, input: unknown) => string | undefined) | undefined;
     /** The time to judge interrupt expiry by. Defaults to now. */
-    now?: Date;
+    now?: Date | undefined;
     /** The state the first run started with; the first STATE_DELTA patches it. Defaults to `{}`, as AG-UI clients send. */
     initialState?: unknown;
     /** Other agents the app knows, by id. An activity naming an agent id not here (or `agent`) isn't mapped to an agent entry. */
-    agents?: AgentIdentity[];
+    agents?: AgentIdentity[] | undefined;
 };
 /**
  * A plan step read from an activity whose content has `steps: [{ title, status }]`.
@@ -72,9 +72,9 @@ export type AgUiPlanStep = {
     title: string;
     status: RunStatus;
     /** The step's own summary, when it sent one as text. */
-    summary?: string;
+    summary?: string | undefined;
     /** Why it failed: the agent's words, or a plain sentence saying it didn't say. Set only when status is "failed". */
-    failure?: string;
+    failure?: string | undefined;
 };
 /**
  * What an agent is doing, read from an activity whose content has `status`
@@ -83,9 +83,9 @@ export type AgUiPlanStep = {
 export type AgUiAgentActivityEntry = {
     /** The app's own identity for the agent, never one taken from the content. */
     agent: AgentIdentity;
-    doing?: string;
+    doing?: string | undefined;
     status: RunStatus;
-    since?: string;
+    since?: string | undefined;
 };
 /** An activity the agent reported: structured progress that isn't part of a reply. */
 export type AgUiActivity = {
@@ -96,25 +96,25 @@ export type AgUiActivity = {
     /** Its content as the agent sent it, after any patches. Data, never markup. */
     content: Record<string, unknown>;
     /** Set when an update to it couldn't be applied: the content is the last good one, and may be behind. */
-    outOfDate?: string;
+    outOfDate?: string | undefined;
     /** Its `steps` as plan steps, when every step has a title and a status Candor knows. */
-    plan?: AgUiPlanStep[];
+    plan?: AgUiPlanStep[] | undefined;
     /** Its `status`/`doing` as an agent entry, when the status is one Candor knows and the agent is one the app named. */
-    agentActivity?: AgUiAgentActivityEntry;
+    agentActivity?: AgUiAgentActivityEntry | undefined;
 };
 export type AgUiState = {
     messages: Message[];
     /** Interrupts waiting on a person, oldest first. Empty while a run is open; expired ones are left out. */
     approvals: AgUiApproval[];
     /** The thread the runs belong to. Send it back to continue the conversation. */
-    threadId?: string;
-    usage?: AgUiUsage;
+    threadId?: string | undefined;
+    usage?: AgUiUsage | undefined;
     /** Something the person should know that isn't part of a reply, such as an expired request. */
-    notice?: string;
+    notice?: string | undefined;
     /** The agent's shared state from STATE_SNAPSHOT and STATE_DELTA; undefined until the agent sends one. */
     state?: unknown;
     /** Set when a state update couldn't be applied: `state` is the last good value and may be behind. Cleared by the next snapshot. */
-    stateOutOfDate?: string;
+    stateOutOfDate?: string | undefined;
     /** The activities the agent reported, in the order they first arrived. */
     activities: AgUiActivity[];
 };

package/dist/adapters/ai-sdk.d.ts

@@ -6,22 +6,22 @@ export type FromAiSdkOptions = {
     /** Who the assistant is. Candor always names the agent. */
     agent: AgentIdentity;
     /** The chat's status from useChat, so the last reply can show as streaming or failed. */
-    chatStatus?: "submitted" | "streaming" | "ready" | "error";
+    chatStatus?: "submitted" | "streaming" | "ready" | "error" | undefined;
     /** When a message was sent, if your metadata says. Without it, no time is shown. */
-    createdAt?: (message: UIMessage) => string | undefined;
+    createdAt?: ((message: UIMessage) => string | undefined) | undefined;
     /** A plain-words title for a tool call: "Searched the docs for “region”". */
-    toolTitle?: (tool: string, input: unknown) => string | undefined;
+    toolTitle?: ((tool: string, input: unknown) => string | undefined) | undefined;
     /** The text version of a data part, used when its card can't be shown. */
-    summarize?: (name: string, data: unknown) => string;
+    summarize?: ((name: string, data: unknown) => string) | undefined;
     /**
      * The sources a tool's result supports, added to the reply's sources after the SDK's own source parts:
      * `(tool, input, output) => [{ kind: "document", label: "Refund policy v2" }]`. Read only from the tool's output.
      */
-    sourcesFrom?: (tool: string, input: unknown, output: unknown) => ToolSource[] | undefined;
+    sourcesFrom?: ((tool: string, input: unknown, output: unknown) => ToolSource[] | undefined) | undefined;
 };
 /** Convert a whole useChat message list. */
 export declare function fromAiSdkMessages(messages: UIMessage[], options: FromAiSdkOptions): Message[];
 /** Convert one message. `last` marks the reply the chat status applies to. */
 export declare function fromAiSdkMessage(message: UIMessage, options: FromAiSdkOptions & {
-    last?: boolean;
+    last?: boolean | undefined;
 }): Message;

package/dist/adapters/claude-agent-sdk.d.ts

@@ -13,11 +13,11 @@ export type ClaudeQuestion = {
     kind: "choice";
     prompt: string;
     /** The SDK's short header ("Library", "Approach"). */
-    tag?: string;
+    tag?: string | undefined;
     options: {
         id: string;
         label: string;
-        detail?: string;
+        detail?: string | undefined;
     }[];
     multiple: boolean;
     /** The SDK always lets the person answer in their own words. */
@@ -26,20 +26,20 @@ export type ClaudeQuestion = {
 /** A person's answer to one ClaudeQuestion: the chosen labels, their own words, or both. Same shape as ClarifyingAnswer. */
 export type ClaudeQuestionAnswer = {
     questionId: string;
-    choice?: string[];
-    text?: string;
+    choice?: string[] | undefined;
+    text?: string | undefined;
 };
 /** How a person answered a permission request. */
 export type ClaudeApprovalAnswer = {
     approved: boolean;
     /** Why it was denied, sent to the agent. */
-    reason?: string;
+    reason?: string | undefined;
     /** The tool's input as the person edited it before allowing it. The tool runs with exactly this. */
-    updatedInput?: Record<string, unknown>;
+    updatedInput?: Record<string, unknown> | undefined;
     /** Answers to the agent's questions, when the request is one (`questions`). */
-    answers?: ClaudeQuestionAnswer[];
+    answers?: ClaudeQuestionAnswer[] | undefined;
     /** Which of the request's `suggestions` the person chose to keep ("always allow"), by index. None unless they choose. */
-    alwaysAllow?: number[];
+    alwaysAllow?: number[] | undefined;
 };
 /** Events of Candor's own, mixed into the SDK's stream. */
 export type CandorAgentEvent = 
@@ -48,7 +48,7 @@ export type CandorAgentEvent =
     type: "candor_user";
     id: string;
     text: string;
-    references?: EntityRef[];
+    references?: EntityRef[] | undefined;
 }
 /** A tool call is waiting for a person to allow or deny it. */
  | {
@@ -58,50 +58,50 @@ export type CandorAgentEvent =
     tool: string;
     input: unknown;
     /** The SDK's own sentence for the request, e.g. "Claude wants to edit notes.md". */
-    title?: string;
-    description?: string;
+    title?: string | undefined;
+    description?: string | undefined;
     /** Why the SDK asked, when it says. */
-    reason?: string;
-    blockedPath?: string;
+    reason?: string | undefined;
+    blockedPath?: string | undefined;
     /** Open on "Deny" and offer no one-key approve: the request grants more than it looks. */
-    defaultToNo?: boolean;
+    defaultToNo?: boolean | undefined;
     /** A short name for the action: "Edit file". */
-    displayName?: string;
+    displayName?: string | undefined;
     /**
      * Rules the SDK suggests so this isn't asked again ("always allow"), as the SDK sends them. Offer them as a
      * choice the person makes; never keep one unless they pick it.
      */
-    suggestions?: PermissionUpdate[];
+    suggestions?: PermissionUpdate[] | undefined;
     /** Offer no "always allow" for this request: its rule would grant more than this one action. */
-    noAlwaysAllow?: boolean;
+    noAlwaysAllow?: boolean | undefined;
     /** The permission mode the run was in when it asked. */
-    mode?: ClaudePermissionMode;
+    mode?: ClaudePermissionMode | undefined;
     /** The agent's questions, when the tool is AskUserQuestion: answer them instead of allowing a tool. */
-    questions?: ClaudeQuestion[];
+    questions?: ClaudeQuestion[] | undefined;
     /** Set when a subagent asked, with its id. */
-    agentId?: string;
+    agentId?: string | undefined;
     /** For an MCP tool: its server's name and where that server was configured, as the SDK reports them. */
     mcpServer?: {
         name: string;
         source: string;
-    };
+    } | undefined;
     /** Whether the server lets a person edit this call's input before allowing it. False means no; left out means yes (1.5.0). */
-    editable?: boolean;
+    editable?: boolean | undefined;
 }
 /** The request was answered, or the run ended before anyone did. */
  | {
     type: "candor_approval_closed";
     id: string;
     approved: boolean;
-    reason?: string;
+    reason?: string | undefined;
     /** The person changed the input before allowing it. */
-    edited?: boolean;
+    edited?: boolean | undefined;
     /** The input the tool ran with, when the person edited it. */
     input?: unknown;
     /** Nobody answered in time (the server's `approvalTimeoutMs`). */
-    expired?: boolean;
+    expired?: boolean | undefined;
     /** How many "always allow" rules the person kept. */
-    kept?: number;
+    kept?: number | undefined;
 }
 /** The run's permission mode changed, by the app (`setPermissionMode`). The SDK's own mode reports also count. */
  | {
@@ -135,27 +135,27 @@ export type FromClaudeAgentOptions = {
     /** Who the agent is. Candor always names the agent. */
     agent: AgentIdentity;
     /** A request is open now: the last reply is still streaming and its approvals can be answered. */
-    running?: boolean;
+    running?: boolean | undefined;
     /** A plain-words title for a tool call: "Read notes.md". */
-    toolTitle?: (tool: string, input: unknown) => string | undefined;
+    toolTitle?: ((tool: string, input: unknown) => string | undefined) | undefined;
     /**
      * The sources a tool's result supports, for the reply's source list: `(tool, input, output) => [{ kind: "document",
      * label: "Pricing policy v3" }]`. Read only from what the tool returned, never from numbers in the agent's text.
      * Claude's own citations and web search results are read without it.
      */
-    sourcesFrom?: (tool: string, input: unknown, output: string) => ToolSource[] | undefined;
+    sourcesFrom?: ((tool: string, input: unknown, output: string) => ToolSource[] | undefined) | undefined;
 };
 export type ClaudeAgentState = {
     messages: Message[];
     /** Tool calls waiting on a person, oldest first. Empty once the request has ended. */
     approvals: ClaudeApproval[];
     /** Send it back with the next message to continue the same session (the SDK's `resume`). */
-    sessionId?: string;
-    usage?: ClaudeAgentUsage;
+    sessionId?: string | undefined;
+    usage?: ClaudeAgentUsage | undefined;
     /** A passing problem the agent is handling itself, such as a retried API call. */
-    notice?: string;
+    notice?: string | undefined;
     /** The permission mode last reported, by the SDK or the app. Absent until one is. */
-    permissionMode?: ClaudePermissionMode;
+    permissionMode?: ClaudePermissionMode | undefined;
 };
 /**
  * Turns Claude Agent SDK events into Candor messages, waiting approvals and usage.
@@ -179,7 +179,7 @@ export declare function claudePermissionResult(request: Answerable, answer: Clau
 export type ClaudeSuggestion = {
     action: "allow" | "deny" | "ask" | "remove" | "mode" | "directories" | "other";
     what: string;
-    scope?: string;
+    scope?: string | undefined;
 };
 /**
  * The SDK's suggested permission updates as plain parts PermissionPrompt shows, in the same order, so the indexes a

package/dist/adapters/claude-agent-server.d.ts

@@ -5,20 +5,20 @@ import type { EntityRef } from "../lib/chat.js";
 export type StoredApproval = {
     id: string;
     /** The run it belongs to, when the run has an id. */
-    runId?: string;
+    runId?: string | undefined;
     /** Who may answer it; checked by answerClaudeApproval. */
-    owner?: string;
+    owner?: string | undefined;
     request: ClaudeApproval;
     createdAt: string;
     /** Set once answered. Recorded, not necessarily used: a run that stopped at the same moment still denies the tool. */
     answer?: ClaudeApprovalAnswer & {
         at: string;
-    };
+    } | undefined;
     /** Set when nobody can answer any more (the run ended or stopped), with why. */
     closed?: {
         at: string;
         reason: string;
-    };
+    } | undefined;
 };
 /**
  * Where waiting permission requests live. Answering and closing each happen once: whichever comes first wins, so a
@@ -47,33 +47,33 @@ export interface ApprovalStore {
  * (10 minutes), so it doesn't grow without bound.
  */
 export declare function memoryApprovalStore({ keepMs }?: {
-    keepMs?: number;
+    keepMs?: number | undefined;
 }): ApprovalStore;
 /** A `wait` for stores that can't push: reads the request every `intervalMs` (1s) until it's answered or closed. */
 export declare function waitByPolling(get: (id: string) => Promise<StoredApproval | undefined>, id: string, signal: AbortSignal, intervalMs?: number): Promise<ClaudeApprovalAnswer | undefined>;
 export type ClaudeCanUseToolOptions = {
     /** Where requests wait. Defaults to this process's memory. */
-    approvals?: ApprovalStore;
+    approvals?: ApprovalStore | undefined;
     /** Sends each request, and its closing, to whoever shows it (the browser, your event log). */
     emit: (event: AgentEvent) => void;
     /** Who may answer. */
-    owner?: string;
+    owner?: string | undefined;
     /** The run's id, kept with each request. */
-    runId?: string;
+    runId?: string | undefined;
     /** The run's permission mode now, recorded on each request. */
-    mode?: () => ClaudePermissionMode | undefined;
+    mode?: (() => ClaudePermissionMode | undefined) | undefined;
     /** Called with each request's id as it starts waiting and once it's settled, e.g. to close the rest when the run ends. */
     track?: {
         add(id: string): void;
         delete(id: string): void;
-    };
+    } | undefined;
     /**
      * Which tools' input a person may edit before allowing it (`updatedInput`). Every tool by default, as in 1.5.0;
      * an answer that edits a tool this refuses is rejected by answerClaudeApproval, whatever the browser sends.
      */
-    editable?: (tool: string, input: unknown) => boolean;
+    editable?: ((tool: string, input: unknown) => boolean) | undefined;
     /** Close a request nobody answered after this long, as expired: the tool is denied, never allowed. No limit by default. */
-    approvalTimeoutMs?: number;
+    approvalTimeoutMs?: number | undefined;
 };
 /**
  * A canUseTool that keeps each request in an ApprovalStore and waits for its answer from wherever it's given: your
@@ -113,8 +113,8 @@ export interface ClaudeRunStore {
  * browser sees text arrive a message at a time instead of as it streams.
  */
 export declare function memoryRunStore({ maxRuns, maxEvents }?: {
-    maxRuns?: number;
-    maxEvents?: number;
+    maxRuns?: number | undefined;
+    maxEvents?: number | undefined;
 }): ClaudeRunStore;
 /** Which permission modes a run may be switched to: a list, or a test. */
 export type ModePolicy = readonly PermissionMode[] | ((mode: PermissionMode) => boolean);
@@ -133,31 +133,31 @@ export type RunClaudeAgent = (tools: {
 }) => Query;
 export type StreamClaudeAgentOptions = {
     /** The incoming request's signal (`request.signal`): the agent stops when the browser goes away, unless `detach`. */
-    signal?: AbortSignal;
+    signal?: AbortSignal | undefined;
     /** Who may answer this run's permission requests, e.g. the signed-in user's id. Checked when they're answered. */
-    owner?: string;
+    owner?: string | undefined;
     /** The sentence shown when the run fails. Defaults to a generic one, so server errors don't leak to the browser. */
-    describeError?: (error: unknown) => string;
+    describeError?: ((error: unknown) => string) | undefined;
     /**
      * Called with every SDK message just before it's sent to the browser, e.g. to record usage and cost from
      * `assistant` and `result` messages. To stop the run from here, abort the run's abortController: the message
      * in hand is still sent, and nothing after it.
      */
-    onMessage?: (message: SDKMessage) => void | Promise<void>;
+    onMessage?: ((message: SDKMessage) => void | Promise<void>) | undefined;
     /** Called with every event the browser gets, in order, e.g. to keep the whole conversation for replay. */
-    onEvent?: (event: AgentEvent) => void | Promise<void>;
+    onEvent?: ((event: AgentEvent) => void | Promise<void>) | undefined;
     /** Where permission requests wait. Defaults to this process's memory. */
-    approvals?: ApprovalStore;
+    approvals?: ApprovalStore | undefined;
     /** Keeps the run's events so a browser can re-attach (attachClaudeAgentRun). Without it, a reload loses the run. */
-    runs?: ClaudeRunStore;
+    runs?: ClaudeRunStore | undefined;
     /** The run's id; a new one by default. Sent back in the `x-candor-run-id` header. */
-    runId?: string;
+    runId?: string | undefined;
     /**
      * Keep running when the browser goes away (a reload, a closed tab), so it can re-attach. Stop it with
      * stopClaudeAgentRun. Needs a process that outlives the response: not a serverless function that's frozen when
      * the response ends.
      */
-    detach?: boolean;
+    detach?: boolean | undefined;
     /**
      * What the person sent, recorded as the run's first event in `runs`, so a re-attached browser shows it. Pass the
      * `promptId` useClaudeAgent sends as `id`: a browser that re-attaches with `initialEvents` then replaces the run's
@@ -166,14 +166,14 @@ export type StreamClaudeAgentOptions = {
     prompt?: {
         id: string;
         text: string;
-        references?: EntityRef[];
-    };
+        references?: EntityRef[] | undefined;
+    } | undefined;
     /** Which tools' input a person may edit before allowing it. Every tool by default. See claudeCanUseTool. */
-    editable?: ClaudeCanUseToolOptions["editable"];
+    editable?: ClaudeCanUseToolOptions["editable"] | undefined;
     /** Close a permission request nobody answered after this long, as expired (denied). No limit by default; set one with `detach`. */
-    approvalTimeoutMs?: number;
+    approvalTimeoutMs?: number | undefined;
     /** The permission modes setClaudeAgentPermissionMode may switch this run to. Any mode by default. */
-    modes?: ModePolicy;
+    modes?: ModePolicy | undefined;
 };
 /**
  * Run an agent and stream it to useClaudeAgent.
@@ -200,10 +200,10 @@ export declare function streamClaudeAgent(run: RunClaudeAgent, { signal, owner,
  *   }
  */
 export declare function attachClaudeAgentRun(runs: ClaudeRunStore, runId: string, { from, owner, signal, pollMs }?: {
-    from?: number;
-    owner?: string;
-    signal?: AbortSignal;
-    pollMs?: number;
+    from?: number | undefined;
+    owner?: string | undefined;
+    signal?: AbortSignal | undefined;
+    pollMs?: number | undefined;
 }): Promise<Response>;
 /** Stop a run this process is running. False when it isn't running here, or `owner` didn't start it. */
 export declare function stopClaudeAgentRun(runId: string, owner?: string): boolean;
@@ -214,7 +214,7 @@ export declare function stopClaudeAgentRun(runId: string, owner?: string): boole
  * must be left out of `allowed` (or the run's `modes`) too, since anyone can post to the route directly.
  */
 export declare function setClaudeAgentPermissionMode(runId: string, mode: PermissionMode, owner?: string, { allowed }?: {
-    allowed?: ModePolicy;
+    allowed?: ModePolicy | undefined;
 }): Promise<boolean>;
 /**
  * Check an answer from the browser against the request it answers, and record it. False when there's no such
@@ -228,7 +228,7 @@ export declare function setClaudeAgentPermissionMode(runId: string, mode: Permis
  *   }
  */
 export declare function answerClaudeApproval(approvals: ApprovalStore, id: string, answer: ClaudeApprovalAnswer, { owner }?: {
-    owner?: string;
+    owner?: string | undefined;
 }): Promise<boolean>;
 /**
  * Answer a waiting permission request in the default, in-memory store. Kept from 1.4; answerClaudeApproval takes a

package/dist/adapters/use-ag-ui.d.ts

@@ -5,16 +5,16 @@ import { type FromAgUiOptions } from "./ag-ui.js";
 export type UseAgUiOptions = Omit<FromAgUiOptions, "running" | "now"> & {
     /** Your AG-UI endpoint (LangGraph, Mastra, CrewAI, Google ADK, Pydantic AI…). It receives a RunAgentInput and streams events back. */
     url: string;
-    headers?: Record<string, string>;
+    headers?: Record<string, string> | undefined;
     /** Replaces the global fetch, e.g. to add auth or to play a script in tests and demos. */
-    fetch?: typeof fetch;
+    fetch?: typeof fetch | undefined;
     /** Continue an existing thread instead of starting a new one. */
-    threadId?: string;
+    threadId?: string | undefined;
     /** Sent with every run as `forwardedProps`, next to the `references` the person mentioned. */
-    forwardedProps?: Record<string, unknown>;
+    forwardedProps?: Record<string, unknown> | undefined;
     /** Tools and context for every run, as AG-UI defines them. Candor doesn't run frontend tools for you. */
-    tools?: RunAgentParameters["tools"];
-    context?: RunAgentParameters["context"];
+    tools?: RunAgentParameters["tools"] | undefined;
+    context?: RunAgentParameters["context"] | undefined;
 };
 /**
  * Wires an AG-UI agent to Candor: messages for <Thread>/<Message>, props for

package/dist/adapters/use-ag-ui.js

@@ -42,7 +42,13 @@ export function useAgUi(options) {
     React.useEffect(() => () => run.current?.abort(), []);
     const getClient = React.useCallback(() => {
         if (!client.current)
-            client.current = new HttpAgent({ url, headers, fetch: fetcher, threadId, initialState });
+            client.current = new HttpAgent({
+                url,
+                ...(headers && { headers }),
+                ...(fetcher && { fetch: fetcher }),
+                ...(threadId !== undefined && { threadId }),
+                ...(initialState !== undefined && { initialState }),
+            });
         const http = client.current;
         // The latest options win, without losing the thread.
         http.url = url;
@@ -66,7 +72,13 @@ export function useAgUi(options) {
                 setEvents((e) => [...e, ...batch]);
         };
         try {
-            await http.runAgent({ resume: params.resume, tools, context, forwardedProps: { ...forwardedProps, references: params.references ?? [] }, abortController: controller }, {
+            await http.runAgent({
+                ...(params.resume && { resume: params.resume }),
+                ...(tools && { tools }),
+                ...(context && { context }),
+                forwardedProps: { ...forwardedProps, references: params.references ?? [] },
+                abortController: controller,
+            }, {
                 onEvent: ({ event }) => {
                     pending.events.push(event);
                     pending.frame ||= requestAnimationFrame(flush);

package/dist/adapters/use-candor-chat.d.ts

@@ -8,7 +8,7 @@ export type PendingApproval = {
     toolCallId: string;
     tool: string;
     input: unknown;
-    reason?: string;
+    reason?: string | undefined;
 };
 /**
  * Wires a `useChat()` result to Candor: messages for <Thread>/<Message>, props

package/dist/adapters/use-candor-chat.js

@@ -30,7 +30,7 @@ export function useCandorChat(chat, options) {
         });
     }, [chat.messages]);
     const { sendMessage, stop, addToolApprovalResponse } = chat;
-    const respond = React.useCallback((approvalId, approved, reason) => addToolApprovalResponse({ id: approvalId, approved, reason }), [addToolApprovalResponse]);
+    const respond = React.useCallback((approvalId, approved, reason) => addToolApprovalResponse({ id: approvalId, approved, ...(reason !== undefined && { reason }) }), [addToolApprovalResponse]);
     return {
         messages,
         approvals,

package/dist/adapters/use-claude-agent.d.ts

@@ -8,30 +8,30 @@ export type UseClaudeAgentOptions = Omit<FromClaudeAgentOptions, "running"> & {
      * Your route that records an answer (answerClaudeApproval). It receives `{ id, approved, reason, updatedInput,
      * answers, alwaysAllow }` and returns `{ ok }`. Not needed with `onRespond`.
      */
-    approveApi?: string;
+    approveApi?: string | undefined;
     /**
      * Answer through your own route instead, e.g. one that signals the workflow running the agent. Resolve true once
      * the answer is recorded, false if it wasn't (the request had ended).
      */
-    onRespond?: (approvalId: string, answer: ClaudeApprovalAnswer) => Promise<boolean>;
+    onRespond?: ((approvalId: string, answer: ClaudeApprovalAnswer) => Promise<boolean>) | undefined;
     /** Events you kept from earlier (onEvent, a run store): the conversation is folded from them, as it was. */
-    initialEvents?: AgentEvent[];
+    initialEvents?: AgentEvent[] | undefined;
     /**
      * Where to re-attach to a run after a reload: `(runId, from) => \`/api/agent/${runId}?from=${from}\``, a route that
      * returns attachClaudeAgentRun. With `runId`, the hook re-attaches when it mounts.
      */
-    attachUrl?: (runId: string, from: number) => string;
+    attachUrl?: ((runId: string, from: number) => string) | undefined;
     /** A run to re-attach to when the hook mounts, e.g. the one you saved from `runId` before the reload. */
-    runId?: string;
+    runId?: string | undefined;
     /** Your route that calls stopClaudeAgentRun with `{ runId }`. Needed to stop a run that keeps going without the browser (`detach`). */
-    stopApi?: string;
+    stopApi?: string | undefined;
     /** Your route that calls setClaudeAgentPermissionMode with `{ runId, mode }`. Enables `setPermissionMode`. */
-    modeApi?: string;
+    modeApi?: string | undefined;
     /** Extra fields for every request, e.g. which project the agent works on. */
-    body?: Record<string, unknown>;
-    headers?: Record<string, string>;
+    body?: Record<string, unknown> | undefined;
+    headers?: Record<string, string> | undefined;
     /** Replaces the global fetch, e.g. to add auth or to play a script in tests and demos. */
-    fetch?: typeof fetch;
+    fetch?: typeof fetch | undefined;
 };
 /**
  * Wires a Claude Agent SDK server route to Candor: messages for <Thread>/<Message>,

package/dist/adapters/use-claude-agent.js

@@ -97,7 +97,7 @@ export function useClaudeAgent(options) {
         if (!attachUrl)
             return Promise.resolve();
         setRunId(id);
-        return stream((signal) => (fetcher ?? fetch)(attachUrl(id, from), { headers, signal }), undefined, from === 0);
+        return stream((signal) => (fetcher ?? fetch)(attachUrl(id, from), { ...(headers && { headers }), signal }), undefined, from === 0);
     }, [attachUrl, fetcher, headers, stream]);
     // Re-attach to the run named in options once, when the hook mounts.
     const attachOnMount = React.useRef(options.runId);

package/dist/blocks/copy-field.d.ts

@@ -14,6 +14,6 @@ declare function CopyField({ label, value, className, }: {
     label: string;
     /** The text that is shown and copied. */
     value: string;
-    className?: string;
+    className?: string | undefined;
 }): import("react").JSX.Element;
 export { CopyField };

package/dist/blocks/copy-field.js

@@ -18,6 +18,6 @@ export const copyFieldStrings = {
 function CopyField({ label, value, className, }) {
     const { state, copy } = useCopy();
     const t = useStrings("copyField", copyFieldStrings);
-    return (_jsxs("div", { "data-slot": "copy-field", className: cn("flex flex-col gap-1", className), children: [_jsx("span", { className: "text-xs font-medium text-muted-foreground", children: label }), _jsxs("button", { type: "button", onClick: () => copy(value), className: "group/copy flex w-full items-center gap-2 rounded-lg border bg-sunken px-3 py-2 text-start outline-none transition-colors duration-150 hover:border-border-strong focus-visible:ring-[3px] focus-visible:ring-ring/40", children: [_jsx("code", { className: "min-w-0 flex-1 truncate font-mono text-xs", children: value }), _jsx("span", { "aria-live": "polite", className: "inline-flex shrink-0 items-center gap-1 text-xs text-muted-foreground group-hover/copy:text-foreground", children: state === "copied" ? (_jsxs(_Fragment, { children: [_jsx(Check, { className: "size-3 text-success-text" }), " ", t("copied")] })) : state === "failed" ? (_jsxs(_Fragment, { children: [_jsx(X, { className: "size-3 text-destructive-text" }), " ", t("failed")] })) : (_jsxs(_Fragment, { children: [_jsx(Copy, { className: "size-3" }), " ", t("copy")] })) })] })] }));
+    return (_jsxs("div", { "data-slot": "copy-field", className: cn("flex flex-col gap-1", className), children: [_jsx("span", { className: "text-xs font-medium text-muted-foreground", children: label }), _jsxs("button", { type: "button", onClick: () => copy(value), className: "group/copy flex w-full items-center gap-2 rounded-lg border bg-sunken px-3 py-2 text-start outline-none transition-colors duration-150 hover:border-border-strong focus-visible:ring-[3px] focus-visible:ring-ring/80", children: [_jsx("code", { className: "min-w-0 flex-1 truncate font-mono text-xs", children: value }), _jsx("span", { "aria-live": "polite", className: "inline-flex shrink-0 items-center gap-1 text-xs text-muted-foreground group-hover/copy:text-foreground", children: state === "copied" ? (_jsxs(_Fragment, { children: [_jsx(Check, { className: "size-3 text-success-text" }), " ", t("copied")] })) : state === "failed" ? (_jsxs(_Fragment, { children: [_jsx(X, { className: "size-3 text-destructive-text" }), " ", t("failed")] })) : (_jsxs(_Fragment, { children: [_jsx(Copy, { className: "size-3" }), " ", t("copy")] })) })] })] }));
 }
 export { CopyField };