@m8tes/sdk 0.1.0-alpha.1

package/dist/protocol/index.d.cts

@@ -0,0 +1,576 @@
+/**
+ * @m8tes/react — normalized PUBLIC stream event model.
+ *
+ * The m8tes V2 backend emits Claude-native FLAT SSE frames (`content_block_delta`,
+ * `tool_use`, `permission_request`, `done`, ...). The normalizer (`normalizer.ts`)
+ * maps each wire frame to ZERO or MORE events of this stable, versioned
+ * discriminated union, keyed on `type`.
+ *
+ * Type discriminants follow the Vercel AI SDK v5 kebab-case idiom where semantics
+ * align (`text-*`, `reasoning-*`, `tool-input-*`, `tool-output-available`) so a
+ * future `@m8tes/ai-sdk` adapter maps cleanly. They DIVERGE where m8tes semantics
+ * are first-class and have no vanilla-`useChat` analog: human-in-the-loop
+ * `approval-request` / `question`, and run rejoin/replay (`run-start` carries
+ * runId/runUuid; every terminal path is explicit).
+ *
+ * Every event carries:
+ *   - `seq`: a client-assigned monotonic counter. The wire exposes NO SSE `id:`
+ *     and NO per-event sequence number, so this is assigned by the normalizer and
+ *     is NOT a dedupe key (see `normalizer.ts` for the domain-id dedupe strategy).
+ *   - `raw`: the unmodified wire frame, for forward-compatibility.
+ *
+ * Frames that normalize to nothing renderable (`: keep-alive`, `keep-alive`,
+ * `ping`, the duplicate `metadata` preamble frame, `RUNNER_DIAG`, etc.) are
+ * dropped by the normalizer and never enter this union.
+ *
+ * This is a PUBLIC PROTOCOL: once shipped, names are semver-stable. Bump
+ * `PROTOCOL_VERSION` on any breaking change to the shape.
+ */
+declare const PROTOCOL_VERSION: "m8tes.stream.v2";
+type ProtocolVersion = typeof PROTOCOL_VERSION;
+/** Tool/approval state machine (superset of AI SDK v5 tool-part states + HITL). */
+type ToolState = "input-streaming" | "input-available" | "awaiting-approval" | "output-available" | "output-error" | "denied";
+/** Coarse run status surfaced to the UI. */
+type RunStatus = "connecting" | "running" | "awaiting_approval" | "awaiting_input" | "complete" | "incomplete" | "error" | "cancelled";
+interface BaseEvent {
+    type: string;
+    /** Client-assigned, monotonic per stream. There is NO wire sequence id. */
+    seq: number;
+    /** The unmodified wire frame this event was normalized from. */
+    raw: Record<string, unknown>;
+}
+/** From the first `metadata` frame. Re-applied (idempotently) on every rejoin. */
+interface RunStartEvent extends BaseEvent {
+    type: "run-start";
+    protocolVersion: ProtocolVersion;
+    runId: number | null;
+    runUuid: string | null;
+    mode: "task" | "chat";
+    agentName?: string;
+    instanceId?: number;
+    taskId?: number;
+    status?: string;
+    sandbox?: {
+        id: string | null;
+        enabled: boolean;
+    };
+}
+/** Coarse status transitions (sandbox connect, metadata.status, pause entry). */
+interface RunStatusEvent extends BaseEvent {
+    type: "run-status";
+    status: RunStatus;
+    message?: string;
+    sandboxId?: string | null;
+    durationMs?: number;
+}
+/** From `run_metrics`. */
+interface RunMetricsEvent extends BaseEvent {
+    type: "run-metrics";
+    model: string;
+    executionTimeMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number | null;
+    sdkCostUsd: number | null;
+    stopReason: string | null;
+    completionState: string;
+    unresolvedToolUseIds: string[];
+    messageCount: number;
+    /** present only when completionState !== "complete" */
+    diagnostics?: Record<string, unknown>;
+}
+/** Terminal success path. From `done`. completionState !== "complete" => incomplete run. */
+interface RunFinishEvent extends BaseEvent {
+    type: "run-finish";
+    status: "complete" | "incomplete";
+    completionState: string;
+    unresolvedToolUseIds: string[];
+    stopReason: string | null;
+    terminalCompletionSeen: boolean;
+    messageCount: number;
+}
+/** Structured failure codes carried on the wire as a dedicated `type`. */
+type RunErrorCode = "SANDBOX_BOOT_TIMEOUT" | "SANDBOX_QUOTA_EXHAUSTED" | "SANDBOX_UNAVAILABLE" | "SNAPSHOT_VERSION_MISMATCH" | "AGENT_RUNNER_DIED" | "RUNNER_LIFECYCLE_ERROR";
+/** Terminal failure path. From `error`, `sdk_error`, `AGENT_RUNNER_DIED`, SANDBOX_*, SNAPSHOT_VERSION_MISMATCH. */
+interface RunErrorEvent extends BaseEvent {
+    type: "run-error";
+    error: string;
+    message: string;
+    /** structured failure code when the wire type was a coded failure, else null */
+    code: RunErrorCode | null;
+    fatal: true;
+    /** HTTP status when the failure was an API (non-stream) error, e.g. 402/429 */
+    apiStatus?: number;
+    /** v2 envelope `error.details` — carries machine codes like
+     *  `error_code: "END_USER_RATE_LIMITED"` plus `retry_after`/`period_end` */
+    apiDetails?: Record<string, unknown>;
+}
+/** Terminal cancellation. From `cancelled`. */
+interface RunCancelledEvent extends BaseEvent {
+    type: "run-cancelled";
+    runId?: number | null;
+}
+interface MessageStartEvent extends BaseEvent {
+    type: "message-start";
+    messageId: string;
+    role: "assistant";
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+/** From `message_stop` or `message_complete`. */
+interface MessageEndEvent extends BaseEvent {
+    type: "message-end";
+    messageId: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+interface TextStartEvent extends BaseEvent {
+    type: "text-start";
+    id: string;
+    messageId: string;
+}
+interface TextDeltaEvent extends BaseEvent {
+    type: "text-delta";
+    id: string;
+    delta: string;
+    messageId: string;
+}
+interface TextEndEvent extends BaseEvent {
+    type: "text-end";
+    id: string;
+    messageId: string;
+}
+interface ReasoningStartEvent extends BaseEvent {
+    type: "reasoning-start";
+    id: string;
+    messageId: string;
+}
+interface ReasoningDeltaEvent extends BaseEvent {
+    type: "reasoning-delta";
+    id: string;
+    delta: string;
+    messageId: string;
+}
+interface ReasoningEndEvent extends BaseEvent {
+    type: "reasoning-end";
+    id: string;
+    messageId: string;
+}
+interface PlanStartEvent extends BaseEvent {
+    type: "plan-start";
+    id: string;
+    messageId: string;
+}
+interface PlanDeltaEvent extends BaseEvent {
+    type: "plan-delta";
+    id: string;
+    delta: string;
+    messageId: string;
+}
+interface PlanEndEvent extends BaseEvent {
+    type: "plan-end";
+    id: string;
+    messageId: string;
+}
+interface ToolInputStartEvent extends BaseEvent {
+    type: "tool-input-start";
+    toolCallId: string;
+    toolName: string;
+    messageId: string;
+    state: "input-streaming";
+}
+interface ToolInputDeltaEvent extends BaseEvent {
+    type: "tool-input-delta";
+    toolCallId: string;
+    inputTextDelta: string;
+    state: "input-streaming";
+}
+interface ToolInputAvailableEvent extends BaseEvent {
+    type: "tool-input-available";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    state: "input-available";
+}
+interface ToolOutputAvailableEvent extends BaseEvent {
+    type: "tool-output-available";
+    toolCallId: string;
+    output: unknown;
+    isError: boolean;
+    state: "output-available" | "output-error";
+}
+/** Tool approval gate. From `awaiting_approval` (toolName !== "AskUserQuestion") or `permission_request`. */
+interface ApprovalRequestEvent extends BaseEvent {
+    type: "approval-request";
+    requestId: string;
+    toolCallId?: string;
+    toolName: string;
+    toolInput: unknown;
+    timeoutSeconds: number;
+}
+/** Derived on resume / from the answer round-trip; surfaced for state reconciliation. */
+interface ApprovalResolvedEvent extends BaseEvent {
+    type: "approval-resolved";
+    requestId: string;
+    resolved: "approved" | "denied";
+}
+/** AskUserQuestion gate. From `awaiting_approval` where toolName === "AskUserQuestion". */
+interface QuestionOption {
+    label: string;
+    description?: string;
+}
+interface QuestionItem {
+    question: string;
+    /** Real wire options are `{label, description}` objects; the normalizer also
+     *  coerces bare-string options into `{label}` defensively. */
+    options?: QuestionOption[];
+    [k: string]: unknown;
+}
+interface QuestionEvent extends BaseEvent {
+    type: "question";
+    requestId: string;
+    toolCallId: string;
+    questions: QuestionItem[];
+    timeoutSeconds: number;
+}
+/** From `sandbox-connecting` / `sandbox-connected`. (Fatal sandbox failures => RunErrorEvent with `code`.) */
+interface SandboxStatusEvent extends BaseEvent {
+    type: "sandbox-status";
+    phase: "connecting" | "connected";
+    message: string;
+    runId: number | null;
+    sandboxId?: string | null;
+    durationMs?: number;
+}
+/** Non-fatal diagnostics: stderr, mcp_error/mcp_auth_failed (warning), rate_limit, system_message. */
+interface NoticeEvent extends BaseEvent {
+    type: "notice";
+    level: "info" | "warning";
+    source: "stderr" | "mcp" | "rate_limit" | "system";
+    message: string;
+    detail?: string;
+}
+/** From `compact_boundary`: the SDK summarized the conversation history. */
+interface CompactBoundaryEvent extends BaseEvent {
+    type: "compact-boundary";
+    trigger: "manual" | "auto";
+    preTokens: number;
+}
+/**
+ * Any wire type with no normalized mapping (`sdk_content_snapshot`, `user_message`,
+ * `compact_boundary`, and future/unknown types). `raw` is preserved so consumers
+ * and a newer normalizer can recover the original. Forward-compat: a new backend
+ * event surfaces here instead of crashing.
+ */
+interface UnknownEvent extends BaseEvent {
+    type: "unknown";
+    wireType: string;
+}
+type M8tesStreamEvent = RunStartEvent | RunStatusEvent | RunMetricsEvent | RunFinishEvent | RunErrorEvent | RunCancelledEvent | MessageStartEvent | MessageEndEvent | TextStartEvent | TextDeltaEvent | TextEndEvent | ReasoningStartEvent | ReasoningDeltaEvent | ReasoningEndEvent | PlanStartEvent | PlanDeltaEvent | PlanEndEvent | ToolInputStartEvent | ToolInputDeltaEvent | ToolInputAvailableEvent | ToolOutputAvailableEvent | ApprovalRequestEvent | ApprovalResolvedEvent | QuestionEvent | SandboxStatusEvent | NoticeEvent | CompactBoundaryEvent | UnknownEvent;
+type M8tesStreamEventType = M8tesStreamEvent["type"];
+/** Terminal events end a stream. */
+declare const TERMINAL_EVENT_TYPES: readonly ["run-finish", "run-error", "run-cancelled"];
+type TerminalEventType = (typeof TERMINAL_EVENT_TYPES)[number];
+/** True for the three terminal event types. */
+declare function isTerminalEvent(event: M8tesStreamEvent): event is RunFinishEvent | RunErrorEvent | RunCancelledEvent;
+
+/**
+ * SSE wire decoder: raw bytes/text -> wire frame objects.
+ *
+ * Layer 1 of the pipeline (Layer 2 is `normalizer.ts`). This module ONLY knows
+ * the SSE envelope + JSON, never the m8tes event semantics.
+ *
+ *   chunk(s)  ─push─►  [ frame split on blank line ]  ─►  [ data: lines ]
+ *             ─►  [ concatenated-JSON split ]  ─►  JSON.parse  ─►  wire object
+ *
+ * Wire facts it handles (from the streaming contract):
+ *  - Frames are separated by a blank line; `\r\n` is normalized to `\n`.
+ *  - A line starting with `:` is an SSE comment (keepalive) — ignored.
+ *  - A frame may carry one or more `data:` lines (joined with `\n` per spec).
+ *  - A single `data:` payload may glue MULTIPLE complete JSON objects together
+ *    (observed in the app stream); they are split with a string-aware brace
+ *    scanner — NOT a naive `}{` regex, which breaks on braces inside strings.
+ *  - Invalid JSON in a completed frame is DROPPED (reported via `onMalformed`),
+ *    never thrown — a corrupt frame must not kill the stream (contract §7).
+ */
+interface SseParserOptions {
+    /**
+     * Called for each `data:` payload (or split piece) that fails to parse as JSON.
+     * Default: no-op. Wire this to telemetry; do NOT throw from it.
+     */
+    onMalformed?: (rawPayload: string, error: unknown) => void;
+}
+type WireFrame$1 = Record<string, unknown>;
+/** Split a payload into top-level JSON object/array substrings, string-aware. */
+declare function splitConcatenatedJson(payload: string): string[];
+/**
+ * Stateful streaming decoder. Feed it response-body chunks (any size, split
+ * mid-frame); it returns the wire frames completed by each chunk. Call `flush()`
+ * once the stream ends to drain a trailing frame that had no closing blank line.
+ */
+declare function createSseDecoder(opts?: SseParserOptions): {
+    /** Feed a chunk; returns the wire frames it completed. */
+    push(chunk: string): WireFrame$1[];
+    /** Flush a trailing unterminated frame at end-of-stream. */
+    flush(): WireFrame$1[];
+};
+/** Convenience: parse a whole SSE string into wire frames (used by fixtures/tests). */
+declare function parseSse(text: string, opts?: SseParserOptions): WireFrame$1[];
+
+/**
+ * Normalizer: wire frames -> public M8tesStreamEvent[].
+ *
+ * Layer 2 of the pipeline (Layer 1 = `sse-parser.ts`). Each wire frame maps to
+ * ZERO or MORE public events. The normalizer owns:
+ *   - `seq`: a monotonic counter stamped on every emitted event (no wire seq id).
+ *   - dedupe: a domain-id `open`/`seen` ledger so a `/stream` rejoin that
+ *     re-streams blocks + re-sends a message_snapshot + re-sends a pending
+ *     permission_request renders EXACTLY ONCE (streaming contract §dedupeStrategy).
+ *
+ * One normalizer instance is kept ALIVE across a reconnect (the hook reuses it),
+ * so `seen` persists and replayed content is dropped. Idempotent-apply rules:
+ *   - START events: skip if the key is already open or seen.
+ *   - DELTA events: drop if the key is in `seen` (finalized) — a replayed delta
+ *     for a closed block. A bare key not yet seen is lazily opened (tolerates a
+ *     trimmed replay prefix).
+ *   - END / result / terminal / approval events: finalize, move key to `seen`;
+ *     a second occurrence is a no-op.
+ *
+ * Unknown/unmapped wire types pass through as `UnknownEvent` (never throw).
+ */
+
+type WireFrame = Record<string, unknown>;
+interface Normalizer {
+    /** Map one wire frame to zero+ public events (seq-stamped, in order). */
+    push(frame: WireFrame): M8tesStreamEvent[];
+    /** Discard all dedupe/lifecycle state (e.g. starting a brand-new run). */
+    reset(): void;
+}
+declare function createNormalizer(): Normalizer;
+
+/**
+ * Accumulator: the normalized event stream -> renderable conversation state.
+ *
+ * Pure + immutable (new state object on every change) so React can re-render via
+ * useState/useSyncExternalStore. Framework-agnostic — `useMate` wraps it. It
+ * assumes the normalizer has already deduped (so each event is "new"); it only
+ * folds events into messages/parts + run status + pending HITL.
+ *
+ * Lazy creation: a `text-delta`/`tool-*` with no preceding start (a trimmed
+ * replay prefix) lazily creates its message/part, so a partial rejoin still
+ * renders rather than dropping content.
+ */
+
+type TextLikeKind = "text" | "reasoning" | "plan";
+interface TextPart {
+    kind: TextLikeKind;
+    id: string;
+    text: string;
+}
+interface ToolPart {
+    kind: "tool";
+    toolCallId: string;
+    toolName: string;
+    state: ToolState;
+    inputText: string;
+    input?: unknown;
+    output?: unknown;
+    isError?: boolean;
+}
+/** Non-fatal diagnostics rendered as a quiet inline row (mcp auth failures,
+ *  rate limits) — the platform surfaces these; silence hides real failures. */
+interface NoticePart {
+    kind: "notice";
+    id: string;
+    level: "info" | "warning";
+    source: string;
+    message: string;
+}
+/** Sandbox lifecycle pill ("connecting to environment" -> "environment ready"). */
+interface SandboxPart {
+    kind: "sandbox";
+    id: string;
+    phase: "connecting" | "connected";
+    durationMs?: number;
+}
+/** Conversation-summarized divider (SDK auto/manual compaction). */
+interface CompactPart {
+    kind: "compact";
+    id: string;
+    trigger: "manual" | "auto";
+    preTokens: number;
+}
+type MatePart = TextPart | ToolPart | NoticePart | SandboxPart | CompactPart;
+interface MateMessage {
+    id: string;
+    role: "assistant" | "user";
+    parts: MatePart[];
+}
+type MateStatus = "idle" | RunStatus;
+interface ConversationState {
+    runId: number | null;
+    runUuid: string | null;
+    agentName: string | null;
+    status: MateStatus;
+    messages: MateMessage[];
+    pendingApproval: ApprovalRequestEvent | null;
+    pendingQuestion: QuestionEvent | null;
+    /** From run-metrics: "refusal" | "max_tokens" render a quiet outcome row
+     *  ("Request declined" / "Response truncated"); anything else is null. */
+    finishStopReason: "refusal" | "max_tokens" | null;
+    error: {
+        message: string;
+        code: string | null;
+        /** HTTP status for API errors (402 limit / 429 rate) */
+        apiStatus?: number;
+        /** v2 `error.details` (machine `error_code`, `retry_after`, `period_end`, ...) */
+        apiDetails?: Record<string, unknown>;
+    } | null;
+}
+declare const initialConversationState: ConversationState;
+declare function accumulate(state: ConversationState, e: M8tesStreamEvent): ConversationState;
+/** Stateful convenience wrapper for the hook (holds the running snapshot). */
+interface Accumulator {
+    readonly state: ConversationState;
+    apply(event: M8tesStreamEvent): ConversationState;
+    /** Optimistically append the user's own message (shown immediately on send). */
+    addUserMessage(text: string): ConversationState;
+    reset(): void;
+}
+declare function createAccumulator(): Accumulator;
+
+/**
+ * Typed error hierarchy for the m8tes V2 API — ONE implementation shared by
+ * `@m8tes/sdk` (API-key client) and `@m8tes/react` (browser proxy client).
+ *
+ * Mirrors the Python SDK's `sdk/py/m8tes/_exceptions.py` so the two languages
+ * behave identically: same status→class map, same `docUrl`/`errorCode`/
+ * `retryAfter`/`details` fields, just camelCase.
+ *
+ * The wire envelope is standardized across every /api/v2 route
+ * (`fastapi/app/routers/v2/_errors.py`):
+ *
+ *   { "error": { "message", "type", "code", "request_id", "doc_url",
+ *                "details": { "error_code": "...", ...context } } }
+ *
+ * Note `error.code` is the int HTTP status by design; the machine-readable app
+ * code (e.g. "RUN_LIMIT_REACHED", "END_USER_RATE_LIMITED") lives at
+ * `error.details.error_code` and is surfaced here as `errorCode`.
+ *
+ * No auth and no `node:` imports live in this file — it ships in browser
+ * bundles via `@m8tes/sdk/protocol`.
+ */
+interface ApiErrorFields {
+    /** Envelope `error.type`, e.g. "authentication_error". */
+    type: string;
+    /** Envelope `error.code` — the int HTTP status (kept for wire fidelity). */
+    code: number;
+    /** HTTP status of the response. */
+    status: number;
+    /** `error.request_id`, else the `x-request-id` response header. Quote this in bug reports. */
+    requestId?: string;
+    /** Full `error.details` object: actionable context (runs_used, period_end, ...). */
+    details?: unknown;
+    /** `error.doc_url` — docs deep link for this error type. */
+    docUrl?: string;
+    /** `error.details.error_code` — machine-readable app code for branching. */
+    errorCode?: string;
+    /** Seconds from the `Retry-After` header. Set on 429; undefined when absent or an HTTP-date. */
+    retryAfter?: number;
+}
+/** Base class for every API error. Catch this to catch them all. */
+declare class M8tesApiError extends Error {
+    readonly type: string;
+    readonly code: number;
+    readonly status: number;
+    readonly requestId?: string;
+    readonly details?: unknown;
+    readonly docUrl?: string;
+    readonly errorCode?: string;
+    readonly retryAfter?: number;
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 400 or 422 — invalid request. Check `.status` to tell them apart. */
+declare class ValidationError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 401 — missing, malformed, or revoked API key. */
+declare class AuthenticationError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 402 — billing limit reached or subscription issue. `.details` carries the caps. */
+declare class BillingError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 403 — authenticated but not allowed. */
+declare class PermissionDeniedError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 404 — no such resource, or it belongs to another account/end-user. */
+declare class NotFoundError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 409 — conflicting state. */
+declare class ConflictError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/**
+ * 409 from `GET /runs/{id}/stream` — the run is no longer executing, so there is
+ * nothing to join. The caller should fall back to `runs.get(id)` for the final
+ * result rather than treating this as a failure.
+ */
+declare class RunNotStreamingError extends ConflictError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 429 — too many requests. Honour `.retryAfter` before retrying. */
+declare class RateLimitError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** 500+ — server-side error. Safe to retry idempotent requests. */
+declare class APIError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/**
+ * A stream completed but emitted error events (expired credential, provider rate
+ * limit, quota exhaustion). Raised so a failed run is never mistaken for a
+ * successful empty one. `.details.errors` holds the raw messages.
+ */
+declare class RunFailedError extends M8tesApiError {
+    constructor(message: string, f: ApiErrorFields);
+}
+/** `Retry-After` in seconds. An HTTP-date (or garbage) yields undefined, matching Python. */
+declare function parseRetryAfter(raw: string | null | undefined): number | undefined;
+/**
+ * Pull the standardized envelope out of a parsed error body.
+ *
+ * Tolerant by design: a proxy, a CDN, or a non-v2 route can return HTML, an
+ * empty body, or a bare `{detail: ...}`, and callers still get a usable error
+ * with the right status rather than a SyntaxError.
+ */
+declare function parseErrorEnvelope(status: number, body: unknown, headers?: {
+    get(name: string): string | null;
+}): {
+    message: string;
+    fields: ApiErrorFields;
+};
+interface ErrorFromResponseOptions {
+    /**
+     * Map 409 to `RunNotStreamingError` (the "run already finished, fall back to
+     * runs.get()" signal) instead of the generic `ConflictError`. Set on stream
+     * requests, where 409 has exactly that meaning.
+     */
+    conflictIsNotStreaming?: boolean;
+}
+/** The error class a status maps to. Exported so clients that build their own
+ *  message (e.g. the SDK's base-URL diagnostics) still get the right type. */
+declare function errorClassForStatus(status: number, opts?: ErrorFromResponseOptions): new (message: string, f: ApiErrorFields) => M8tesApiError;
+/**
+ * Build the right typed error from a non-OK `Response`. Consumes the body.
+ */
+declare function errorFromResponse(res: Response, opts?: ErrorFromResponseOptions): Promise<M8tesApiError>;
+
+export { APIError, type Accumulator, type ApiErrorFields, type ApprovalRequestEvent, type ApprovalResolvedEvent, AuthenticationError, type BaseEvent, BillingError, type CompactBoundaryEvent, type CompactPart, ConflictError, type ConversationState, type ErrorFromResponseOptions, M8tesApiError, type M8tesStreamEvent, type M8tesStreamEventType, type MateMessage, type MatePart, type MateStatus, type MessageEndEvent, type MessageStartEvent, type Normalizer, NotFoundError, type NoticeEvent, type NoticePart, PROTOCOL_VERSION, PermissionDeniedError, type PlanDeltaEvent, type PlanEndEvent, type PlanStartEvent, type ProtocolVersion, type QuestionEvent, type QuestionItem, type QuestionOption, RateLimitError, type ReasoningDeltaEvent, type ReasoningEndEvent, type ReasoningStartEvent, type RunCancelledEvent, type RunErrorCode, type RunErrorEvent, RunFailedError, type RunFinishEvent, type RunMetricsEvent, RunNotStreamingError, type RunStartEvent, type RunStatus, type RunStatusEvent, type SandboxPart, type SandboxStatusEvent, type SseParserOptions, TERMINAL_EVENT_TYPES, type TerminalEventType, type TextDeltaEvent, type TextEndEvent, type TextLikeKind, type TextPart, type TextStartEvent, type ToolInputAvailableEvent, type ToolInputDeltaEvent, type ToolInputStartEvent, type ToolOutputAvailableEvent, type ToolPart, type ToolState, type UnknownEvent, ValidationError, accumulate, createAccumulator, createNormalizer, createSseDecoder, errorClassForStatus, errorFromResponse, initialConversationState, isTerminalEvent, parseErrorEnvelope, parseRetryAfter, parseSse, splitConcatenatedJson };