@mu-agent/mu 0.0.1

package/dist/types/ai/auth.d.ts

@@ -0,0 +1,2 @@
+import type { Credential, StreamOpts } from "./types.js";
+export declare function resolveCredential(provider: string, envVar: string | undefined, opts?: StreamOpts): Promise<Credential>;

package/dist/types/ai/catalog.d.ts

@@ -0,0 +1,20 @@
+import type { Credential, ModelInfo, Provider } from "./types.js";
+type CatalogFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface ModelDiscoveryOptions {
+    fetch?: CatalogFetch;
+    url?: string;
+    signal?: AbortSignal;
+    getCredentials?: (provider: string) => Promise<Credential | undefined>;
+    clientVersion?: string;
+    providers?: Iterable<Provider>;
+    onWarning?: (warning: string) => void;
+}
+export declare function discoverModels(options?: ModelDiscoveryOptions): Promise<ModelInfo[]>;
+export declare function refreshModels(options?: ModelDiscoveryOptions): Promise<ModelInfo[]>;
+export declare function listModels(): ModelInfo[];
+export declare function registerModels(extra: ModelInfo[]): void;
+export declare function findModel(ref: string): ModelInfo | undefined;
+export declare function modelRef(model: ModelInfo): string;
+export declare function providerHasCredentials(provider: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function defaultModelRef(env?: NodeJS.ProcessEnv, authenticatedProviders?: Iterable<string>): string;
+export {};

package/dist/types/ai/cost.d.ts

@@ -0,0 +1,4 @@
+import type { ModelPricing, Usage } from "./types.js";
+export declare function computeCostUsd(pricing: ModelPricing, usage: Usage): number;
+export declare function zeroUsage(): Usage;
+export declare function addUsage(a: Usage, b: Usage): Usage;

package/dist/types/ai/errors.d.ts

@@ -0,0 +1,13 @@
+export type AiErrorKind = "auth" | "rate_limit" | "overloaded" | "context_too_long" | "bad_request" | "not_found" | "network" | "api";
+export declare class AiError extends Error {
+    readonly kind: AiErrorKind;
+    readonly status?: number;
+    readonly retryAfterMs?: number;
+    constructor(kind: AiErrorKind, message: string, opts?: {
+        status?: number;
+        retryAfterMs?: number;
+    });
+    get retryable(): boolean;
+}
+export declare function isContextTooLongMessage(message: string): boolean;
+export declare function classifyHttpError(status: number, body: string, headers: Headers): AiError;

package/dist/types/ai/index.d.ts

@@ -0,0 +1,22 @@
+export { resolveCredential } from "./auth.js";
+export type { ModelDiscoveryOptions } from "./catalog.js";
+export { defaultModelRef, discoverModels, findModel, listModels, modelRef, providerHasCredentials, refreshModels, registerModels, } from "./catalog.js";
+export { addUsage, computeCostUsd, zeroUsage } from "./cost.js";
+export type { AiErrorKind } from "./errors.js";
+export { AiError, classifyHttpError, isContextTooLongMessage } from "./errors.js";
+export { parseJsonWithRepair, parsePartialJson, repairJson, salvageToolArgs } from "./json.js";
+export { builtinProviderConfigs, modelApi, providerBaseUrl, providerConfig, providerEnvVars, } from "./provider-config.js";
+export { anthropic, streamAnthropic } from "./providers/anthropic.js";
+export { gemini, streamGemini } from "./providers/gemini.js";
+export { discoverGitHubCopilotModels } from "./providers/github-copilot.js";
+export { discoverOpenAICodexModels, openai, openaiCodex, streamOpenAI, } from "./providers/openai.js";
+export { openaiCompletions, streamOpenAICompletions } from "./providers/openai-completions.js";
+export { getProvider, providers, registerProvider } from "./registry.js";
+export type { RetryOpts } from "./retry.js";
+export { withRetries } from "./retry.js";
+export type { SseEvent } from "./sse.js";
+export { iterateSse } from "./sse.js";
+export { AssistantStream, EventStream } from "./stream.js";
+export type { Cassette, RecordedInteraction, ReplayCall, ReplayHandle } from "./testing/replay.js";
+export { recordFetch, replayFetch } from "./testing/replay.js";
+export * from "./types.js";

package/dist/types/ai/json.d.ts

@@ -0,0 +1,4 @@
+export declare function repairJson(json: string): string;
+export declare function parseJsonWithRepair<T = unknown>(json: string): T;
+export declare function parsePartialJson(text: string): unknown;
+export declare function salvageToolArgs(partialJson: string | undefined): Record<string, unknown>;

package/dist/types/ai/provider-config.d.ts

@@ -0,0 +1,15 @@
+import type { LlmApi, ModelInfo } from "./types.js";
+export interface BuiltinProviderConfig {
+    id: string;
+    name: string;
+    api: LlmApi;
+    baseUrl?: string;
+    env: string[];
+    auth?: "bearer" | "anthropic" | "google" | "azure" | "cloudflare";
+    headers?: Record<string, string>;
+}
+export declare const builtinProviderConfigs: Map<string, BuiltinProviderConfig>;
+export declare function providerConfig(id: string): BuiltinProviderConfig | undefined;
+export declare function modelApi(model: ModelInfo): LlmApi;
+export declare function providerBaseUrl(model: ModelInfo): string | undefined;
+export declare function providerEnvVars(provider: string): readonly string[];

package/dist/types/ai/providers/anthropic.d.ts

@@ -0,0 +1,4 @@
+import type { AssistantStream } from "../stream.js";
+import type { LlmContext, ModelInfo, Provider, StreamOpts } from "../types.js";
+export declare function streamAnthropic(model: ModelInfo, ctx: LlmContext, opts?: StreamOpts): AssistantStream;
+export declare const anthropic: Provider;

package/dist/types/ai/providers/gemini.d.ts

@@ -0,0 +1,4 @@
+import type { AssistantStream } from "../stream.js";
+import type { LlmContext, ModelInfo, Provider, StreamOpts } from "../types.js";
+export declare function streamGemini(model: ModelInfo, ctx: LlmContext, opts?: StreamOpts): AssistantStream;
+export declare const gemini: Provider;

package/dist/types/ai/providers/github-copilot.d.ts

@@ -0,0 +1,2 @@
+import type { ModelInfo, ProviderModelDiscoveryOptions } from "../types.js";
+export declare function discoverGitHubCopilotModels(options: ProviderModelDiscoveryOptions): Promise<ModelInfo[] | undefined>;

package/dist/types/ai/providers/openai-completions.d.ts

@@ -0,0 +1,4 @@
+import type { AssistantStream } from "../stream.js";
+import type { LlmContext, ModelInfo, Provider, StreamOpts } from "../types.js";
+export declare function streamOpenAICompletions(model: ModelInfo, ctx: LlmContext, opts?: StreamOpts): AssistantStream;
+export declare const openaiCompletions: Provider;

package/dist/types/ai/providers/openai.d.ts

@@ -0,0 +1,6 @@
+import type { AssistantStream } from "../stream.js";
+import type { LlmContext, ModelInfo, Provider, ProviderModelDiscoveryOptions, StreamOpts } from "../types.js";
+export declare function discoverOpenAICodexModels(options: ProviderModelDiscoveryOptions): Promise<ModelInfo[] | undefined>;
+export declare function streamOpenAI(model: ModelInfo, ctx: LlmContext, opts?: StreamOpts): AssistantStream;
+export declare const openai: Provider;
+export declare const openaiCodex: Provider;

package/dist/types/ai/providers/radius.d.ts

@@ -0,0 +1,5 @@
+import type { AssistantStream } from "../stream.js";
+import type { LlmContext, ModelInfo, Provider, ProviderModelDiscoveryOptions, StreamOpts } from "../types.js";
+export declare function discoverRadiusModels(options: ProviderModelDiscoveryOptions): Promise<ModelInfo[] | undefined>;
+export declare function streamRadius(model: ModelInfo, context: LlmContext, opts?: StreamOpts): AssistantStream;
+export declare const radius: Provider;

package/dist/types/ai/providers/request.d.ts

@@ -0,0 +1,6 @@
+import type { Credential, ModelInfo, StreamOpts } from "../types.js";
+export declare function resolveProviderCredential(model: ModelInfo, opts?: StreamOpts): Promise<Credential>;
+export declare function resolvedBaseUrl(model: ModelInfo, opts?: StreamOpts): string;
+export declare function apiPath(baseUrl: string, path: string): string;
+export declare function credentialHeaders(model: ModelInfo, credential: Credential): Record<string, string>;
+export declare function credentialBaseUrl(model: ModelInfo, credential: Credential, opts?: StreamOpts): string;

package/dist/types/ai/providers/shared.d.ts

@@ -0,0 +1,6 @@
+import { AssistantStream } from "../stream.js";
+import type { AssistantMessage, ModelInfo, StreamOpts } from "../types.js";
+export declare function newAssistantMessage(model: ModelInfo): AssistantMessage;
+export declare function updateCost(model: ModelInfo, output: AssistantMessage): void;
+export declare function driveStream(model: ModelInfo, opts: StreamOpts | undefined, fn: (stream: AssistantStream, output: AssistantMessage) => Promise<void>): AssistantStream;
+export declare function postSse(url: string, headers: Record<string, string>, body: unknown, opts?: StreamOpts): Promise<Response>;

package/dist/types/ai/registry.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "./types.js";
+export declare const providers: Map<string, Provider>;
+export declare function getProvider(id: string): Provider;
+export declare function registerProvider(provider: Provider): void;

package/dist/types/ai/retry.d.ts

@@ -0,0 +1,6 @@
+export interface RetryOpts {
+    maxRetries?: number;
+    maxRetryDelayMs?: number;
+    signal?: AbortSignal;
+}
+export declare function withRetries<T>(request: () => Promise<T>, opts?: RetryOpts): Promise<T>;

package/dist/types/ai/sse.d.ts

@@ -0,0 +1,5 @@
+export interface SseEvent {
+    event: string | null;
+    data: string;
+}
+export declare function iterateSse(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<SseEvent>;

package/dist/types/ai/stream.d.ts

@@ -0,0 +1,18 @@
+import type { AssistantMessage, ProviderStreamEvent } from "./types.js";
+export declare class EventStream<T, R = T> implements AsyncIterable<T> {
+    private isComplete;
+    private extractResult;
+    private queue;
+    private waiting;
+    private done;
+    private finalResult;
+    private resolveFinal;
+    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
+    push(event: T): void;
+    end(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    result(): Promise<R>;
+}
+export declare class AssistantStream extends EventStream<ProviderStreamEvent, AssistantMessage> {
+    constructor();
+}

package/dist/types/ai/testing/replay.d.ts

@@ -0,0 +1,31 @@
+export interface RecordedInteraction {
+    request: {
+        method: string;
+        url: string;
+        body?: string;
+    };
+    response: {
+        status: number;
+        headers?: Record<string, string>;
+        body: string;
+    };
+}
+export interface Cassette {
+    interactions: RecordedInteraction[];
+}
+export interface ReplayCall {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+export interface ReplayHandle {
+    fetch: typeof fetch;
+    calls: ReplayCall[];
+    assertExhausted(): void;
+}
+export declare function replayFetch(cassette: Cassette): ReplayHandle;
+export declare function recordFetch(base?: typeof fetch): {
+    fetch: typeof fetch;
+    cassette: Cassette;
+};

package/dist/types/ai/types.d.ts

@@ -0,0 +1,187 @@
+export interface TextContent {
+    type: "text";
+    text: string;
+}
+export interface ThinkingContent {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+    redacted?: boolean;
+}
+export interface ImageContent {
+    type: "image";
+    mimeType: string;
+    data: string;
+    evictable?: boolean;
+}
+export interface ToolCallContent {
+    type: "toolCall";
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    signature?: string;
+}
+export type UserContent = TextContent | ImageContent;
+export type AssistantContent = TextContent | ThinkingContent | ToolCallContent;
+export type ToolResultContent = TextContent | ImageContent;
+export interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    costUsd?: number;
+}
+export type StopReason = "end" | "toolUse" | "length" | "aborted" | "error";
+export interface UserMessage {
+    role: "user";
+    content: UserContent[];
+    timestamp: number;
+}
+export interface AssistantMessage {
+    role: "assistant";
+    content: AssistantContent[];
+    model: string;
+    usage: Usage;
+    stopReason: StopReason;
+    errorMessage?: string;
+    timestamp: number;
+}
+export interface ToolResultMessage {
+    role: "toolResult";
+    toolCallId: string;
+    toolName: string;
+    content: ToolResultContent[];
+    details?: unknown;
+    isError: boolean;
+    evicted?: boolean;
+    timestamp: number;
+}
+export type AiMessage = UserMessage | AssistantMessage | ToolResultMessage;
+export interface PromptSection {
+    text: string;
+    dynamic?: boolean;
+}
+export interface ToolSpec {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface LlmContext {
+    systemPrompt?: PromptSection[];
+    messages: AiMessage[];
+    tools?: ToolSpec[];
+}
+export interface ModelPricing {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+export type LlmApi = "anthropic-messages" | "google-generative-ai" | "google-vertex" | "openai-completions" | "openai-responses";
+export interface ModelInfo {
+    provider: string;
+    id: string;
+    name?: string;
+    api?: LlmApi;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    contextWindow: number;
+    maxOutput: number;
+    modalities: ("text" | "image")[];
+    thinking?: boolean;
+    thinkingMode?: "adaptive" | "budget";
+    pricing: ModelPricing;
+}
+export type ThinkingLevel = "off" | "low" | "medium" | "high";
+export type Credential = {
+    type: "apiKey";
+    apiKey: string;
+} | {
+    type: "oauth";
+    accessToken: string;
+    accountId?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    availableModelIds?: string[];
+};
+export type CredentialResolver = () => Promise<Credential | undefined>;
+export interface ProviderModelDiscoveryOptions {
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+    getCredentials?: CredentialResolver;
+    clientVersion?: string;
+    currentModels: readonly ModelInfo[];
+}
+export interface StreamOpts {
+    apiKey?: string;
+    getCredentials?: CredentialResolver;
+    baseUrl?: string;
+    sessionId?: string;
+    maxTokens?: number;
+    temperature?: number;
+    thinkingLevel?: ThinkingLevel;
+    signal?: AbortSignal;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}
+export type ProviderStreamEvent = {
+    type: "start";
+    partial: AssistantMessage;
+} | {
+    type: "text_start";
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: "text_delta";
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: "text_end";
+    contentIndex: number;
+    content: string;
+    partial: AssistantMessage;
+} | {
+    type: "thinking_start";
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: "thinking_delta";
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: "thinking_end";
+    contentIndex: number;
+    content: string;
+    partial: AssistantMessage;
+} | {
+    type: "toolcall_start";
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: "toolcall_end";
+    contentIndex: number;
+    toolCall: ToolCallContent;
+    partial: AssistantMessage;
+} | {
+    type: "done";
+    message: AssistantMessage;
+} | {
+    type: "error";
+    reason: Extract<StopReason, "aborted" | "error">;
+    errorKind?: string;
+    error: AssistantMessage;
+};
+import type { AssistantStream } from "./stream.js";
+export interface Provider {
+    id: string;
+    stream(model: ModelInfo, ctx: LlmContext, opts?: StreamOpts): AssistantStream;
+    discoverModels?(options: ProviderModelDiscoveryOptions): Promise<ModelInfo[] | undefined>;
+}

package/dist/types/core/checkpoint.d.ts

@@ -0,0 +1,39 @@
+export interface CheckpointDiffFile {
+    path: string;
+    added: number;
+    removed: number;
+    hunks: string[];
+}
+export interface CheckpointProvider {
+    snapshot(label?: string): Promise<string | undefined>;
+    restore(ref: string): Promise<void>;
+    restoreResources?(ref: string, resources: string[]): Promise<void>;
+    diff(fromRef: string, toRef?: string): Promise<CheckpointDiffFile[]>;
+}
+export interface CheckpointEntry {
+    id: string;
+    beforeEntryId: string | null;
+    beforeRef: string;
+    afterRef: string;
+    redoRef?: string;
+    label?: string;
+}
+export declare class CheckpointHistory {
+    private done;
+    private undone;
+    record(entry: CheckpointEntry): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    peekUndo(): CheckpointEntry | undefined;
+    commitUndo(expected: CheckpointEntry, redoRef?: string): void;
+    peekRedo(): CheckpointEntry | undefined;
+    commitRedo(expected: CheckpointEntry): void;
+    restore(done: CheckpointEntry[], undone?: CheckpointEntry[]): void;
+    state(): {
+        done: CheckpointEntry[];
+        undone: CheckpointEntry[];
+    };
+    all(): CheckpointEntry[];
+    first(): CheckpointEntry | undefined;
+    last(): CheckpointEntry | undefined;
+}

package/dist/types/core/commands.d.ts

@@ -0,0 +1,30 @@
+import type { AgentMessage } from "./messages.js";
+export interface CommandContext {
+    args: string;
+    inject: (message: AgentMessage) => void;
+    print: (text: string) => void;
+    getModel: () => string;
+    setModel: (ref: string) => void;
+}
+export interface CommandResult {
+    handled: boolean;
+    message?: string;
+    data?: unknown;
+}
+export interface Command {
+    name: string;
+    description: string;
+    run: (ctx: CommandContext) => CommandResult | void | Promise<CommandResult | void>;
+}
+export declare class CommandRegistry {
+    private commands;
+    register(command: Command): void;
+    get(name: string): Command | undefined;
+    list(): Command[];
+    has(name: string): boolean;
+    parse(input: string): {
+        name: string;
+        args: string;
+    } | undefined;
+    execute(input: string, ctx: Omit<CommandContext, "args">): Promise<CommandResult>;
+}

package/dist/types/core/compaction.d.ts

@@ -0,0 +1,45 @@
+import type { ModelInfo, Provider, StreamOpts, Usage } from "../ai/index.js";
+import type { AgentMessage } from "./messages.js";
+export declare function estimateTokens(messages: AgentMessage[]): number;
+export interface ContextState {
+    tokens: number;
+    limit: number;
+    percent: number;
+}
+export declare function contextState(model: ModelInfo, messages: AgentMessage[], lastUsage?: Usage, estimatedTokensAtLastUsage?: number): ContextState;
+export declare const AUTO_COMPACT_THRESHOLD = 0.85;
+export declare function shouldCompact(state: ContextState, threshold?: number): boolean;
+export interface CompactionRequest {
+    messages: AgentMessage[];
+    keepFromIndex: number;
+    carryover?: unknown;
+}
+export interface CompactionResult {
+    summary: string;
+    carryover?: unknown;
+    keptMessages: AgentMessage[];
+    tokensFreed: number;
+    usage: Usage;
+}
+type CompactionTranscript = Omit<CompactionResult, "usage">;
+export declare class CompactionError extends Error {
+    readonly usage?: Usage | undefined;
+    constructor(message: string, usage?: Usage | undefined);
+}
+export declare function planCompaction(messages: AgentMessage[], keepRatio?: number): {
+    keepFromIndex: number;
+};
+export declare const SUMMARY_PROMPT = "Summarize the conversation so far so that work can continue without the original transcript.\n\nPreserve, in this order:\n1. What the user asked for \u2014 the goal, in their terms, including any constraints they stated.\n2. Decisions taken and why, including approaches tried and rejected.\n3. Current task state: what is done, what is in progress, what remains.\n4. Concrete facts discovered that would be expensive to rediscover (file locations, API shapes, error messages, command invocations that work).\n5. Anything the user corrected you on.\n\nBe specific and factual. Do not include pleasantries or narration. This summary replaces the transcript, so anything you omit is lost.";
+export interface CompactorOptions {
+    provider: Provider;
+    model: ModelInfo;
+    carryoverExtractor?: (messages: AgentMessage[]) => unknown;
+    keepRatio?: number;
+    signal?: AbortSignal;
+    streamOpts?: StreamOpts;
+}
+export declare function compact(messages: AgentMessage[], options: CompactorOptions): Promise<CompactionResult>;
+export declare function applyCompaction(result: CompactionTranscript): AgentMessage[];
+export declare function compactionSummaryMessage(summary: string, carryover?: unknown, timestamp?: number): AgentMessage;
+export declare function formatCarryover(carryover: unknown): string;
+export {};

package/dist/types/core/events.d.ts

@@ -0,0 +1,109 @@
+import type { AssistantMessage, ToolResultContent, ToolResultMessage, Usage } from "../ai/index.js";
+import type { AgentMessage } from "./messages.js";
+import type { PermissionRequest } from "./permission.js";
+export type StreamDelta = {
+    kind: "text_start";
+    contentIndex: number;
+} | {
+    kind: "text_delta";
+    contentIndex: number;
+    text: string;
+} | {
+    kind: "text_end";
+    contentIndex: number;
+} | {
+    kind: "thinking_start";
+    contentIndex: number;
+} | {
+    kind: "thinking_delta";
+    contentIndex: number;
+    text: string;
+} | {
+    kind: "thinking_end";
+    contentIndex: number;
+} | {
+    kind: "toolcall_start";
+    contentIndex: number;
+} | {
+    kind: "toolcall_delta";
+    contentIndex: number;
+    argsFragment: string;
+} | {
+    kind: "toolcall_end";
+    contentIndex: number;
+    toolCallId: string;
+};
+export type AgentEndReason = "done" | "aborted" | "budget" | "maxTurns" | "error";
+export type AgentEvent = {
+    type: "agent_start";
+} | {
+    type: "agent_end";
+    messages: AgentMessage[];
+    reason: AgentEndReason;
+} | {
+    type: "turn_start";
+} | {
+    type: "turn_end";
+    message: AssistantMessage;
+    toolResults: ToolResultMessage[];
+} | {
+    type: "message_start";
+    message: AgentMessage;
+} | {
+    type: "message_update";
+    message: AssistantMessage;
+    delta: StreamDelta;
+} | {
+    type: "message_end";
+    message: AgentMessage;
+} | {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    partial: ToolResultContent[];
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    result: ToolResultMessage;
+} | {
+    type: "permission_asked";
+    request: PermissionRequest;
+} | {
+    type: "permission_resolved";
+    requestId: string;
+    outcome: "allow" | "deny";
+    remembered?: boolean;
+} | {
+    type: "compaction_start";
+    layer: 1 | 2 | 3;
+} | {
+    type: "compaction_end";
+    layer: 1 | 2 | 3;
+    tokensFreed: number;
+    summaryEntryId?: string;
+} | {
+    type: "task_started";
+    taskId: string;
+    command: string;
+    background: boolean;
+} | {
+    type: "task_output";
+    taskId: string;
+    chunk: string;
+} | {
+    type: "task_exited";
+    taskId: string;
+    exitCode: number | null;
+    status?: "exited" | "killed";
+} | {
+    type: "usage_updated";
+    sessionTotals: Usage;
+    contextTokens: number;
+    contextPercent: number;
+};
+export type AgentEventType = AgentEvent["type"];
+export type EventSink = (event: AgentEvent) => void | Promise<void>;