librechat-data-provider 0.8.521 → 0.8.522

package/dist/types/types/runs.d.ts

@@ -33,11 +33,14 @@ export declare enum StepEvents {
     ON_REASONING_DELTA = "on_reasoning_delta",
     ON_RUN_STEP_DELTA = "on_run_step_delta",
     ON_RUN_STEP_COMPLETED = "on_run_step_completed",
+    /** Terminal signal for a run step: closed with a status and timestamps. */
+    ON_RUN_STEP_CLOSED = "on_run_step_closed",
     ON_SUMMARIZE_START = "on_summarize_start",
     ON_SUMMARIZE_DELTA = "on_summarize_delta",
     ON_SUMMARIZE_COMPLETE = "on_summarize_complete",
     ON_SUBAGENT_UPDATE = "on_subagent_update",
-    ON_SANDBOX_STARTING = "on_sandbox_starting"
+    ON_SANDBOX_STARTING = "on_sandbox_starting",
+    ON_PTC_TOOL_CALL = "on_ptc_tool_call"
 }
 /** Payload for {@link StepEvents.ON_SANDBOX_STARTING} — the stateful code
  * sandbox is cold-booting for the given code tool call. */
@@ -45,6 +48,30 @@ export type SandboxStartingEvent = {
     tool_call_id: string;
     runId?: string;
 };
