librechat-data-provider 0.8.509 → 0.8.522

package/dist/types/stateful-code.d.ts

@@ -0,0 +1,7 @@
+export declare const STATEFUL_CODE_ENVIRONMENTS: readonly ["user", "agent-user", "conversation"];
+export type StatefulCodeEnvironment = (typeof STATEFUL_CODE_ENVIRONMENTS)[number];
+/** Resolve a deployment allowlist in stable UI order. An omitted value preserves
+ * the backward-compatible behavior where every environment is available. */
+export declare function resolveAllowedStatefulCodeEnvironments(configured?: readonly StatefulCodeEnvironment[] | null): StatefulCodeEnvironment[];
+/** Keep an allowed preference, otherwise select the first deployment-allowed scope. */
+export declare function resolveStatefulCodeEnvironment(preferred: StatefulCodeEnvironment | null | undefined, configured?: readonly StatefulCodeEnvironment[] | null): StatefulCodeEnvironment | undefined;

package/dist/types/types/agents.d.ts

@@ -1,6 +1,6 @@
-import type { FunctionToolCall, SummaryContentPart } from './assistants';
-import type { TTokenUsageEvent, TContextUsageEvent } from './runs';
+import type { TTokenUsageEvent, TContextUsageEvent, TPendingSteer } from './runs';
 import type { TAttachment, TPlugin } from 'src/schemas';
