@cerebriline/core 4.100.240

package/dist/runtime/host/runtime-host.d.ts

@@ -0,0 +1,280 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { AgentMode, AgentResult, RuntimeConfigExtensionKind } from "@cerebriline/shared";
+import type { BackgroundDelegationView } from "../../extensions/tools/team/background-delegations";
+import type { ConfiguredAgentDelegationResult, ConfiguredAgentSummary } from "../../extensions/tools/team/delegate-to-agent";
+import type { HookEventPayload } from "../../hooks";
+import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
+import type { ProviderSettings } from "../../services/llms/provider-settings";
+import type { SessionCompactionState } from "../../session/models/session-compaction";
+import type { SessionManifest } from "../../session/models/session-manifest";
+import type { SessionSource } from "../../types/common";
+import type { ClineCoreStartConfig, CoreSessionConfig } from "../../types/config";
+import type { CoreSessionEvent, SessionPendingPrompt } from "../../types/events";
+import type { SessionRecord } from "../../types/sessions";
+import type { RuntimeCapabilities } from "../capabilities";
+import type { ConnectionUpdate } from "../config/connection-update";
+export declare const SESSION_NOT_FOUND_ERROR_CODE = "session_not_found";
+export declare class SessionNotFoundError extends Error {
+    readonly sessionId?: string | undefined;
+    readonly code = "session_not_found";
+    constructor(sessionId?: string | undefined, message?: string);
+}
+export declare function isSessionNotFoundError(error: unknown): error is SessionNotFoundError;
+/**
+ * A session that cannot serve another turn, whatever the caller does with it.
+ *
+ * Two distinct causes, one remedy: the session is gone (`session_not_found`,
+ * after a hub restart, a deletion, or retention cleanup), or its runtime is stuck
+ * with a run that never drained (`session_run_in_progress`). A caller holding a
+ * long-lived mapping to that session — a connector thread, for instance — has to
+ * replace the session rather than keep retrying against it.
+ *
+ * Errors reaching a connector have crossed the hub's JSON boundary, so the code
+ * may be gone and only the message survives; both are checked, which also keeps
+ * this working when the hub and the CLI are different versions.
+ */
+export declare function isUnusableSessionError(error: unknown): boolean;
+type LocalOnlyCoreSessionConfigKeys = "hooks" | "logger" | "telemetry" | "extensionContext" | "extraTools" | "extensions" | "onTeamEvent" | "onConsecutiveMistakeLimitReached" | "taskProgress";
+export type RuntimeSessionConfig = Omit<CoreSessionConfig, LocalOnlyCoreSessionConfigKeys | "checkpoint" | "compaction"> & {
+    checkpoint?: Omit<NonNullable<CoreSessionConfig["checkpoint"]>, "createCheckpoint">;
+    compaction?: Omit<NonNullable<CoreSessionConfig["compaction"]>, "compact">;
+};
+/** Workspace paths may be omitted only at the session-start boundary. */
+export type StartSessionConfig = Omit<RuntimeSessionConfig, "cwd"> & {
+    cwd?: string;
+};
+export type LocalRuntimeBootstrapConfig = Pick<CoreSessionConfig, LocalOnlyCoreSessionConfigKeys> & {
+    checkpoint?: Pick<NonNullable<CoreSessionConfig["checkpoint"]>, "createCheckpoint"> & Partial<NonNullable<CoreSessionConfig["checkpoint"]>>;
+    compaction?: Pick<NonNullable<CoreSessionConfig["compaction"]>, "compact"> & Partial<NonNullable<CoreSessionConfig["compaction"]>>;
+};
+export interface LocalRuntimeStartOptions {
+    hooks?: LocalRuntimeBootstrapConfig["hooks"];
+    logger?: LocalRuntimeBootstrapConfig["logger"];
+    telemetry?: LocalRuntimeBootstrapConfig["telemetry"];
+    extensionContext?: LocalRuntimeBootstrapConfig["extensionContext"];
+    extraTools?: LocalRuntimeBootstrapConfig["extraTools"];
+    extensions?: LocalRuntimeBootstrapConfig["extensions"];
+    onTeamEvent?: LocalRuntimeBootstrapConfig["onTeamEvent"];
+    onConsecutiveMistakeLimitReached?: LocalRuntimeBootstrapConfig["onConsecutiveMistakeLimitReached"];
+    taskProgress?: LocalRuntimeBootstrapConfig["taskProgress"];
+    checkpoint?: LocalRuntimeBootstrapConfig["checkpoint"];
+    compaction?: LocalRuntimeBootstrapConfig["compaction"];
+    modelCatalogDefaults?: Partial<NonNullable<ProviderSettings["modelCatalog"]>>;
+    userInstructionService?: import("../../extensions/config").UserInstructionConfigService;
+    configExtensions?: RuntimeConfigExtensionKind[];
+    onTeamRestored?: () => void;
+}
+export interface StartSessionInput {
+    config: StartSessionConfig;
+    /** The process/client that starts the session. E.g., "vscode", "cli". */
+    source?: SessionSource;
+    /** How the session was initiated, such as user, automation, or subagent. */
+    mode?: string;
+    prompt?: string;
+    interactive?: boolean;
+    sessionMetadata?: Record<string, unknown>;
+    initialMessages?: LlmsProviders.MessageWithMetadata[];
+    initialCompactionState?: SessionCompactionState;
+    userImages?: string[];
+    userFiles?: string[];
+    /**
+     * Host-local bootstrap options. These are intentionally isolated from the
+     * transport-neutral runtime session config so all runtime hosts share the
+     * same execution contract while still allowing host-specific preparation.
+     */
+    localRuntime?: LocalRuntimeStartOptions;
+    capabilities?: RuntimeCapabilities;
+    toolPolicies?: import("@cerebriline/shared").AgentConfig["toolPolicies"];
+}
+/** Session input after the execution host has resolved a concrete workspace. */
+export interface ResolvedStartSessionInput extends Omit<StartSessionInput, "config"> {
+    config: RuntimeSessionConfig;
+}
+export declare function splitCoreSessionConfig(config: ClineCoreStartConfig): {
+    config: StartSessionConfig;
+    localRuntime?: LocalRuntimeStartOptions;
+};
+export interface StartSessionResult {
+    sessionId: string;
+    manifest: SessionManifest;
+    manifestPath: string;
+    messagesPath: string;
+    result?: AgentResult;
+}
+export interface SendSessionInput {
+    sessionId: string;
+    prompt: string;
+    mode?: AgentMode;
+    userImages?: string[];
+    userFiles?: string[];
+    delivery?: "queue" | "steer";
+    timeoutMs?: number;
+}
+export interface SessionAccumulatedUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalCost: number;
+}
+export interface SessionUsageSummary {
+    usage?: SessionAccumulatedUsage;
+    aggregateUsage?: SessionAccumulatedUsage;
+}
+export interface PendingPromptMutationResult {
+    sessionId: string;
+    prompts: SessionPendingPrompt[];
+    prompt?: SessionPendingPrompt;
+    updated?: boolean;
+    removed?: boolean;
+}
+export interface PendingPromptsListInput {
+    sessionId: string;
+}
+export interface PendingPromptsUpdateInput {
+    sessionId: string;
+    promptId: string;
+    prompt?: string;
+    mode?: AgentMode;
+    delivery?: "queue" | "steer";
+}
+export interface PendingPromptsDeleteInput {
+    sessionId: string;
+    promptId: string;
+}
+export interface PendingPromptsServiceApi {
+    list(input: PendingPromptsListInput): Promise<SessionPendingPrompt[]>;
+    update(input: PendingPromptsUpdateInput): Promise<PendingPromptMutationResult>;
+    delete(input: PendingPromptsDeleteInput): Promise<PendingPromptMutationResult>;
+}
+export interface PendingPromptsRuntimeService {
+    readonly pendingPrompts: PendingPromptsServiceApi;
+}
+export interface SessionUsageRuntimeService {
+    getAccumulatedUsage(sessionId: string): Promise<SessionUsageSummary | undefined>;
+}
+export type SessionConnectionUpdate = ConnectionUpdate;
+export interface SessionModelRuntimeService {
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
+}
+export interface SessionConnectionRuntimeService {
+    updateSessionConnection(sessionId: string, updates: SessionConnectionUpdate): Promise<void>;
+}
+export interface CommandExecutionRuntimeService {
+    proceedWhileRunning(sessionId: string, toolCallId?: string): Promise<number>;
+}
+export interface RuntimeHostSubscribeOptions {
+    sessionId?: string;
+}
+export interface RestoreSessionInput {
+    sessionId: string;
+    checkpointRunCount: number;
+    cwd?: string;
+    restore?: {
+        messages?: boolean;
+        workspace?: boolean;
+        omitCheckpointMessageFromSession?: boolean;
+    };
+    start?: StartSessionInput;
+}
+export interface RestoreSessionResult {
+    sessionId?: string;
+    startResult?: StartSessionResult;
+    messages?: LlmsProviders.MessageWithMetadata[];
+    checkpoint: CheckpointEntry;
+}
+/**
+ * RuntimeHost is the transport/runtime boundary for core session execution.
+ * Callers must normalize broad local config into `RuntimeSessionConfig`
+ * plus optional named `localRuntime` bootstrap fields before invoking a host.
+ */
+export interface RuntimeHost {
+    readonly runtimeAddress?: string;
+    startSession(input: StartSessionInput): Promise<StartSessionResult>;
+    runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
+    restoreSession(input: RestoreSessionInput): Promise<RestoreSessionResult>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
+    stopSession(sessionId: string): Promise<void>;
+    dispose(reason?: string): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    listSessions(limit?: number): Promise<SessionRecord[]>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    updateSession(sessionId: string, updates: {
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        title?: string | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    updateSessionCompactionState(sessionId: string, state: SessionCompactionState): Promise<{
+        updated: boolean;
+    }>;
+    readSessionCompactionState(sessionId: string): Promise<SessionCompactionState | undefined>;
+    readSessionMessages(sessionId: string): Promise<LlmsProviders.MessageWithMetadata[]>;
+    /**
+     * Like {@link readSessionMessages}, but prefers the resident session's
+     * in-memory conversation over the persisted transcript. Disk persistence
+     * happens at assistant-message/turn boundaries (and abort() does not
+     * flush), so this is the accurate read for callers that need the
+     * conversation of an in-flight or just-aborted turn — e.g. rebuilding a
+     * session for a mode switch. Optional: hosts without live-session access
+     * (e.g. hub clients) fall back to the persisted transcript.
+     */
+    readLiveSessionMessages?(sessionId: string): Promise<LlmsProviders.MessageWithMetadata[]>;
+    /**
+     * The configured agents this session loaded, for a host that offers a
+     * picker. Optional: a host with no live-session access has nothing to list.
+     */
+    listConfiguredAgents?(sessionId: string): Promise<ConfiguredAgentSummary[]>;
+    /**
+     * Run one configured agent on a task, because the user said to.
+     *
+     * Distinct from the model calling `subagent_<name>` itself: this does not
+     * consult the lead model at all. The agent's report is appended to the
+     * conversation, so the next turn sees what was done on its behalf.
+     */
+    delegateToConfiguredAgent?(input: {
+        sessionId: string;
+        agentName: string;
+        prompt: string;
+        signal?: AbortSignal;
+    }): Promise<ConfiguredAgentDelegationResult>;
+    /**
+     * The same, except the caller does not wait and the lead is not blocked.
+     *
+     * Unlike the foreground call this is allowed while a turn is running --
+     * that is the whole point of it -- and the report is delivered whenever the
+     * run finishes, into whatever the conversation is doing by then.
+     */
+    /**
+     * The user turned the change protocol off for this session.
+     *
+     * Optional because a host without the protocol has nothing to stand down.
+     * The implementation owns the timing: putting a discarded transaction's
+     * files back must not race a tool call that is still open, so this may
+     * complete without having done it yet.
+     *
+     * @returns whether there was a protocol running to stand down.
+     */
+    disengageAtomicProtocol?(sessionId: string): Promise<boolean>;
+    startBackgroundDelegation?(input: {
+        sessionId: string;
+        agentName: string;
+        prompt: string;
+    }): Promise<BackgroundDelegationView>;
+    /** The background runs of one session, for a host drawing them. */
+    listBackgroundDelegations?(sessionId: string): Promise<BackgroundDelegationView[]>;
+    /**
+     * @param action What the user pressed.
+     * @returns whether there was a run in a state that could take it.
+     */
+    controlBackgroundDelegation?(input: {
+        sessionId: string;
+        id: string;
+        action: "pause" | "resume" | "stop";
+    }): Promise<boolean>;
+    dispatchHookEvent(payload: HookEventPayload): Promise<void>;
+    subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+}
+export type RuntimeHostMode = "auto" | "local" | "hub" | "remote";
+export {};

package/dist/runtime/host/steer-side-turn.d.ts

@@ -0,0 +1,119 @@
+/**
+ * A turn for the lead while it waits on its agents.
+ *
+ * The lead reads a steering message at its next turn boundary, and a lead
+ * inside `spawn_agent` has none until every agent in the round has finished:
+ * on pandorum 2026-09-24 a message sent 45 minutes into a round of 75 was
+ * queued and never read ("Message queued for session", then nothing). The user
+ * could not ask the lead anything, nor have it stop what it had started.
+ *
+ * So a steer that arrives while agents are running is answered here, at once,
+ * by a short run of the lead's own model on the lead's own conversation: the
+ * delegation call still open is closed in this copy with the round's live
+ * state, and the message follows it. The lead may answer, leave a message for
+ * some or all of the running agents, or stop them. Then the round carries on,
+ * and the lead's real turn later is told what was said and done here, so the
+ * two do not disagree about what happened.
+ *
+ * The run is a copy. Nothing is written to the lead's conversation until that
+ * note, because the lead's history has a tool call open that only the
+ * delegation's own result may close.
+ */
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { AgentTool } from "@cerebriline/shared";
+type Message = LlmsProviders.MessageWithMetadata;
+/**
+ * Turns the side run may take.
+ *
+ * Four ran out in 4 of the 8 side turns of swarm 0926: a side turn now reads
+ * the round (`agents_status`, sometimes twice -- summary, then an agent's
+ * detail), acts on it (`message_agents`, `stop_agents`, `requeue_agent`,
+ * `restart_agent`, `resume_agent`, `retry_failed`; a model often issues these
+ * one per turn rather than in one batch), and then answers. Status twice,
+ * four controls and the reply is seven; ten leaves room for one tool error
+ * the model corrects and one more look, and still bounds a side run that
+ * loops -- it is a copy of the lead answering one message, not a work turn.
+ */
+export declare const STEER_SIDE_TURN_MAX_ITERATIONS = 10;
+export interface SteerSideTurnRunner {
+    /** Seed the copy of the lead's conversation. */
+    restore(messages: readonly Message[]): void;
+    /**
+     * Run one user message on it; resolves with the final text, and why the
+     * run ended when it says (a run that hit its cap or failed ends with the
+     * runtime's message as its text, which is not a reply).
+     */
+    continue(message: string): Promise<{
+        text: string;
+        finishReason?: string;
+    }>;
+}
+export interface SteerSideTurnInput {
+    sessionId: string;
+    /** The steer, as the user wrote it -- or the system's status report. */
+    message: string;
+    /**
+     * Who is speaking. `system` is the agents' own status report (see
+     * `agent-trouble.ts`): agents stuck for a long time, which the lead may
+     * want to take back. Defaults to the user.
+     */
+    source?: "user" | "system";
+    /** The lead's conversation as it stands, with its delegation call open. */
+    messages: readonly Message[];
+    /** Builds the lead's model with exactly these tools. */
+    createRunner: (tools: AgentTool[]) => SteerSideTurnRunner;
+    /**
+     * The lead's own agent tools the side turn may use besides the two above:
+     * those of {@link SIDE_TURN_LEAD_TOOL_NAMES} the session has.
+     */
+    leadTools?: readonly AgentTool[];
+}
+/**
+ * The session's tools a side turn gets as they are: what the lead needs to
+ * see into the round it is waiting on (spec B: the status tool in every mode).
+ */
+export declare const SIDE_TURN_LEAD_TOOL_NAMES: ReadonlySet<string>;
+export interface SteerSideTurnResult {
+    /** What the lead said to the user. */
+    reply: string;
+    /** What it did to the round, in words, for the user and for the lead. */
+    actions: string[];
+    /** The side turn itself failed; the message still needs the lead. */
+    failed?: boolean;
+    /**
+     * How it failed: `iteration_cap` when it ran out of turns before it
+     * replied, `error` when its run ended in an error. About the side turn,
+     * never about the agents.
+     */
+    failure?: "iteration_cap" | "error";
+}
+/** The agents of this session's round, as the lead's side turn is shown them. */
+export declare function describeRunningRound(sessionId: string): string;
+/**
+ * Close every tool call left open at the end of the lead's conversation, in
+ * this copy only, with the round's state as its result. A request with an open
+ * tool call is refused by every chat template this runs on.
+ */
+export declare function closeOpenToolCalls(messages: readonly Message[], status: string): Message[];
+/**
+ * What the side turn may do to the round: message and stop its agents, and
+ * the controls -- requeue, restart, resume, retry -- the lead has in its own
+ * turn. Each records what it did, for the user and for the lead.
+ */
+export declare function createSteerRoundTools(sessionId: string, actions: string[]): AgentTool[];
+/**
+ * The reply when the side turn used all of its own turns without writing one.
+ * Says whose turns they were, so it cannot be read as a report on the agents.
+ */
+export declare const SIDE_TURN_OUT_OF_TURNS = "(No reply: this side turn used all 10 of its own turns before answering. That limit is the side turn's own, not the agents' -- it says nothing about how far they got.)";
+/** Run the side turn. Never throws: a failure is the reply. */
+export declare function runSteerSideTurn(input: SteerSideTurnInput): Promise<SteerSideTurnResult>;
+/**
+ * What the lead's real turn is told, once the round returns: the exchange it
+ * had in the side turn, which is not in its history. One line, so queued
+ * recaps merge into one note with the user's messages first; a stuck-agent
+ * report is named by its agents, not quoted -- the latest status says the
+ * rest. "Answer it" only when the side turn neither replied nor acted.
+ */
+export declare function describeSideTurnForLead(message: string, result: SteerSideTurnResult, source?: "user" | "system"): string;
+export {};

package/dist/runtime/orchestration/runtime-builder.d.ts

@@ -0,0 +1,14 @@
+import type { CoreSessionConfig } from "../../types/config";
+import type { RuntimeBuilder, RuntimeBuilderInput, BuiltRuntime as RuntimeEnvironment } from "./session-runtime";
+export declare function createTeamName(): string;
+/**
+ * The nodes this session places agents on, priority 0 included when
+ * "Use PolyKV agents as Priority 0" is on. Every reader of the node list
+ * goes through here, so the delegation gate and the swarm offer see the
+ * nodes agents are actually placed on.
+ */
+export declare function resolveSessionAgentNodes(config: CoreSessionConfig): NonNullable<CoreSessionConfig["agentNodes"]>;
+export declare class DefaultRuntimeBuilder implements RuntimeBuilder {
+    private readonly teamRuntimeEntries;
+    build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment>;
+}

package/dist/runtime/orchestration/runtime-event-adapter.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Adapter from the new `AgentRuntimeEvent` union (defined
+ * in `@cerebriline/shared/src/agent.ts`) to the legacy `AgentEvent` union
+ * (9 top-level types, defined in
+ * `@cerebriline/shared/src/agents/types.ts`) consumed by today's
+ * `Agent.subscribeEvents` callback.
+ *
+ * @see PLAN.md §3.1  — new file introduced alongside the core runtime port.
+ * @see PLAN.md §3.3.2 — variant-by-variant OLD → NEW mapping.
+ * @see PLAN.md §3.2.4 — called from `Agent.subscribeEvents` inside the
+ *                       legacy-agent facade.
+ *
+ * --- IMPLEMENTATION NOTE — PLAN §3.3.2 text/reasoning-delta rows ----------
+ *
+ * PLAN.md §3.3.2 describes `assistant-text-delta` as "first delta →
+ * content_start, subsequent → content_update". The **actual** legacy
+ * shape forbids this: `AgentContentUpdateEvent.contentType` is
+ * hard-typed as `"tool"` in
+ * `packages/shared/src/agents/types.ts:87`, and the legacy
+ * turn-processor
+ * (`packages/agents/src/runtime/turn-processor.ts:82-87,113-118`)
+ * emits a `content_start` event for **every** text delta and for
+ * **every** reasoning delta — not just the first. This adapter
+ * preserves that observable behavior (what every legacy consumer
+ * relies on today) over the description in §3.3.2.
+ *
+ *   text deltas      → content_start { contentType:"text", text,
+ *                        accumulated } (per delta)
+ *   reasoning deltas → content_start { contentType:"reasoning",
+ *                        reasoning, redacted } (per delta)
+ *   assistant-media   → content_end { contentType:"media", media }
+ *                        at the original stream position
+ *   assistant-message → one content_end { contentType:"text", text }
+ *                        if any text parts; one
+ *                        content_end { contentType:"reasoning", reasoning }
+ *                        if any reasoning parts
+ *                        (turn-processor.ts:157-170).
+ *
+ * --- STATEFUL BOOK-KEEPING ------------------------------------------------
+ *
+ *  1. Rolling usage totals. `usage-updated` carries the already-
+ *     accumulated snapshot (agent-runtime.ts:668-683). Legacy
+ *     `AgentUsageEvent` wants both per-turn delta and accumulated
+ *     totals; the adapter subtracts the previous accumulated value
+ *     from the incoming one to produce the delta.
+ *  2. Tool timing. `tool-finished` does not carry `durationMs`. The
+ *     adapter records `Date.now()` on `tool-started` (keyed by
+ *     `toolCallId`) and computes `durationMs` at `tool-finished`.
+ *     Matches `tool-orchestrator.ts:112-131`.
+ *
+ * Both are scoped to a single adapter instance and cleared by
+ * `reset()`.
+ */
+import type { AgentEvent, AgentMessage, AgentRuntimeEvent } from "@cerebriline/shared";
+declare function textFromMessage(message: AgentMessage | undefined): string;
+/**
+ * Per-subscriber adapter instance. Constructed once per
+ * `Agent.subscribeEvents` registration (or per `SessionRuntime`),
+ * used for the lifetime of that subscription, and `reset()` at the
+ * start of every new run.
+ *
+ * `translate(event)` returns zero, one, or two `AgentEvent`s. An
+ * array is needed because a single `assistant-message` may yield both
+ * a text `content_end` and a reasoning `content_end`. Empty array
+ * means the event is intentionally suppressed (§3.3.2 rows
+ * `run-started`, `message-added`).
+ */
+export declare class RuntimeEventAdapter {
+    private lastUsage;
+    private toolStartedAt;
+    translate(event: AgentRuntimeEvent): AgentEvent[];
+    private translateEvent;
+    reset(): void;
+    private translateAssistantMessage;
+    private translateToolStarted;
+    private translateToolFinished;
+    private translateUsage;
+    private translateRunFinished;
+}
+/**
+ * Stateless translator. Works correctly for every variant except
+ * those that require bookkeeping:
+ *
+ *  - `usage-updated` — deltas cannot be computed without a prior
+ *    snapshot; this function treats the prior snapshot as zero (so
+ *    delta == accumulated). Adequate for a single event, incorrect
+ *    across multiple.
+ *  - `tool-finished` — `durationMs` is reported as `undefined`
+ *    because the corresponding `tool-started` was never observed by
+ *    this one-shot adapter.
+ *
+ * Production code must use `RuntimeEventAdapter` for multi-event
+ * runs; this function exists for ad-hoc unit tests and one-shot
+ * translations where bookkeeping does not matter.
+ *
+ * Returns `undefined` when the event maps to zero legacy events
+ * (`run-started`, `message-added`, or an `assistant-message` that
+ * carries no text/reasoning parts). When an event produces multiple
+ * legacy events (e.g. `assistant-message` with both text and
+ * reasoning parts), only the first is returned; callers needing the
+ * full array must use `RuntimeEventAdapter.translate()`.
+ */
+export declare function toLegacyAgentEvent(event: AgentRuntimeEvent): AgentEvent | undefined;
+export { textFromMessage };

package/dist/runtime/orchestration/runtime-oauth-token-manager.d.ts

@@ -0,0 +1,28 @@
+import type { ITelemetryService } from "@cerebriline/shared";
+import { ProviderSettingsManager } from "../../services/storage/provider-settings-manager";
+type ManagedOAuthProviderId = string;
+export declare class OAuthReauthRequiredError extends Error {
+    readonly providerId: ManagedOAuthProviderId;
+    constructor(providerId: ManagedOAuthProviderId);
+}
+export type RuntimeOAuthResolution = {
+    apiKey: string;
+    accountId?: string;
+    refreshed: boolean;
+};
+export declare class RuntimeOAuthTokenManager {
+    private readonly providerSettingsManager;
+    private readonly telemetry?;
+    private readonly refreshInFlight;
+    constructor(options?: {
+        providerSettingsManager?: ProviderSettingsManager;
+        telemetry?: ITelemetryService;
+    });
+    resolveProviderApiKey(input: {
+        providerId: string;
+        forceRefresh?: boolean;
+    }): Promise<RuntimeOAuthResolution | null>;
+    private resolveWithSingleFlight;
+    private resolveProviderApiKeyInternal;
+}
+export {};