@sayknow-cli/coding-agent 0.4.7 → 0.5.1

package/dist/types/sdk/bus/topic-registry.d.ts

@@ -38,8 +38,22 @@ export interface TopicRecord {
     replaySeq?: number;
     /** Serialized authority epoch; a late create may commit only in its starting epoch. */
     authorityEpoch?: number;
+    /** Immutable authority epoch held when this remote topic create began. */
+    creationLeaseEpoch?: number;
     /** An uncertain delete fences future creation and inbound routing. */
     authorityState?: "active" | "delete_pending";
+    /** Telegram chat and endpoint authority last proven to use this topic. */
+    chatId?: string;
+    /** Canonical endpoint tuple (URL + token) that currently holds the lease. */
+    endpointKey?: string;
+    /** Authenticated endpoint authority digest, excluding transport presentation. */
+    endpointDigest?: string;
+    /** SDK event generation associated with the current endpoint lease. */
+    endpointGeneration?: number;
+    /** Monotonic authenticated endpoint handoffs; legacy bindings begin at zero. */
+    endpointIncarnation?: number;
+    /** True when persisted binding fields were present but malformed; recovery must fail closed. */
+    bindingMalformed?: true;
 }
 /** Serialisable shape persisted to disk. */
 export interface TopicRegistryState {
@@ -47,6 +61,34 @@ export interface TopicRegistryState {
     topics: Record<string, TopicRecord>;
     /** Durable deletion epochs retained after a definite delete. */
     fences?: Record<string, number>;
+    /** Closed transport endpoint leases; unchanged endpoint discovery remains fenced across restart. */
+    closedEndpoints?: Record<string, TopicEndpointBinding>;
+}
+/** Authenticated runtime binding for a durable topic lease. */
+export interface TopicEndpointBinding {
+    chatId: string;
+    endpointKey: string;
+    endpointDigest: string;
+    endpointGeneration?: number;
+}
+/** Discriminated durable endpoint authority for identity-less replay admission. */
+export type TopicEndpointAuthority = {
+    state: "none";
+} | {
+    state: "unique";
+    sessionId: string;
+} | {
+    state: "ambiguous";
+};
+/** Conditional rollback token for a delete fence publication. */
+export interface TopicDeleteAuthoritySnapshot {
+    sessionId: string;
+    topicId?: string;
+    authorityEpoch?: number;
+    authorityState?: TopicRecord["authorityState"];
+    fenceEpoch?: number;
+    /** Exact fenced record, retained to restore an in-memory tombstone after a failed clear publication. */
+    record?: TopicRecord;
 }
 export declare function emptyTopicRegistryState(): TopicRegistryState;
 /**
@@ -61,9 +103,17 @@ export declare class TopicRegistry {
     private readonly byTopic;
     /** In-flight create promises, keyed by session, to dedupe concurrent creates. */
     private readonly inflight;
+    /** Newly-created records being durably published; never routable until committed. */
+    private readonly staged;
+    /** Socket-specific provenance for transient endpoint claims. */
+    private readonly transientClaimants;
+    /** Endpoint claims registered before a remote topic create can publish a record. */
+    private readonly creatingBindings;
     /** Monotonic authority epochs, including deletion fences for absent records. */
     private readonly epochs;
     constructor(state?: TopicRegistryState);
+    /** Replace all runtime state after a successfully persisted staged publication. */
+    replace(state: TopicRegistryState): void;
     /** Merge serialized state and normalize authority fields from older releases. */
     load(state: TopicRegistryState): void;
     private rebuildInboundRoutes;
@@ -71,13 +121,39 @@ export declare class TopicRegistry {
     sessionForTopic(topicId: string): string | undefined;
     /** All session ids with a persisted topic record. */
     sessionIds(): string[];
+    /** Persisted remote deletes that must be reconciled before recovery can proceed. */
+    deletePendingSessionIds(): string[];
     /** The existing topic record for a session, if any. */
     get(sessionId: string): TopicRecord | undefined;
+    /** Current immutable authority epoch for a creation lease. */
+    authorityEpoch(sessionId: string): number;
+    /** Whether this session has an active, unambiguous topic authority. */
+    isActiveUnambiguous(sessionId: string): boolean;
+    /**
+     * Resolve endpoint authority for identity-less replay. An endpoint may bootstrap
+     * only when no committed, staged, or pre-create claim can own it; malformed
+     * partial bindings and deletion fences deliberately fail closed.
+     */
+    endpointAuthority(binding: TopicEndpointBinding, excludedTransientClaimant?: object): TopicEndpointAuthority;
+    /** Resolve a uniquely bound logical owner for callers that only need the owner. */
+    uniqueSessionForEndpoint(binding: TopicEndpointBinding): string | undefined;
+    /** Whether this exact session owns the complete durable endpoint binding. */
+    matchesEndpoint(sessionId: string, binding: TopicEndpointBinding): boolean;
+    /**
+     * Rebind an existing topic to an authenticated successor endpoint. The exact
+     * logical session id is proved by replay before this method is called. A
+     * rotated credential may replace only an inactive incumbent; concurrent
+     * incumbents, cross-chat records, malformed evidence, collisions, and delete
+     * fences remain fail-closed.
+     */
+    bindEndpoint(sessionId: string, binding: TopicEndpointBinding, activeEndpointKeys?: ReadonlySet<string>, allowEndpointRotation?: boolean): "bound" | "unchanged" | "rejected";
+    /** Undo a failed durable endpoint migration without disturbing concurrent metadata writers. */
+    restoreEndpointBinding(sessionId: string, expected: TopicEndpointBinding, previous: Pick<TopicRecord, "chatId" | "endpointKey" | "endpointDigest" | "endpointGeneration" | "endpointIncarnation">): boolean;
     /**
      * Return the existing active topic for `sessionId`, or create one via
      * `create` (called only on first use).
      */
-    getOrCreateTopic(sessionId: string, create: () => Promise<unknown>, now?: () => number, name?: string): Promise<TopicRecord>;
+    getOrCreateTopic(sessionId: string, create: () => Promise<unknown>, now?: () => number, name?: string, binding?: TopicEndpointBinding, commit?: () => Promise<void>, transientClaimant?: object): Promise<TopicRecord>;
     /** Mark the identity header as sent for a session. Idempotent. */
     markIdentitySent(sessionId: string): void;
     /** Whether the identity header still needs sending for this session. */
@@ -109,14 +185,24 @@ export declare class TopicRegistry {
     markUserNamePending(sessionId: string, name: string): boolean;
     /** Commit a successfully-applied daemon topic title. */
     markNameApplied(sessionId: string, name: string): void;
+    /** Capture only authority fields that a failed delete publication may restore. */
+    captureDeleteAuthority(sessionId: string): TopicDeleteAuthoritySnapshot;
+    /** Restore a failed delete fence only while its exact authority mutation remains current. */
+    restoreDeleteAuthority(snapshot: TopicDeleteAuthoritySnapshot): boolean;
+    /** Restore the exact delete fence after a failed compensation publication. */
+    restoreDeleteFence(snapshot: TopicDeleteAuthoritySnapshot): boolean;
     /** Fence new work before the remote delete starts, including an absent in-flight create. */
     beginDelete(sessionId: string): TopicRecord | undefined;
+    /** Retain an accepted create as deletion-fenced before remote compensation can begin. */
+    fenceAcceptedCreate(sessionId: string, topicId: string, now?: () => number, name?: string, binding?: TopicEndpointBinding): TopicRecord;
+    /** Fence an accepted create only when its exact creator lease still owns the record. */
+    fenceAcceptedCreateForLease(sessionId: string, topicId: string, creationLeaseEpoch: number, now?: () => number, name?: string, binding?: TopicEndpointBinding): TopicRecord | undefined;
     /** Wait for a revoked create to settle before admitting a later lifecycle epoch. */
     awaitInflight(sessionId: string): Promise<void>;
     /** Remove only after a definite remote deletion; ambiguity deliberately retains its fence. */
     settleDelete(sessionId: string, topicId: string): boolean;
     /** Remove a topic record immediately for local/test cleanup compatibility. */
     delete(sessionId: string): boolean;
-    /** Serialise for atomic persistence beside the daemon state. */
+    /** Serialise active records plus unpublished staged creates for atomic commit. */
     serialize(): TopicRegistryState;
 }

package/dist/types/sdk/client/discovery.d.ts

@@ -3,6 +3,8 @@ export interface SdkSessionEndpoint {
     sessionId: string;
     url: string;
     token: string;
+    pid?: number;
+    stale?: boolean;
     path: string;
 }
 export interface SdkDiscoveryWarning {

package/dist/types/sdk/client/liveness.d.ts

@@ -0,0 +1,7 @@
+import type { SdkSessionEndpoint } from "./discovery";
+export type SdkEndpointLiveness = "live" | "stale" | "dead" | "unknown";
+export interface SdkEndpointSelectionError {
+    code: "endpoint_stale" | "endpoint_dead" | "endpoint_unknown" | "no_live_endpoint" | "multiple_live_endpoints" | "not_found";
+}
+export declare function classifyEndpoint(endpoint: SdkSessionEndpoint): SdkEndpointLiveness;
+export declare function selectLiveEndpoint(records: readonly SdkSessionEndpoint[], explicitSessionId?: string): SdkSessionEndpoint | SdkEndpointSelectionError;

package/dist/types/sdk/host/control/operations.d.ts

@@ -5,7 +5,7 @@ export type ControlInput = Record<string, unknown>;
  * AgentSession and its controllers without exposing those concrete types here.
  */
 export interface ControlSurface {
-    prompt(text: string, images?: ControlValue): Promise<ControlValue> | ControlValue;
+    prompt(text: string, images?: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     steer(text: string): Promise<ControlValue> | ControlValue;
     followUp(text: string): Promise<ControlValue> | ControlValue;
     abort(): Promise<ControlValue> | ControlValue;
@@ -13,11 +13,12 @@ export interface ControlSurface {
     answerAsk(id: string, answer: ControlValue): Promise<ControlValue> | ControlValue;
     answerGate(id: string, response: ControlValue, expectedSessionId?: string, idempotencyKey?: string): Promise<ControlValue> | ControlValue;
     approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
-    invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
+    invokeSkill(name: string, args: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
     operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;
     replaceTodo(items: ControlValue): Promise<ControlValue> | ControlValue;
     setModel(id: string, thinkingLevel?: ControlValue): Promise<ControlValue> | ControlValue;
+    setModelProfile(id: string): Promise<ControlValue> | ControlValue;
     cycleModel(): Promise<ControlValue> | ControlValue;
     setThinking(level: ControlValue): Promise<ControlValue> | ControlValue;
     cycleThinking(): Promise<ControlValue> | ControlValue;

package/dist/types/sdk/host/host.d.ts

@@ -7,13 +7,15 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
     query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
     /** Best-effort diagnostic observation of accepted control/query frames. */
     onRequest?: SdkRequestObserver;
+    /** Runs before a control response is sent; identity transitions use sendTerminal. */
+    beforeControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame, sendTerminal: () => Promise<void>) => void | Promise<void>;
     /** Runs only after a successful control response has been sent to the client. */
     afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
     installProviderDefinitions?: (capability: string, definitions: unknown) => void;
     onProviderDefinitionsRemoved?: (capability: string) => void;
     onReverseCancel?: (requestId: string, reason: "provider_disconnected" | "lease_released") => void;
     /** Best-effort capabilities mirrored from the native transport for out-of-band consumers. */
-    connectionCapabilities?: (connectionId: string) => ReadonlySet<string>;
+    connectionCapabilities?: (connectionId: string) => ReadonlySet<string> | undefined;
 }
 /** SDK hosting is independent of notification configuration. Only root sessions host an endpoint. */
 export declare function shouldHostSdk(_settings: unknown, isTopLevel: boolean, env?: NodeJS.ProcessEnv): boolean;

package/dist/types/sdk/host/query/handlers.d.ts

@@ -31,6 +31,19 @@ export interface SessionSurface {
         totalBytes: number;
     } | undefined>;
     getJobs(): unknown | Promise<unknown>;
+    /** Q26 keyed lookup of a submitted prompt's authoritative reconciliation status. */
+    getPromptStatus?(selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): unknown | Promise<unknown>;
+    getSkillInvokeStatus?(selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): unknown | Promise<unknown>;
+    /** Q27 effective model-profile catalog from the live session registry. */
+    getModelProfiles?(): unknown[] | Promise<unknown[]>;
     /** Query rows backed by the session's installed binding map. */
     installedQueries?: ReadonlySet<string>;
 }
@@ -57,6 +70,7 @@ export interface QueryResponse {
         code: string;
         message: string;
         restartQuery?: boolean;
+        details?: unknown;
     };
 }
 export declare class QueryHandlers {

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

@@ -1,7 +1,9 @@
+export { MODEL_PROFILE_DISCOVERY_QUERY, MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES, type ModelProfileCatalogItem, type ModelProfileErrorCode, type ModelProfileErrorDetails, ModelProfileRegistryError, type ModelProfileRegistryErrorDetails, type UnknownModelProfileDetails, UnknownModelProfileError, } from "../config/model-profile-contract";
 export * as bus from "./bus";
 export * from "./client";
 export * as host from "./host";
 export * as mcp from "./mcp";
 export type { Q10CurrentThinkingLevel, Q10Model, Q10SettableThinkingLevel, Q10ThinkingCapabilities, Q10ThinkingEffort, Q10ThinkingMode, } from "./models";
+export * from "./prompt-status";
 export * from "./session";
 export * from "./session-directory";

package/dist/types/sdk/lifecycle-session.d.ts

@@ -10,5 +10,14 @@ export type CreateLifecycleAgentSessionResult = {
     rollback: SdkStartupRollbackTracker;
     failure: SdkStartupFailure;
 };
+/** Options accepted by lifecycle-only session construction. */
+export type CreateLifecycleAgentSessionOptions = CreateAgentSessionOptions & {
+    /**
+     * Startup budget for ACP lifecycle MCP launches, in milliseconds. Set only
+     * when the lifecycle request supplies `mcpServers`; ordinary consumers keep
+     * the manager's short default ceiling.
+     */
+    mcpStartupTimeoutMs?: number;
+};
 /** Internal lifecycle-only session construction with an owner-bound SDK startup result. */
-export declare function createLifecycleAgentSession(options?: CreateAgentSessionOptions): Promise<CreateLifecycleAgentSessionResult>;
+export declare function createLifecycleAgentSession(options?: CreateLifecycleAgentSessionOptions): Promise<CreateLifecycleAgentSessionResult>;

package/dist/types/sdk/prompt-status.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Public DTO contract for Q26 `turn.prompt_status` and the `clientRef`
+ * correlation field on `turn.prompt`.
+ *
+ * Semantics:
+ * - `turn.prompt` remains ordered and non-idempotent. An envelope
+ *   `idempotencyKey` is ignored for replay/conflict purposes on ordered
+ *   operations (no replay cache, no `idempotency_conflict`).
+ * - `clientRef` is a caller-chosen correlation key (trimmed, non-empty,
+ *   1..PROMPT_CLIENT_REF_MAX_LENGTH chars; one fresh value per logical prompt)
+ *   mapped to the generated commandId/turnId at preflight acceptance so a
+ *   caller can reconcile after a lost acknowledgement frame.
+ * - The clientRef index is scoped to one live session runtime: identical refs
+ *   may coexist in different sessions, lookups never cross sessions, a ref
+ *   conflicts only while its record is retained (`client_ref_conflict`), and
+ *   after terminal TTL/capacity eviction a ref may be admitted again with the
+ *   prior outcome unknown — callers MUST NOT reuse a clientRef as a retry
+ *   mechanism and MUST treat `unknown` as uncertainty, not proof of
+ *   non-execution.
+ * - The durability floor is the live session process: after restart or
+ *   retained-record eviction, a lookup honestly reports `unknown`.
+ * - Q26 tracks prompts accepted through the SDK control surface (which always
+ *   carries a requesting connection); submissions without a delivery owner are
+ *   outside the reconciliation contract and hold no reservation.
+ */
+export declare const PROMPT_CLIENT_REF_MAX_LENGTH = 128;
+export interface TurnPromptImageInput {
+    data: string;
+    mimeType?: string;
+}
+/** Public input contract for ordered `turn.prompt`. */
+export interface TurnPromptInput {
+    text: string;
+    images?: TurnPromptImageInput[];
+    clientRef?: string;
+}
+/** Terminal outcome is preserved exactly; active records never age into terminal. */
+export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
+/** Exactly one selector per lookup. */
+export type TurnPromptStatusSelector = {
+    clientRef: string;
+} | {
+    commandId: string;
+    turnId: string;
+};
+interface TurnPromptReconciliationIdentity {
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    /** Epoch milliseconds of preflight acceptance. */
+    acceptedAt: number;
+}
+export interface TurnPromptReconciliationAccepted extends TurnPromptReconciliationIdentity {
+    status: "accepted";
+}
+export interface TurnPromptReconciliationInFlight extends TurnPromptReconciliationIdentity {
+    status: "in_flight";
+    /** Epoch milliseconds of the agent_start transition. */
+    startedAt: number;
+}
+export interface TurnPromptReconciliationTerminalOk extends TurnPromptReconciliationIdentity {
+    status: "terminal_ok";
+    startedAt?: number;
+    /** Epoch milliseconds of the terminal transition. */
+    terminalAt: number;
+}
+export interface TurnPromptReconciliationFailed extends TurnPromptReconciliationIdentity {
+    status: "failed";
+    startedAt?: number;
+    terminalAt: number;
+    /** Bounded, sanitized failure detail (code safe-token ≤64, message ≤512). */
+    error: {
+        code: string;
+        message: string;
+    };
+}
+export interface TurnPromptReconciliationUnknown {
+    status: "unknown";
+}
+export type TurnPromptReconciliation = TurnPromptReconciliationAccepted | TurnPromptReconciliationInFlight | TurnPromptReconciliationTerminalOk | TurnPromptReconciliationFailed | TurnPromptReconciliationUnknown;
+/** Result of a successful `turn.prompt` preflight acknowledgement. */
+export interface TurnPromptAcceptedResult {
+    commandId: string;
+    turnId: string;
+    accepted: true;
+    clientRef?: string;
+}
+export {};

package/dist/types/sdk/session-directory.d.ts

@@ -20,7 +20,7 @@ export type ResolveManagedSessionScopeResult = {
     scope: ManagedSessionScope;
 } | {
     kind: "error";
-    code: "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid";
+    code: "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid" | "atomic_unavailable" | "durability_not_provable" | "durability_failed" | "invalid_request";
     message: string;
 };
 export interface LogicalSessionCandidate {

package/dist/types/sdk/session.d.ts

@@ -149,6 +149,13 @@ export interface CreateAgentSessionOptions {
     goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
     /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
     discoverableToolAllowedNames?: readonly string[];
+    /**
+     * Discoverable built-in tools that must stay in the initial active set even when
+     * `tools.discoveryMode === "all"` would otherwise hide them behind `search_tool_bm25`.
+     * Used for coordination tools (e.g. `irc`) that a subagent must be able to use
+     * immediately without first spending a discovery round-trip to find them.
+     */
+    alwaysActiveToolNames?: readonly string[];
     /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
     agentRegistry?: AgentRegistry;
     /** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */

package/dist/types/sdk/startup-capability.d.ts

@@ -1,9 +1,12 @@
+import { type ModelProfileErrorCode, type ModelProfileErrorDetails } from "../config/model-profile-contract";
 export type SdkStartupPhase = "registration" | "startup";
 export type SdkStartupReason = "disabled" | "ineligible" | "factory_absent" | "runner_absent" | "pending" | "failed";
 export interface SdkStartupFailure {
     phase: SdkStartupPhase;
     reason: SdkStartupReason;
     message: string;
+    code?: ModelProfileErrorCode;
+    details?: ModelProfileErrorDetails;
 }
 export type SdkStartupResult = {
     status: "started";
@@ -13,6 +16,12 @@ export type SdkStartupResult = {
 };
 /** Internal symbols for lifecycle-only SDK startup construction and bus wiring. */
 export declare const lifecycleStartupCapabilityOption: unique symbol;
+/**
+ * Internal option carrying the startup budget for ACP lifecycle MCP launches.
+ * Only set when the lifecycle request actually supplies `mcpServers`, so the
+ * longer ceiling never leaks to ordinary CLI/SDK `mcpConfigPath` consumers.
+ */
+export declare const lifecycleMcpStartupTimeoutOption: unique symbol;
 export declare function attachLifecycleStartupCapability(api: object, capability: SdkStartupCapability): void;
 export declare function lifecycleStartupCapabilityForApi(api: object): SdkStartupCapability | undefined;
 export interface SdkStartupRollbackResult {

package/dist/types/sdk/transport/auth-preface.d.ts

@@ -0,0 +1,9 @@
+import type * as net from "node:net";
+type AuthFailureCode = "auth_missing" | "auth_malformed" | "auth_invalid" | "auth_oversize" | "auth_timeout" | "unsupported_version";
+export declare class AuthPrefaceError extends Error {
+    readonly code: AuthFailureCode;
+    constructor(code: AuthFailureCode);
+}
+/** Consumes the one-shot socket authentication preface and leaves later bytes readable. */
+export declare function authenticatePreface(socket: net.Socket, token: string): Promise<Buffer>;
+export {};

package/dist/types/sdk/transport/index.d.ts

@@ -0,0 +1,12 @@
+export { DEFAULT_PENDING_CEILING_BYTES, MIN_PENDING_CEILING_BYTES, REQUEST_FRAME_BYTES, } from "./relay";
+export { startSocketServe } from "./socket";
+export { startStdioServe } from "./stdio";
+export type ServeOptions = {
+    url: string;
+    token: string;
+    pendingCeilingBytes: number;
+};
+export type ServeHandle = {
+    close(): Promise<void>;
+    readonly done: Promise<void>;
+};

package/dist/types/sdk/transport/relay.d.ts

@@ -0,0 +1,43 @@
+import type { Readable, Writable } from "node:stream";
+export declare const REQUEST_FRAME_BYTES: number;
+export declare const DEFAULT_PENDING_CEILING_BYTES: number;
+export declare const MIN_PENDING_CEILING_BYTES: number;
+export type RelayDirection = "downstream->ws" | "ws->downstream";
+export type TransportError = {
+    type: "transport_error";
+    code: "frame_oversize" | "pending_overflow" | "protocol_error";
+    direction?: RelayDirection;
+};
+export type RelayPair = {
+    close(): Promise<void>;
+    readonly done: Promise<void>;
+};
+export declare class RelayOpenAbortedError extends Error {
+    constructor();
+}
+export type RelayWebSocketEvent = {
+    data?: unknown;
+};
+export type RelayWebSocket = {
+    readonly bufferedAmount: number;
+    readonly readyState: number;
+    close(): void;
+    send(data: string): void;
+    addEventListener(type: string, listener: (event: RelayWebSocketEvent) => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: string, listener: (event: RelayWebSocketEvent) => void): void;
+};
+export type RelayOptions = {
+    url: string;
+    token: string;
+    pendingCeilingBytes: number;
+    downstream: Readable;
+    downstreamSink: Writable;
+    initialDownstreamBytes?: Buffer;
+    onTransportError: (error: TransportError) => void;
+    webSocketFactory?: (url: string) => RelayWebSocket;
+    signal?: AbortSignal;
+};
+/** Starts a dedicated raw-WebSocket relay for exactly one downstream stream. */
+export declare function startRelayPair(options: RelayOptions): Promise<RelayPair>;

package/dist/types/sdk/transport/serve-cli.d.ts

@@ -0,0 +1,4 @@
+/** Resolves the pending ceiling with flag > env > default precedence; exported for tests. */
+export declare function resolveServePendingCeiling(flagValue: string | undefined, envValue: string | undefined): number;
+/** Attaches a stdio or Unix-socket relay to one live SDK session endpoint. */
+export declare function runSdkServe(argv: string[]): Promise<void>;

package/dist/types/sdk/transport/socket.d.ts

@@ -0,0 +1,7 @@
+import type { ServeHandle, ServeOptions } from "./index";
+import type { RelayOptions } from "./relay";
+/** Serves authenticated SDK JSONL clients over a private Unix-domain socket. */
+export declare function startSocketServe(options: ServeOptions & {
+    socketPath: string;
+    webSocketFactory?: RelayOptions["webSocketFactory"];
+}): Promise<ServeHandle>;

package/dist/types/sdk/transport/stdio.d.ts

@@ -0,0 +1,3 @@
+import type { ServeHandle, ServeOptions } from "./index";
+/** Serves one parent-owned JSONL connection over the process standard streams. */
+export declare function startStdioServe(options: ServeOptions): Promise<ServeHandle>;