+import type { SummaryContentPart } from './assistants';
 import { StepTypes, ContentTypes, ToolCallTypes } from './runs';
 export declare namespace Agents {
     type MessageType = 'human' | 'ai' | 'generic' | 'system' | 'function' | 'tool' | 'remove';
@@ -52,20 +52,52 @@ export declare namespace Agents {
      * A call to a tool.
      */
     type ToolCall = {
-        /** Type ("tool_call") according to Assistants Tool Call Structure */
-        type: ToolCallTypes.TOOL_CALL;
+        /** Type ("tool_call") according to Assistants Tool Call Structure; optional literal
+         *  form included to mirror langchain's ToolCall, whose `type` is optional. */
+        type?: ToolCallTypes.TOOL_CALL | 'tool_call';
         /** The name of the tool to be called */
         name: string;
+        /** Host-derived MCP server identity retained to disambiguate historical tool keys. */
+        mcpServerName?: string;
         /** The arguments to the tool call */
         args?: string | Record<string, any>;
         /** If provided, an identifier associated with the tool call */
         id?: string;
+        /** Host run-step identity; unlike provider ids, this is unique across turns. */
+        stepId?: string;
         /** If provided, the output of the tool call */
         output?: string;
+        /** Host-owned durable receipt for a detached ordinary tool result.
+         * It lives beside the original call so reload, manual collection, and
+         * automatic continuation all arbitrate the same result identity. */
+        backgroundTask?: {
+            version: 1;
+            taskId: string;
+            toolName: string;
+            status: 'completed' | 'error';
+            settledAt: Date;
+            resultClaim?: {
+                kind: 'manual' | 'wakeup';
+                claimId: string;
+                claimedAt: Date;
+            };
+        };
+        /** The tool call was rejected before execution because its input failed schema validation. */
+        inputValidationError?: true;
         /** Auth URL */
         auth?: string;
         /** Expiration time */
         expires_at?: number;
+        /**
+         * When set, this tool call is paused for human review.
+         * The presence of this field signals the UI to render approval controls
+         * instead of the in-flight tool execution state.
+         */
+        approval?: {
+            actionId: string;
+            allowed_decisions: ToolApprovalDecisionType[];
+            description?: string;
+        };
     };
     type ToolEndEvent = {
         /** The Step Id of the Tool Call */
@@ -165,7 +197,35 @@ export declare namespace Agents {
         groupId?: number;
         stepDetails: StepDetails;
         summary?: SummaryContentPart;
-        usage: null | object;
+        /** Optional to mirror the agents SDK, which omits usage until a step reports it. */
+        usage?: null | object;
+        /** Epoch ms the step was opened. Emitted by `@librechat/agents` >= 3.4.6. */
+        created_at?: number;
+        status?: RunStepStatus;
+    };
+    /** Lifecycle status of a run step. `in_progress` until a terminal close. */
+    type RunStepStatus = 'in_progress' | 'completed' | 'cancelled' | 'failed';
+    /** Terminal status a run step can close with. */
+    type RunStepClosedStatus = Exclude<RunStepStatus, 'in_progress'>;
+    /**
+     * Payload of {@link StepEvents.ON_RUN_STEP_CLOSED}. Emitted once per step
+     * when it reaches a terminal state, including steps swept at end-of-run
+     * because the caller aborted — which is the only signal that distinguishes
+     * a stopped step from one still in flight.
+     */
+    type RunStepClosedEvent = {
+        id: string;
+        index: number;
+        type: StepTypes;
+        status: RunStepClosedStatus;
+        /** Epoch ms the step was opened, when the emitter knows it. */
+        created_at?: number;
+        /** Epoch ms the step reached its terminal state. */
+        closed_at: number;
+        runId?: string;
+        agentId?: string;
+        groupId?: number;
+        stepIndex?: number;
     };
     /** Content part for aggregated message content */
     interface ContentPart {
@@ -179,6 +239,21 @@ export declare namespace Agents {
         parentMessageId?: string;
         conversationId?: string;
         text?: string;
+        /** Skill selections on the turn, carried so a HITL-resumed turn's reconstructed
+         *  requestMessage keeps its skill pills (they aren't on the DB row the client refetches
+         *  until reload). */
+        manualSkills?: string[];
+        alwaysAppliedSkills?: string[];
+    }
+    /** Client-safe state for one MCP authorization prompt that remains actionable. */
+    interface PendingMCPOAuthPrompt {
+        stepId: string;
+        runId?: string;
+        index: number;
+        toolCallId?: string;
+        toolName: string;
+        authURL: string;
+        expiresAt?: number;
     }
     /** State data sent to reconnecting clients */
     interface ResumeState {
@@ -187,6 +262,8 @@ export declare namespace Agents {
         aggregatedContent?: MessageContentComplex[];
         userMessage?: UserMessageMeta;
         responseMessageId?: string;
+        /** True when the live generation replaces an existing assistant branch. */
+        isRegenerate?: boolean;
         conversationId?: string;
         sender?: string;
         iconURL?: string;
@@ -203,10 +280,24 @@ export declare namespace Agents {
             data?: unknown;
             [key: string]: unknown;
         }>;
+        /** Pending MCP authorization prompts projected from durable stream state. */
+        pendingOAuthPrompts?: PendingMCPOAuthPrompt[];
         /** Cumulative provider-reported usage for the run; backfills usage totals on resume */
         collectedUsage?: TTokenUsageEvent[];
         /** Latest context window snapshot; restores the usage gauge on resume */
         contextUsage?: TContextUsageEvent;
+        /**
+         * Live pending approval when the run is paused for human review. Carried in
+         * the resume contract (not just /chat/status) so a reloading or
+         * cross-replica client can rebuild and render the prompt from `resumeState`.
+         */
+        pendingAction?: PendingAction;
+        /**
+         * Steers queued server-side but not yet injected into the run. Injected
+         * steers already live inside `aggregatedContent`; these are the remainder,
+         * so a reconnecting client can rebuild its pending-steer chips.
+         */
+        pendingSteers?: TPendingSteer[];
     }
     /**
      * Represents a run step delta i.e. any changed fields on a run step during
@@ -227,19 +318,214 @@ export declare namespace Agents {
         type: StepTypes.MESSAGE_CREATION;
         message_creation: {
             message_id: string;
+            /** Provider content kind and Open Responses semantic text channel. */
+            content_type?: 'text' | 'think';
+            phase?: 'commentary' | 'final_answer';
         };
     };
     type ToolCallsDetails = {
         type: StepTypes.TOOL_CALLS;
-        tool_calls: AgentToolCall[];
+        tool_calls?: AgentToolCall[];
     };
     type ToolCallDelta = {
         type: StepTypes.TOOL_CALLS | string;
         tool_calls?: ToolCallChunk[];
         auth?: string;
         expires_at?: number;
+        /** Approval metadata, set when a tool call is paused for human review. */
+        approval?: {
+            actionId: string;
+            allowed_decisions: ToolApprovalDecisionType[];
+            description?: string;
+        };
+    };
+    /**
+     * Mirrors the agents SDK's function tool-call variant: `arguments` may arrive as a
+     * parsed object, and `output` is attached by LibreChat aggregation only once available
+     * (the legacy assistants `FunctionToolCall` requires both as string/present).
+     */
+    type AgentFunctionToolCall = {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string | object;
+            output?: string | null;
+        };
     };
-    type AgentToolCall = FunctionToolCall | ToolCall;
+    type AgentToolCall = AgentFunctionToolCall | ToolCall;
+    /**
+     * Human-in-the-loop interrupt categories. The discriminator on
+     * {@link HumanInterruptPayload}.
+     *
+     * - `tool_approval`: agent paused before executing one or more tools; user
+     *   approves / rejects / edits each call.
+     * - `ask_user_question`: agent invoked the `AskUserQuestion` tool to gather
+     *   clarification; user replies with free-form text (or selects an option).
+     *
+     * `tool_approval` is a permission gate; `ask_user_question` is a clarification
+     * channel — they share the {@link PendingAction} envelope but have different
+     * UI affordances and resume payloads.
+     */
+    type HumanInterruptType = 'tool_approval' | 'ask_user_question';
+    /** String enum of decision kinds the user can make on a paused tool call. */
+    type ToolApprovalDecisionType = 'approve' | 'reject' | 'edit' | 'respond';
+    /**
+     * One pending tool execution awaiting user review.
+     * Field naming mirrors LangChain HumanInterrupt's `ActionRequest`.
+     */
+    interface ToolApprovalRequest {
+        /** Tool name as registered with the agent */
+        name: string;
+        /** Sanitized arguments (no auth tokens / file blobs). May be string or parsed object. */
+        arguments: string | Record<string, unknown>;
+        /** Provider tool_call_id linking this request to the model's tool_use block */
+        tool_call_id: string;
+        /** Optional human-readable description shown alongside the prompt */
+        description?: string;
+    }
+    /**
+     * Per-call review configuration: which decisions the user is allowed to make.
+     *
+     * `tool_call_id` (NOT `action_name`) is the join key against
+     * {@link ToolApprovalRequest.tool_call_id}. By-position mapping breaks the
+     * moment a single batch contains the same tool called twice — e.g. a model
+     * fanning out two `mcp:server:search` calls in parallel — so always join
+     * by `tool_call_id`. `action_name` is retained for display only.
+     */
+    interface ToolReviewConfig {
+        action_name: string;
+        tool_call_id: string;
+        allowed_decisions: ToolApprovalDecisionType[];
+    }
+    /** Interrupt payload for a tool-approval pause. */
+    interface ToolApprovalInterruptPayload {
+        type: 'tool_approval';
+        action_requests: ToolApprovalRequest[];
+        review_configs: ToolReviewConfig[];
+    }
+    /** A selectable answer for an ask-user-question prompt. */
+    interface AskUserQuestionOption {
+        label: string;
+        value: string;
+    }
+    /** The question itself: free-form prompt with optional curated answers. */
+    interface AskUserQuestionRequest {
+        question: string;
+        /** Optional descriptive context for the prompt; mirrors the SDK field. */
+        description?: string;
+        options?: AskUserQuestionOption[];
+        /** When true the user may pick several options; the answer is their
+         *  selected option values joined with ", ". */
+        multiSelect?: boolean;
+    }
+    /** One independently answerable question in a batched clarification. */
+    interface AskUserQuestionBatchItem extends AskUserQuestionRequest {
+        /** Batch-unique identifier used to map the submitted answer. */
+        id: string;
+        /** Optional short heading rendered above the question. */
+        header?: string;
+    }
+    /** Input shape for one tool call that asks several related questions. */
+    interface AskUserQuestionsRequest {
+        questions: AskUserQuestionBatchItem[];
+    }
+    /** Interrupt payload for an ask-user-question pause. */
+    interface AskUserQuestionInterruptPayload {
+        type: 'ask_user_question';
+        question: AskUserQuestionRequest;
+        /** Present for a batched clarification; `question` remains the first-item fallback. */
+        questions?: AskUserQuestionBatchItem[];
+        /**
+         * The ask tool call that raised this interrupt (mirrors the SDK field,
+         * present from `@librechat/agents` > 3.3.8). Lets the question/answer
+         * stamps target the exact tool-call part instead of guessing by
+         * position when a model emits several ask calls in one turn.
+         */
+        tool_call_id?: string;
+    }
+    /**
+     * Discriminated by `type`. Mirrors `@librechat/agents`'s `HumanInterruptPayload`
+     * so the SDK's `Run.getInterrupt()` output can be embedded directly.
+     */
+    type HumanInterruptPayload = ToolApprovalInterruptPayload | AskUserQuestionInterruptPayload;
+    /**
+     * Server-side record of a job that is waiting for user input.
+     * Persisted with the job; consumed by approval routes and the status endpoint.
+     */
+    interface PendingAction {
+        /** Stable identifier used in approval URLs */
+        actionId: string;
+        streamId: string;
+        conversationId?: string;
+        /** Stable per-turn identifier (LangGraph checkpoint_ns) when available */
+        runId?: string;
+        responseMessageId?: string;
+        payload: HumanInterruptPayload;
+        createdAt: number;
+        /** Optional expiry; clients should treat past `expiresAt` as stale */
+        expiresAt?: number;
+        /**
+         * SDK interrupt id (`RunInterruptResult.interruptId`). Persisted so a
+         * cross-process resume can correlate the decision with the LangGraph
+         * interrupt after the original `Run` object is gone.
+         */
+        interruptId?: string;
+        /**
+         * LangGraph `thread_id` the run was bound to (`RunInterruptResult.threadId`).
+         * Required, with the checkpointer, to rebuild `Command({ resume })` on a
+         * worker that didn't originate the run.
+         */
+        threadId?: string;
+        /**
+         * Fingerprint of the request fields that determine the agent/graph + tool set
+         * (endpoint, agent_id, model, spec, ephemeralAgent), captured at pause time. The
+         * resume route recomputes it from the resume request and rejects a mismatch — the
+         * guard that catches an ephemeral-agent config swap, where `agent_id` is undefined
+         * so the id check can't.
+         */
+        requestFingerprint?: string;
+        /**
+         * Graph-determining request fields (endpoint, agent_id, model, spec, promptPrefix,
+         * ephemeralAgent) captured at pause. The resume route REPLAYS these onto the request
+         * before rebuilding the run, so a reload/cross-replica resume — where the client can
+         * no longer reconstruct the ephemeral config — still rebuilds the same agent/graph.
+         */
+        resumeContext?: Record<string, unknown>;
+    }
+    /**
+     * Scope of a tool-approval decision — drives the "remember this" persistence
+     * envelope. Storage of session/always decisions is a Slice B+ concern; the
+     * field is on the wire today so route signatures don't break later.
+     */
+    type DecisionScope = 'once' | 'session' | 'always';
+    /**
+     * Per-tool decision returned from the approval UI.
+     * Wire format. The host adapts each entry to the SDK's discriminated
+     * `ToolApprovalDecision` (e.g. `{ type: 'edit', updatedInput }`) at the resume route.
+     *
+     * Constraints:
+     * - `editedArguments` is required when `decision === 'edit'`.
+     * - `responseText` is required when `decision === 'respond'`.
+     * - `reason` is optional metadata; useful for reject/edit audit trails.
+     * - `scope` defaults to `'once'`.
+     */
+    interface ToolApprovalResolution {
+        tool_call_id: string;
+        decision: ToolApprovalDecisionType;
+        editedArguments?: Record<string, unknown>;
+        responseText?: string;
+        reason?: string;
+        scope?: DecisionScope;
+    }
+    /** Wire format for an ask-user-question response. */
+    interface AskUserQuestionResolution {
+        answer: string;
+    }
+    /** Wire format for a batched ask-user-question response. */
+    interface AskUserQuestionsResolution {
+        answers: Record<string, string>;
+    }
     interface ExtendedMessageContent {
         type?: string;
         text?: string;
@@ -436,8 +722,17 @@ export type GraphEdge = {
      *
      * For handoff edges: Description for the input parameter that the handoff tool accepts,
      * allowing the supervisor to pass specific instructions/context to the transferred agent.
+     *
+     * The callback receives a minimal structural view of the run's messages (data-provider
+     * cannot depend on langchain's BaseMessage): every langchain message satisfies
+     * `{ content: unknown }`, and callbacks typed against richer structural message shapes
+     * remain assignable. The promise branch mirrors the agents SDK signature exactly —
+     * widening it (e.g. to `Promise<string | undefined>`) would break assignability of
+     * stored edges into the SDK's `GraphEdge`.
      */
-    prompt?: string | ((messages: BaseMessage[], runStartIndex: number) => string | undefined);
+    prompt?: string | ((messages: {
+        content: unknown;
+    }[], runStartIndex: number) => string | Promise<string> | undefined);
     /**
      * When true, excludes messages from startIndex when adding prompt.
      * Automatically set to true when {results} variable is used in prompt.

package/dist/types/types/assistants.d.ts

@@ -1,9 +1,12 @@
 import type { OpenAPIV3 } from 'openapi-types';
-import type { AssistantsEndpoint, AgentProvider } from 'src/schemas';
+import type { AssistantsEndpoint, AgentProvider, MemoryScope, SkillsScope } from 'src/schemas';
+import type { StatefulCodeEnvironment } from '../stateful-code';
 import type { Agents, GraphEdge } from './agents';
 import type { ContentTypes } from './runs';
 import type { TFile } from './files';
 import { ArtifactModes } from 'src/artifacts';
+export { STATEFUL_CODE_ENVIRONMENTS, resolveStatefulCodeEnvironment, resolveAllowedStatefulCodeEnvironments, } from '../stateful-code';
+export type { StatefulCodeEnvironment } from '../stateful-code';
 export type Schema = OpenAPIV3.SchemaObject & {
     description?: string;
 };
@@ -188,6 +191,9 @@ export type SupportContact = {
     name?: string;
     email?: string;
 };
+export type AgentOwnerContact = {
+    name?: string;
+};
 /**
  * Specifies who can invoke a tool.
  * - 'direct': LLM can call directly
@@ -211,6 +217,21 @@ export type ToolOptions = {
      * @default ['direct']
      */
     allowed_callers?: AllowedCaller[];
+    /**
+     * If true (and the `run_in_background` capability is enabled), the tool's
+     * schema gains a `run_in_background` boolean so the model can dispatch the
+     * call detached and poll its result via `check_background_task`.
+     * @default false
+     */
+    run_in_background?: boolean;
+    /**
+     * If true (and the `tool_intents` capability is enabled), the tool's schema
+     * gains an `intent` string as its FIRST property — one model-authored
+     * sentence per call, rendered as the call's live status label. Native host
+     * tools default on while the capability is enabled; `false` opts one out.
+     * @default false
+     */
+    describe_intent?: boolean;
 };
 /**
  * Map of tool_id to its configuration options.
@@ -220,14 +241,36 @@ export type AgentToolOptions = Record<string, ToolOptions>;
 /**
  * Configuration for spawning subagents (isolated-context child agents) from an agent.
  * When `enabled` is true, the agent gets a subagent-spawn tool that can delegate work
- * to either itself (when `allowSelf` is true) and/or the listed `agent_ids`.
+ * to itself, listed single-agent targets, and/or explicit saved-agent teams.
  */
+export type AgentSubagentGraphEdge = Omit<GraphEdge, 'edgeType' | 'condition' | 'prompt' | 'promptKey'> & {
+    edgeType: 'direct';
+    condition?: never;
+    prompt?: string;
+    promptKey?: never;
+};
+/** A bounded saved-agent team that can be spawned as one isolated child graph. */
+export type AgentSubagentGraph = {
+    /** Stable spawn-tool enum value for the team. */
+    type: string;
+    name: string;
+    description: string;
+    /** Member IDs. In create/update payloads, an empty ID refers to the current agent. */
+    agent_ids: string[];
+    edges: AgentSubagentGraphEdge[];
+    /** Entry member ID. In create/update payloads, an empty ID refers to the current agent. */
+    entry_agent_id: string;
+    /** Result member ID. In create/update payloads, an empty ID refers to the current agent. */
+    result_agent_id: string;
+};
 export type AgentSubagentsConfig = {
     enabled?: boolean;
     /** When true (default), the agent may spawn itself in an isolated context. */
     allowSelf?: boolean;
     /** Specific agents that may be spawned as subagents. */
     agent_ids?: string[];
+    /** Explicit saved-agent teams that may be spawned as bounded child graphs. */
+    graphs?: AgentSubagentGraph[];
 };
 export type Agent = {
     _id?: string;
@@ -255,21 +298,49 @@ export type Agent = {
     edges?: GraphEdge[];
     end_after_tools?: boolean;
     hide_sequential_outputs?: boolean;
+    /** Per-agent opt-in for stateful code sessions (requires the app-level capability). */
+    stateful_code_sessions?: boolean;
+    /** Stateful workspace sharing scope. Defaults to one workspace per user. */
+    stateful_code_environment?: StatefulCodeEnvironment;
+    /** Operator-configured managed or attached stateful execution environment. */
+    code_environment_id?: string | null;
     artifacts?: ArtifactModes;
     recursion_limit?: number;
     isPublic?: boolean;
+    /**
+     * Whether the requesting user holds EDIT on this agent, so a single VIEW-scoped fetch can
+     * serve consumers that only need the editable subset instead of issuing a second full
+     * paginated walk under an EDIT-scoped cache key.
+     *
+     * Set by the list endpoint only; single-agent responses omit it. Treat absence as unknown
+     * and fail open (`isEditable !== false`), never as `false`, since a client on an older
+     * server would otherwise see an empty list rather than too many rows.
+     *
+     * Reflects the caller's ACL grant. The `MANAGE_AGENTS` capability bypasses ACL on write,
+     * so a capability holder can edit agents this flag reports as not editable.
+     */
+    isEditable?: boolean;
     version?: number;
     category?: string;
     support_contact?: SupportContact;
+    owner_contact?: AgentOwnerContact;
     /** Per-tool configuration options (deferred loading, allowed callers, etc.) */
     tool_options?: AgentToolOptions;
+    /** Attached action registrations, each `${encodedDomain}${actionDelimiter}${action_id}` */
+    actions?: string[];
     /** Optional allowlist of skill ObjectIds. Only applies when `skills_enabled`. */
     skills?: string[];
     /** Master toggle for skill use on this agent. `true` = active (full catalog unless
      *  `skills` narrows it). `false`/undefined = inactive (no skills available). */
     skills_enabled?: boolean;
+    /** Enables runtime skill creation without exposing an existing skill catalog. */
+    skill_authoring_enabled?: boolean;
+    /** Explicit catalog exposure while skills are enabled. Missing preserves legacy semantics. */
+    skills_scope?: SkillsScope;
     /** Subagent spawning configuration — isolated-context child agents. */
     subagents?: AgentSubagentsConfig;
+    /** Memory partition: `agent` isolates memories per (user, agent); default shared pool */
+    memory_scope?: MemoryScope;
 };
 export type TAgentsMap = Record<string, Agent | undefined>;
 export type AgentCreateParams = {
@@ -282,7 +353,7 @@ export type AgentCreateParams = {
     provider: AgentProvider;
     model: string | null;
     model_parameters: AgentModelParameters;
-} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'stateful_code_environment' | 'code_environment_id' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'skill_authoring_enabled' | 'skills_scope' | 'subagents' | 'memory_scope'>;
 export type AgentUpdateParams = {
     name?: string | null;
     description?: string | null;
@@ -294,7 +365,7 @@ export type AgentUpdateParams = {
     provider?: AgentProvider;
     model?: string | null;
     model_parameters?: AgentModelParameters;
-} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'stateful_code_environment' | 'code_environment_id' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'skill_authoring_enabled' | 'skills_scope' | 'subagents' | 'memory_scope'>;
 export type AgentListParams = {
     limit?: number;
     requiredPermission: number;
@@ -454,9 +525,46 @@ export type PartMetadata = {
     agentId?: string;
     /** Group ID for parallel content - parts with same groupId are displayed in columns */
     groupId?: number;
+    /**
+     * Terminal lifecycle status of the run step that produced this part, from
+     * `on_run_step_closed`. Distinct from `status`, which is already claimed by
+     * activity-label and question-form parts. Absent on parts predating the
+     * event or from endpoints that do not emit it, in which case renderers fall
+     * back to inferring "stopped" from `progress` and `isSubmitting`.
+     */
+    runStepStatus?: Agents.RunStepClosedStatus;
+    /**
+     * Wall-clock milliseconds the run step took, derived from the same
+     * `on_run_step_closed` event as {@link runStepStatus} via
+     * `getRunStepDurationMs`. Only written when the event carried both
+     * timestamps and they agree in order — so its absence means "not
+     * derivable", never "instant". The raw value is persisted unfiltered;
+     * whether it is worth showing (`isReportableRunStepDuration`) is decided
+     * at render time.
+     */
+    runStepDurationMs?: number;
+    /**
+     * Stamped by the background harvester when a detached task's final output
+     * replaces the dispatch handle in `tool_call.output`. The handle JSON and
+     * the live status-marker attachment are both transient, so after the patch
+     * (or a reload) this is the only signal that the call ran in the
+     * background — renderers use it to keep treating {@link runStepDurationMs}
+     * as dispatch time rather than the task's runtime.
+     */
+    backgrounded?: boolean;
+    /**
+     * Content index this part occupied while its run streamed. The aggregator
+     * writes parts at provider-source indexes, so the streamed array is sparse;
+     * persistence compacts it and every part after a hole shifts down. The
+     * client's final handler stamps the streamed position onto the compacted
+     * parts it adopts, so index-derived render identity survives the swap
+     * instead of remounting the settled message. Client-only and absent
+     * everywhere else — persisted content never carries it.
+     */
+    streamedIndex?: number;
 };
 /** Metadata for parallel content rendering - subset of PartMetadata */
-export type ContentMetadata = Pick<PartMetadata, 'agentId' | 'groupId'>;
+export type ContentMetadata = Pick<PartMetadata, 'agentId' | 'groupId' | 'streamedIndex'>;
 export type ContentPart = (CodeToolCall | RetrievalToolCall | FileSearchToolCall | FunctionToolCall | Agents.AgentToolCall | ImageFile | Text) & PartMetadata;
 export type TextData = (Text & PartMetadata) | undefined;
 export type SummaryContentPart = {
@@ -476,6 +584,27 @@ export type SummaryContentPart = {
         contentIndex: number;
     };
 };
+/**
+ * A user steering message injected mid-run at a tool-batch boundary.
+ * Persisted inline in the response message's content array (keyed by the
+ * type name like `text`/`think` so token counting reads it for free);
+ * replayed as a user message on subsequent turns by `formatAgentMessages`.
+ */
+export type SteerContentPart = {
+    type: ContentTypes.STEER;
+    steer: string;
+    steerId?: string;
+    /** Stable optimistic-client id used to settle a POST whose response was lost. */
+    clientSteerId?: string;
+    createdAt?: number;
+    /** Attachments steered with the message; re-encoded per turn on replay
+     *  like any other user-message media (refs only, never encoded data). */
+    files?: Partial<TFile>[];
+    /** Quoted excerpts steered with the message, persisted separately from the
+     *  typed text (mirroring `TMessage.quotes`) so the UI renders them as
+     *  reference blocks; merged into the model-bound user turn on every replay. */
+    quotes?: string[];
+};
 export type TMessageContentParts = ({
     type: ContentTypes.ERROR;
     text?: string | TextData;
@@ -483,17 +612,51 @@ export type TMessageContentParts = ({
 } & ContentMetadata) | ({
     type: ContentTypes.THINK;
     think?: string | TextData;
-} & ContentMetadata) | ({
+    /** Generated orientation for this user-visible reasoning step. */
+    reasoning_label?: string;
+    /** Stable SDK run-step identity used to correlate live revisions. */
+    reasoning_label_step_id?: string;
+    /** Durable provider-call count used to enforce the per-run cost cap across resumes. */
+    reasoning_label_attempts?: number;
+    /** Visible reasoning length included in this step's latest provider call. */
+    reasoning_label_submitted_chars?: number;
+    /** Monotonic provider-call revision; gaps are allowed after unsuccessful attempts. */
+    reasoning_label_revision?: number;
+    /** Whether the reasoning step can still produce a newer label. */
+    reasoning_label_status?: 'streaming' | 'complete';
+    /** The reasoning happened but its text is not available to this view
+     *  (e.g. detached subagent projections retain only a marker). */
+    reasoning_unavailable?: boolean;
+} & ContentMetadata) | (SteerContentPart & ContentMetadata) | ({
     type: ContentTypes.TEXT;
     text?: string | TextData;
     tool_call_ids?: string[];
+    /** Open Responses semantic channel for assistant text. */
+    phase?: 'commentary' | 'final_answer';
 } & ContentMetadata) | ({
     type: ContentTypes.TOOL_CALL;
     tool_call: (CodeToolCall | RetrievalToolCall | FileSearchToolCall | FunctionToolCall | Agents.AgentToolCall) & PartMetadata;
 } & ContentMetadata) | ({
     type: ContentTypes.IMAGE_FILE;
     image_file: ImageFile & PartMetadata;
-} & ContentMetadata) | (SummaryContentPart & ContentMetadata) | (Agents.AgentUpdate & ContentMetadata) | (Agents.MessageContentImageUrl & ContentMetadata) | (Agents.MessageContentVideoUrl & ContentMetadata) | (Agents.MessageContentInputAudio & ContentMetadata);
+} & ContentMetadata) | (SummaryContentPart & ContentMetadata) | ({
+    /** One-line LLM-generated note describing a completed tool batch. UI-only:
+     *  never sent to the model (stripped before payload formatting). */
+    type: ContentTypes.ACTIVITY_LABEL;
+    activity_label?: string;
+    /** Missing means the legacy/per-batch activity label. */
+    activity_label_type?: 'phase';
+    tool_call_ids?: string[];
+    /** Parent phase bounds and telemetry. */
+    activity_start_index?: number;
+    /** Exclusive end of the grouped content; may precede the marker itself. */
+    activity_end_index?: number;
+    activity_count?: number;
+    agent_ids?: string[];
+    /** ok = all tools succeeded, failed = all failed, partial = mixed. */
+    status?: 'ok' | 'partial' | 'failed';
+    pending?: boolean;
+} & ContentMetadata) | (Agents.AgentUpdate & ContentMetadata) | (Agents.MessageContentImageUrl & ContentMetadata) | (Agents.MessageContentVideoUrl & ContentMetadata) | (Agents.MessageContentInputAudio & ContentMetadata);
 export type StreamContentData = TMessageContentParts & {
     /** The index of the current content part */
     index: number;