+/** Lifecycle of one tool call made from inside a programmatic (PTC) program. */
+export type PtcToolCallStatus = 'running' | 'success' | 'error';
+/**
+ * Payload for {@link StepEvents.ON_PTC_TOOL_CALL} — one tool invocation the
+ * sandbox made on behalf of a programmatic tool-calling program. Emitted twice
+ * per inner call (`running`, then `success` / `error`) so the PTC card can
+ * render a live trace of what the code is doing under the code itself.
+ */
+export type PtcToolCallEvent = {
+    /** The PTC run step's tool call id — the card this line belongs under. */
+    tool_call_id: string;
+    /** Stable per-program id; the settle event reuses the start event's value. */
+    call_id: string;
+    /** Inner tool id, e.g. `search_code_mcp_github`. */
+    name: string;
+    status: PtcToolCallStatus;
+    /** `key=value` preview of the call's input. Start event only. */
+    args?: string;
+    /** Truncated failure message. `error` status only. */
+    error?: string;
+    /** Wall-clock time the inner call took. Settle events only. */
+    durationMs?: number;
+    runId?: string;
+};
 /** Token-tracking event names streamed to the client (separate from StepEvents dispatch). */
 export declare enum UsageEvents {
     ON_CONTEXT_USAGE = "on_context_usage",
@@ -79,6 +106,41 @@ export declare enum SteerEvents {
 export declare enum ActivityLabelEvents {
     ON_ACTIVITY_LABEL = "on_activity_label"
 }
+/** Live title updates for an existing reasoning content part. */
+export declare enum ReasoningLabelEvents {
+    ON_REASONING_LABEL = "on_reasoning_label",
+    /** Internal durable budget reservation; clients intentionally do not render it. */
+    ON_REASONING_LABEL_ATTEMPT = "on_reasoning_label_attempt"
+}
+type TReasoningLabelEventBase = {
+    /** Completion-local content index of the reasoning part being updated. */
+    index: number;
+    stepId: string;
+    responseMessageId?: string;
+    conversationId?: string;
+};
+/** Payload of the `on_reasoning_label` SSE event. */
+export type TReasoningLabelEvent = TReasoningLabelEventBase & ({
+    /** Clears a snapshot title when its THINK slot changed during the resume gap. */
+    reset: true;
+    /** Step identity observed in the snapshot and exclusively eligible for this reset. */
+    previousStepId: string;
+    /** Latest run-global call-budget high-water, when present on fresh content. */
+    attempts?: number;
+} | {
+    reset?: false;
+    /** Run-unique provider-call revision; may contain gaps after unsuccessful attempts. */
+    revision: number;
+    label: string;
+    status: 'streaming' | 'complete';
+});
+/** Durable run-cumulative call-budget reservation, attributed to one reasoning step. */
+export type TReasoningLabelAttemptEvent = {
+    index: number;
+    stepId: string;
+    attempts: number;
+    submittedChars: number;
+};
 /** Payload of the `on_activity_label` SSE event. */
 export type TActivityLabelEvent = {
     /** Absolute content index the label part occupies. */
@@ -116,6 +178,9 @@ export type TPendingSteer = {
     text: string;
     createdAt?: number;
     files?: Partial<TFile>[];
+    /** Quoted excerpts steered with the message ("Add to chat" selections);
+     *  merged into the model-bound text at the injection boundary. */
+    quotes?: string[];
     /** The steer asked to interrupt generation at the next safe boundary —
      *  kept on parked/replayed chips so the "interrupting" label survives. */
     preempt?: boolean;
@@ -136,6 +201,9 @@ export type TSteerAppliedEvent = {
         clientSteerId?: string;
         createdAt?: number;
         files?: Partial<TFile>[];
+        /** Quoted excerpts steered with the message (mirrors `SteerContentPart`,
+         *  which cannot be imported here without a module cycle). */
+        quotes?: string[];
     };
     responseMessageId?: string;
     conversationId?: string;
@@ -217,8 +285,9 @@ export type TTokenUsageEvent = {
     /** Non-primary buckets fold into session cost/totals but not the live
      *  context gauge: hidden sequential-agent calls (`sequential`), summary
      *  passes (`summarization`), isolated subagent runs (`subagent`), and
-     *  fast-model activity headers (`activity-label`, `activity-phase`) */
-    usage_type?: 'summarization' | 'subagent' | 'sequential' | 'activity-label' | 'activity-phase';
+     *  fast-model activity headers (`activity-label`, `activity-phase`), and
+     *  live reasoning titles (`reasoning-label`) */
+    usage_type?: 'summarization' | 'subagent' | 'sequential' | 'activity-label' | 'activity-phase' | 'reasoning-label';
     runId?: string;
     /** Per-run emission sequence; keeps identical payloads from distinct model calls unique */
     seq?: number;
@@ -250,20 +319,42 @@ export declare const promptTokensFromUsage: (event: TTokenUsageEvent) => number;
  */
 export declare const reconcileContextUsage: (snapshot: TContextUsageEvent, promptTokens: number) => TContextUsageEvent;
 /** Lifecycle phase carried on subagent-progress envelopes (mirrors SDK SubagentUpdatePhase). */
-export type SubagentUpdatePhase = 'start' | 'run_step' | 'run_step_delta' | 'run_step_completed' | 'message_delta' | 'reasoning_delta' | 'stop' | 'error';
+export type SubagentUpdatePhase = 'start' | 'run_step' | 'run_step_delta' | 'run_step_completed' | 'run_step_closed' | 'message_delta' | 'reasoning_delta' | 'stop' | 'error';
+/** Structured root-to-leaf identity for one nested subagent execution. */
+export interface SubagentAncestryEntry {
+    readonly subagentRunId: string;
+    readonly subagentType: string;
+    readonly subagentKind: 'agent' | 'graph';
+    /** Execution subject ID; synthetic for graph subagents. */
+    readonly subagentAgentId: string;
+    readonly parentRunId: string;
+    readonly parentAgentId?: string;
+    readonly parentToolCallId?: string;
+}
 /** Single streamed subagent update forwarded by the SDK's SubagentExecutor. */
 export interface SubagentUpdateEvent {
     runId: string;
+    parentRunId?: string;
     subagentRunId: string;
+    /** Host-assigned identity preserved when one detached update overlaps delivery streams. */
+    activityEventId?: string;
+    /** Host-assigned monotonic sequence within one detached child run. */
+    activitySequence?: number;
     /** Parent-side `tool_call_id` for the `subagent` tool invocation that
      *  triggered this run. Surfaces from the SDK (`3.1.67-dev.2`+) so hosts
      *  can correlate child progress to the parent tool call deterministically. */
     parentToolCallId?: string;
     subagentType: string;
+    subagentKind?: 'agent' | 'graph';
+    /** Execution subject ID; synthetic for graph subagents. */
     subagentAgentId: string;
+    memberAgentId?: string;
+    depth?: number;
+    ancestry?: readonly SubagentAncestryEntry[];
     parentAgentId?: string;
     phase: SubagentUpdatePhase;
     data?: unknown;
     label?: string;
     timestamp: string;
 }
+export {};

package/dist/types/types/schedules.d.ts

@@ -0,0 +1,306 @@
+import { z } from 'zod';
+/** Cadences the dialog builds from structured pickers (hour, minute, weekday). */
+export declare const scheduleStructuredFrequencies: readonly ["hourly", "daily", "weekdays", "weekly"];
+export type ScheduleStructuredFrequency = (typeof scheduleStructuredFrequencies)[number];
+export declare const scheduleFrequencies: readonly ["hourly", "daily", "weekdays", "weekly", "cron"];
+export type ScheduleFrequency = (typeof scheduleFrequencies)[number];
+/** Bounds a stored expression. Generous for five fields, because each one can hold a
+ *  list: an every-minute-of-the-hour cadence spelled out runs past two hundred chars. */
+export declare const SCHEDULE_CRON_MAX_LENGTH = 256;
+export declare const scheduleTargets: readonly ["new"];
+export type ScheduleTarget = (typeof scheduleTargets)[number];
+export type ScheduleDisabledReason = 'too_many_failures' | 'agent_deleted' | 'invalid_schedule' | 'permission_revoked' | 'insufficient_balance' | 'project_deleted' | 'project_required';
+export type ScheduleRunStatus = 'started' | 'requires_action' | 'success' | 'error' | 'interrupted' | 'skipped_overlap' | 'skipped_balance';
+export declare const structuredCadenceSchema: z.ZodObject<{
+    frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+    hour: z.ZodNumber;
+    minute: z.ZodNumber;
+    daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+}, "strip", z.ZodTypeAny, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}>;
+export type TStructuredCadence = z.infer<typeof structuredCadenceSchema>;
+/**
+ * A raw cron expression carries its own hour and minute, so it cannot share the
+ * structured shape: there is no single `hour` for `0 9,17 * * 1-5`. Syntax is
+ * validated server-side by croner, the same parser the engine fires from, rather
+ * than by a regex that would accept patterns croner then rejects at fire time.
+ */
+export declare const cronCadenceSchema: z.ZodObject<{
+    frequency: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    frequency: "cron";
+    expression: string;
+}, {
+    frequency: "cron";
+    expression: string;
+}>;
+export type TCronCadence = z.infer<typeof cronCadenceSchema>;
+export declare const scheduleCadenceSchema: z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
+    frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+    hour: z.ZodNumber;
+    minute: z.ZodNumber;
+    daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+}, "strip", z.ZodTypeAny, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}>, z.ZodObject<{
+    frequency: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    frequency: "cron";
+    expression: string;
+}, {
+    frequency: "cron";
+    expression: string;
+}>]>;
+export type TScheduleCadence = z.infer<typeof scheduleCadenceSchema>;
+export declare const isCronCadence: (cadence: TScheduleCadence) => cadence is TCronCadence;
+export declare const createSchedulePayloadSchema: z.ZodObject<{
+    name: z.ZodString;
+    prompt: z.ZodString;
+    agent_id: z.ZodString;
+    cadence: z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
+        frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+        hour: z.ZodNumber;
+        minute: z.ZodNumber;
+        daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }>, z.ZodObject<{
+        frequency: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "cron";
+        expression: string;
+    }, {
+        frequency: "cron";
+        expression: string;
+    }>]>;
+    timezone: z.ZodString;
+    target: z.ZodDefault<z.ZodEnum<["new"]>>;
+    file_ids: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    /**
+     * Chat project each run's conversation is filed under. `null` clears the scope.
+     * Ownership is checked server-side at write time and again at every fire, so a
+     * deleted project disables the schedule instead of silently filing runs loose.
+     */
+    chatProjectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Client-generated key making creation idempotent across retries. Creation commits
+     * the row and arms it in two writes, so a failure between them leaves the client
+     * unable to tell whether anything persisted; retrying blind can produce two recurring
+     * schedules. A retry carrying the same key resolves to the original row instead.
+     * REQUIRED: an optional key preserves the keyless duplicate path for any client
+     * that omits it, which is exactly the failure the key exists to close.
+     */
+    clientRequestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    agent_id: string;
+    clientRequestId: string;
+    prompt: string;
+    enabled: boolean;
+    timezone: string;
+    cadence: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    };
+    target: "new";
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+}, {
+    name: string;
+    agent_id: string;
+    clientRequestId: string;
+    prompt: string;
+    timezone: string;
+    cadence: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    };
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    enabled?: boolean | undefined;
+    target?: "new" | undefined;
+}>;
+export type TCreateSchedule = z.infer<typeof createSchedulePayloadSchema>;
+/** Idempotency is a property of the CREATE attempt, not of the schedule's config. */
+export declare const updateSchedulePayloadSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    chatProjectId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    file_ids: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    timezone: z.ZodOptional<z.ZodString>;
+    cadence: z.ZodOptional<z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
+        frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+        hour: z.ZodNumber;
+        minute: z.ZodNumber;
+        daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }>, z.ZodObject<{
+        frequency: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "cron";
+        expression: string;
+    }, {
+        frequency: "cron";
+        expression: string;
+    }>]>>;
+    target: z.ZodOptional<z.ZodDefault<z.ZodEnum<["new"]>>>;
+} & {
+    /**
+     * The configRevision the client's edit was computed from (captured when the
+     * dialog opened). The server fences the update on it, so a concurrent edit
+     * from another tab answers 409 instead of being silently overwritten by a
+     * payload rebuilt from a stale snapshot (cadence is sent whole, so the
+     * server-side fresh-read fence alone cannot detect this).
+     */
+    expectedConfigRevision: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    agent_id?: string | undefined;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
+    timezone?: string | undefined;
+    cadence?: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    } | undefined;
+    target?: "new" | undefined;
+    expectedConfigRevision?: number | undefined;
+}, {
+    name?: string | undefined;
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    agent_id?: string | undefined;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
+    timezone?: string | undefined;
+    cadence?: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    } | undefined;
+    target?: "new" | undefined;
+    expectedConfigRevision?: number | undefined;
+}>;
+export type TUpdateSchedule = z.infer<typeof updateSchedulePayloadSchema>;
+export type TScheduleLastRun = {
+    conversationId?: string;
+    status: ScheduleRunStatus;
+    error?: string;
+    firedAt: string;
+};
+export type TSchedule = {
+    id: string;
+    user: string;
+    name: string;
+    prompt: string;
+    agent_id: string;
+    cadence: TScheduleCadence;
+    timezone: string;
+    target: ScheduleTarget;
+    file_ids?: string[];
+    chatProjectId?: string | null;
+    enabled: boolean;
+    disabledReason?: ScheduleDisabledReason;
+    nextRunAt?: string;
+    lastRun?: TScheduleLastRun;
+    runCount: number;
+    failureCount: number;
+    configRevision?: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type TScheduleRun = {
+    scheduleId: string;
+    scheduledFor: string;
+    firedAt?: string;
+    conversationId?: string;
+    status: ScheduleRunStatus;
+    error?: string;
+    droppedFileIds?: string[];
+    durationMs?: number;
+};
+/** Server-resolved policy the dialog must mirror. Sourced from the same
+ *  per-principal `interface.schedules` resolution the write handlers and the fire
+ *  path enforce, so the form can never offer a choice the server would refuse. */
+export type TScheduleLimits = {
+    maxPerUser: number;
+    /** Served with the list so the dialog can refuse a cadence the floor would reject
+     *  rather than surfacing it as a 400 after submit. */
+    minIntervalMinutes: number;
+    /** Every schedule must be filed under a chat project. */
+    requireProject: boolean;
+    /** Operator-pinned destination project; when set it is the ONLY destination and
+     *  the client must not offer a picker. */
+    projectId?: string;
+};
+export type TSchedulesResponse = {
+    schedules: TSchedule[];
+    limits: TScheduleLimits;
+};
+export type TScheduleRunNowResponse = {
+    scheduleId: string;
+    conversationId: string;
+    status: 'started';
+};

package/dist/types/types/skills.d.ts

@@ -216,6 +216,13 @@ export type TGitHubSkillSyncSkippedSkill = {
     errorCode: string;
     errorMessage: string;
 };
+/** One upstream file a sync run published a skill without, and why. */
+export type TGitHubSkillSyncSkippedFile = {
+    path: string;
+    skillPath: string;
+    errorCode: string;
+    errorMessage: string;
+};
 export type TGitHubSkillSyncSourceStatus = {
     provider: 'github';
     sourceId: string;
@@ -240,6 +247,8 @@ export type TGitHubSkillSyncSourceStatus = {
     deletedFileCount: number;
     skippedSkillCount: number;
     skippedSkills?: TGitHubSkillSyncSkippedSkill[];
+    skippedFileCount: number;
+    skippedFiles?: TGitHubSkillSyncSkippedFile[];
     updatedAt?: string;
     createdAt?: string;
 };

package/dist/types/types/subagents.d.ts

@@ -0,0 +1,159 @@
+export type SubagentThreadStatus = 'dispatched' | 'running' | 'completed' | 'failed' | 'interrupted' | 'cancelled';
+export type ParentSubagentTaskSummary = {
+    taskId: string;
+    status: SubagentThreadStatus;
+    createdAt?: string;
+};
+/**
+ * Bounded discovery projection for one child owned by a parent conversation.
+ * Event-delivery identities stay private; `actorId` is the only event-binding
+ * field intentionally exposed to the parent's UI.
+ */
+export type ParentSubagentSummary = {
+    threadId: string;
+    parentMessageId: string;
+    /** Present only for ordinary tool-spawned children. */
+    parentToolCallId?: string;
+    subagentType: string;
+    subagentKind: 'agent' | 'graph';
+    agentId?: string;
+    title: string;
+    origin: 'tool' | 'event';
+    actorId?: string;
+    status: SubagentThreadStatus;
+    updatedAt?: string;
+    latestTaskId?: string;
+    tasks: ParentSubagentTaskSummary[];
+    tasksTruncated: boolean;
+};
+export type ParentSubagentIndex = {
+    parentConversationId: string;
+    children: ParentSubagentSummary[];
+    childrenTruncated: boolean;
+};
+/**
+ * A bounded, presentation-safe description of child work. This deliberately
+ * models user-visible activity instead of the LangChain messages, SSE events,
+ * or durable records that produced it.
+ */
+export type SubagentActivityItem = {
+    type: 'writing';
+    text: string;
+    textTruncated?: boolean;
+} | {
+    type: 'reasoning';
+    /** Bounded user-visible reasoning text; absent on projections persisted
+     *  before reasoning retention (rendered as a marker). */
+    text?: string;
+    textTruncated?: boolean;
+} | {
+    type: 'activity_label';
+    label: string;
+    labelType?: 'phase';
+    toolCallIds?: string[];
+    activityStartIndex?: number;
+    activityEndIndex?: number;
+    activityCount?: number;
+    agentIds?: string[];
+    status?: 'ok' | 'partial' | 'failed';
+    pending?: boolean;
+    labelTruncated?: boolean;
+} | {
+    type: 'tool';
+    toolCallId: string;
+    name: string;
+    input?: string;
+    output?: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    inputValidationError?: true;
+    inputTruncated?: boolean;
+    outputTruncated?: boolean;
+};
+export type SubagentControlAction = 'steer' | 'queue' | 'interrupt' | 'cancel' | 'cancel_message';
+export type SubagentControlReceipt = {
+    invocationId: string;
+    controlId?: string;
+    action: SubagentControlAction;
+    status: 'accepted' | 'applied' | 'rejected' | 'failed';
+    createdAt: string;
+    updatedAt: string;
+    boundary?: 'preempt' | 'tool' | 'turn';
+    reason?: string;
+    message?: string;
+    messageTruncated?: boolean;
+};
+export type SubagentControlRequest = {
+    taskId: string;
+    invocationId: string;
+    action: SubagentControlAction;
+    message?: string;
+    controlId?: string;
+};
+export type SubagentControlResponse = {
+    receipt: SubagentControlReceipt;
+};
+export type SubagentThreadMessage = {
+    messageId: string;
+    parentMessageId: string | null;
+    role: 'user' | 'assistant';
+    text: string;
+    createdAt?: string;
+    error?: boolean;
+    textTruncated?: boolean;
+};
+export type SubagentThreadTriggerKind = 'parent_dispatch' | 'parent_continuation' | 'external_event';
+export type SubagentExternalEventDetails = {
+    eventType: string;
+    sourceType: string;
+    occurredAt: string;
+    expectedActionToolName?: string;
+};
+/**
+ * One chronological child execution boundary. The trigger is host-authored,
+ * while activity and messages are bounded public projections of the child run.
+ */
+export type SubagentThreadTurn = {
+    taskId: string;
+    trigger: {
+        kind: SubagentThreadTriggerKind;
+        summary: string;
+        createdAt?: string;
+        summaryTruncated?: boolean;
+        externalEvent?: SubagentExternalEventDetails;
+    };
+    status: SubagentThreadStatus;
+    activity: SubagentActivityItem[];
+    activityTruncated: boolean;
+    controlReceipts?: SubagentControlReceipt[];
+    controlReceiptsTruncated?: boolean;
+    messages: SubagentThreadMessage[];
+};
+export type SubagentThreadView = {
+    threadId: string;
+    parentConversationId: string;
+    parentMessageId: string;
+    parentToolCallId: string;
+    subagentType: string;
+    subagentKind: 'agent' | 'graph';
+    /** Product recursion level, currently bounded to one by the host runtime. */
+    depth?: number;
+    agentId?: string;
+    title: string;
+    status: SubagentThreadStatus;
+    /** Activity for the exact task requested by the parent card, when retained. */
+    activity: SubagentActivityItem[];
+    activityTruncated: boolean;
+    /** Bounded authoritative parent-to-child command receipts for this task. */
+    controlReceipts?: SubagentControlReceipt[];
+    /** True when older authoritative command receipts were omitted from this view. */
+    controlReceiptsTruncated?: boolean;
+    /** Chronological, branch-selected child history for conversation-native rendering. */
+    turns?: SubagentThreadTurn[];
+    messages: SubagentThreadMessage[];
+    historyTruncated: boolean;
+    /** True when some branch rows were omitted and cannot be recovered with `nextCursor`. */
+    historyUnavailable?: boolean;
+    /** Opaque task-message cursor for the next older bounded branch page. */
+    nextCursor?: string;
+    updatedAt?: string;
+};

package/dist/types/types/web.d.ts

@@ -9,8 +9,8 @@ export declare enum DATE_RANGE {
     PAST_MONTH = "m",
     PAST_YEAR = "y"
 }
-export type SearchProvider = 'serper' | 'searxng' | 'tavily';
-export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable';
+export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily' | 'keenable';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -68,9 +68,13 @@ export interface SearchConfig {
     serperApiKey?: string;
     searxngInstanceUrl?: string;
     searxngApiKey?: string;
+    searxngSearchOptions?: z.infer<typeof webSearchSchema>['searxngSearchOptions'];
     tavilyApiKey?: string;
     tavilySearchUrl?: string;
     tavilySearchOptions?: TavilyConfig['tavilySearchOptions'];
+    keenableApiKey?: string;
+    keenableApiUrl?: string;
+    keenableSearchOptions?: KeenableConfig['keenableSearchOptions'];
 }
 export type References = {
     links: MediaReference[];
@@ -130,6 +134,12 @@ export interface TavilyConfig {
     tavilySearchOptions?: z.infer<typeof webSearchSchema>['tavilySearchOptions'];
     tavilyScraperOptions?: z.infer<typeof webSearchSchema>['tavilyScraperOptions'];
 }
+export interface KeenableConfig {
+    keenableApiKey?: string;
+    keenableApiUrl?: string;
+    keenableSearchOptions?: z.infer<typeof webSearchSchema>['keenableSearchOptions'];
+    keenableScraperOptions?: z.infer<typeof webSearchSchema>['keenableScraperOptions'];
+}
 export interface ScraperContentResult {
     content: string;
 }