librechat-data-provider 0.8.521 → 0.8.523

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;
@@ -166,6 +234,10 @@ export type TTokenBudgetBreakdown = {
     toolTokenCounts?: Record<string, number>;
     /** Names of counted tools that are deferred (`defer_loading`) and discovered */
     deferredToolNames?: string[];
+    /** Calibrated retained tool traffic: tool results plus assistant turns made only of tool calls, inline provider tool results and reasoning. A subset of messageTokens, not an additional budget category. */
+    toolMessageTokens?: number;
+    /** Per-tool result-message share; excludes assistant invocation overhead. */
+    toolMessageTokenCounts?: Record<string, number>;
 };
 /** Per-model-call context snapshot, dispatched after pruning and before the LLM call. */
 export type TContextUsageEvent = {
@@ -181,12 +253,21 @@ export type TContextUsageEvent = {
     /** Tokens still free after instructions + pruned messages */
     remainingContextTokens?: number;
     calibrationRatio?: number;
+    /** Model and provider of the reconciling primary call, retained across reloads. */
+    model?: string;
+    provider?: string;
+    /** Cache portions of that call's prompt, in normalized display units. */
+    cacheRead?: number;
+    cacheWrite?: number;
     /** Output tokens of the response's final model call (the call this pre-invoke
-     *  snapshot precedes). Populated only on the persisted `metadata.contextUsage`
-     *  blob so a reloaded multi-call turn adds the same post-snapshot delta the
+     *  snapshot precedes). Saved in message metadata and used by the client so a
+     *  reloaded multi-call turn adds the same post-snapshot delta the
      *  live finalizer did — not the full response `tokenCount`, which the snapshot
      *  already includes for earlier steps. */
     completedOutputTokens?: number;
+    /** Completed output in a resumable job. Separate from the saved-message field
+     * so older clients do not add it alongside their trailing-text estimate. */
+    resumedOutputTokens?: number;
 };
 /**
  * Per-response usage rollup persisted on `responseMessage.metadata.usage`, in
@@ -217,8 +298,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;
@@ -241,29 +323,57 @@ export declare const promptTokensFromUsage: (event: TTokenUsageEvent) => number;
 /**
  * Reconciles a pre-invoke context snapshot's CALIBRATED estimate to a call's
  * ACTUAL prompt tokens. The SDK's calibration multiplier scales only
- * `messageTokens` (instructions/summary are raw tiktoken counts), and it can
+ * `messageTokens` (instructions/summary are raw tiktoken counts) and can
  * over-shoot badly when a provider injects server-side content the SDK never
  * counted (e.g. Anthropic web search) — pinning the gauge several× too high and
  * persisting it. Trust the provider's own prompt count: keep the raw
- * instruction/summary rows, set `messageTokens` to the remainder, and recompute
- * the free space. No-op when `promptTokens` is unusable.
+ * instruction/summary rows, set `messageTokens` to the remainder, recompute the
+ * free space, and rescale the `toolMessageTokens` share to the new message
+ * total. No-op when `promptTokens` is unusable.
  */
 export declare const reconcileContextUsage: (snapshot: TContextUsageEvent, promptTokens: number) => TContextUsageEvent;
+/** Provider output, including reasoning omitted from an under-reported output count. */
+export declare const outputTokensFromUsage: (event: TTokenUsageEvent) => number;
+/** Reconcile and retain the primary call details on live, saved, and resumable snapshots. */
+export declare const reconcileContextUsageFromEvent: (snapshot: TContextUsageEvent, event: TTokenUsageEvent) => 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;
+}
+export type SubagentIdentity = Pick<SubagentAncestryEntry, 'subagentKind' | 'subagentAgentId'>;
 /** 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,339 @@
+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 = 'mcp_reauth_required' | 'mcp_configuration_missing' | 'mcp_permission_denied' | '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;
+    prompt: string;
+    enabled: boolean;
+    agent_id: string;
+    clientRequestId: string;
+    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;
+    prompt: string;
+    agent_id: string;
+    clientRequestId: string;
+    timezone: string;
+    cadence: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    };
+    enabled?: boolean | undefined;
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | 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>;
+    prompt: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    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>;
+    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;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    agent_id?: string | 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;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    agent_id?: string | 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;
+    mcp?: ScheduleMCPOutcome[];
+    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;
+    /**
+     * The occurrences generating right now. Read from their own run rows, not from
+     * `lastRun`, which is projected only when a run settles, pauses or skips and is
+     * deliberately withheld from a run whose schedule was edited mid-flight. This is
+     * the signal a client has that a chat is on its way, and the id to fetch it by.
+     * A run parked on an approval is not here: its chat was listed long ago, and the
+     * rows can accumulate for as long as approvals wait.
+     */
+    inFlight?: Array<{
+        conversationId: string;
+    }>;
+    runCount: number;
+    failureCount: number;
+    configRevision?: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type TScheduleRun = {
+    mcp?: ScheduleMCPOutcome[];
+    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';
+};
+/** Only structured schedule preflight failures may request immediate suspension. */
+export declare function getScheduleMCPDisabledReason(outcomes?: ScheduleMCPOutcome[]): 'mcp_reauth_required' | 'mcp_configuration_missing' | 'mcp_permission_denied' | undefined;
+export declare const scheduleMCPOutcomeSchema: z.ZodObject<{
+    server: z.ZodString;
+    /** Agent whose selected tool requires this server. Used to open the correct
+     * recovery chat when the requirement belongs to a handoff or subagent. */
+    agentId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["ready", "mcp_reauth_required", "mcp_configuration_missing", "mcp_permission_denied", "mcp_unavailable"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "ready" | "mcp_reauth_required" | "mcp_configuration_missing" | "mcp_permission_denied" | "mcp_unavailable";
+    server: string;
+    agentId?: string | undefined;
+}, {
+    status: "ready" | "mcp_reauth_required" | "mcp_configuration_missing" | "mcp_permission_denied" | "mcp_unavailable";
+    server: string;
+    agentId?: string | undefined;
+}>;
+export type ScheduleMCPOutcome = z.infer<typeof scheduleMCPOutcomeSchema>;
+export type ScheduleMCPStatus = ScheduleMCPOutcome['status'];
+export declare function readScheduleMCPOutcomes(error?: string): ScheduleMCPOutcome[];

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;
 };