indusagi-coding-agent 0.2.4 → 0.2.5

package/dist/types/channels/framer.d.ts

@@ -1,49 +0,0 @@
-/**
- * NDJSON framer — the concrete, separator-safe line transport.
- *
- * Implements the {@link NdjsonFramer} surface declared in the contract: a pure
- * encoder ({@link encodeLine}) and a pull-model async-generator decoder
- * ({@link decodeLines}). Both halves are I/O-free seams over an injected stream,
- * so the server, the driver, and the oneshot channel share one correct framing
- * implementation.
- *
- * The correctness pin: U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH SEPARATOR)
- * are legal inside a JSON string but a downstream splitter that treats them as
- * line boundaries corrupts the frame. {@link encodeLine} escapes both to their
- * backslash-u forms, and {@link decodeLines} splits strictly on the line feed
- * (U+000A) only — so any value the encoder emits round-trips through the decoder
- * unchanged regardless of payload content.
- */
-import type { DecodeLines, EncodeLine, NdjsonFramer } from "./contract";
-/**
- * Encode one value as a single, separator-safe NDJSON line.
- *
- * Serializes `value` with `JSON.stringify`, escapes the two Unicode line
- * separators, and appends exactly one line feed. The result contains no raw
- * U+2028 / U+2029 and exactly one terminating `\n`, so a strictly-newline
- * splitter recovers it intact.
- *
- * @param value any JSON-serializable value (a request, a reply, or a signal)
- * @returns the encoded line, terminated by a single `\n`
- */
-export declare const encodeLine: EncodeLine;
-/**
- * Decode a chunk stream into a stream of parsed JSON values.
- *
- * Pull model: buffers incoming text, splits on `\n` only, parses each complete
- * line, and yields the parsed value. A partial trailing line is held until its
- * newline arrives; an empty (or whitespace-only) line is skipped. A trailing
- * unterminated line at end-of-stream is parsed if it carries content, so a
- * non-newline-terminated final frame is not silently dropped.
- *
- * @param stream the raw chunk stream (stdin, a child pipe, or an in-memory pipe)
- */
-export declare const decodeLines: DecodeLines;
-/**
- * The bundled framer pair: the canonical {@link NdjsonFramer} instance.
- *
- * Frozen so consumers share one implementation by reference rather than
- * re-deriving framing at each call site; an embedder may still inject an
- * alternate framer via the driver / server options.
- */
-export declare const ndjsonFramer: NdjsonFramer;

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

@@ -1,24 +0,0 @@
-/**
- * Channels subsystem — public barrel.
- *
- * Re-exports the FROZEN Phase-8 contract: the JSON-RPC 2.0 envelope
- * ({@link OpRequest}, {@link Reply}, {@link OpError}), the declarative operation
- * registry ({@link Op}, {@link OpRegistry}, {@link defineOps}) and the type that
- * the typed client is generated from ({@link LinkDriver}), the NDJSON framer
- * surface ({@link NdjsonFramer} / {@link EncodeLine} / {@link DecodeLines}), the
- * dialog primitives ({@link Ask} / {@link Tell} / {@link DialogBridge}), the
- * {@link ChannelContext}, the wire session projection ({@link LinkSnapshot}), and
- * the oneshot channel shapes ({@link OneshotRequest} / {@link OneshotStrategy}).
- *
- * Behavior modules (the oneshot runner, the link server, the generated driver,
- * the NDJSON framer, and the dialog bridge) are added to this barrel as they
- * land; consumers import the channel surface from `src/channels` rather than
- * reaching into individual modules.
- */
-export type { ProtocolVersion, RequestId, OpRequest, OpError, ReplyOk, ReplyErr, Reply, WritableLine, ReadableChunks, EncodeLine, DecodeLines, NdjsonFramer, Ask, AskAnswer, Tell, DialogBridge, ChannelContext, Op, OpRegistry, OpParams, OpResult, LinkDriver, LinkSnapshot, Signal, OneshotShape, OneshotRequest, OneshotStrategy, ChannelTimings, DriverOptions, ServerOptions, ImageContent, SessionConductor, ConductorState, ThinkingLevel, Usage, } from "./contract";
-export { PROTOCOL_VERSION, OP_ERROR, REQUEST_ID_PREFIX, DEFAULT_CHANNEL_TIMINGS, isReplyOk, defineOps, } from "./contract";
-export { encodeLine, decodeLines, ndjsonFramer } from "./framer";
-export { dispatch, hasOp, methodsOf, buildOps, UnknownOpError, type OpRegistryHandle, } from "./ops";
-export { runOneshot, inertDialog } from "./oneshot";
-export { SESSION_OPS, projectSnapshot, type SessionOps, type SubmitParams, type ResumeParams, type CycleModelParams, type ModelEntry, } from "./session-ops";
-export { createLinkServer, createLinkDriver, createDialogBridge, makeDialogMethods, DIALOG_TABLE, LinkRequestError, type LinkServer, type LinkServerIo, type LinkServerConfig, type LinkDriverHandle, type LinkDriverIo, type LinkDriverConfig, type LinkedDialogBridge, type DialogBridgeDeps, type DialogSpec, type DialogMethods, } from "./link";

package/dist/types/channels/link/dialog.d.ts

@@ -1,138 +0,0 @@
-/**
- * Dialog bridge — the ask / tell seam over the link transport.
- *
- * The agent (and the extensions it hosts) needs to interact with whoever drives
- * the channel: ask a multiple-choice question, confirm a destructive action,
- * prompt for free text, flash a notice, set a status line. Rather than a
- * per-interaction handler ladder, the whole surface reduces to two primitives:
- *
- *   - {@link DialogBridge.ask} — one generic round-trip: emit an {@link Ask}
- *     frame, suspend until a correlated {@link AskAnswer} arrives, and resolve
- *     with its value (or a caller-supplied fallback when the deadline lapses or
- *     the driver dismisses the request).
- *   - {@link DialogBridge.tell} — one generic fire-and-forget: emit a {@link Tell}
- *     frame and return immediately.
- *
- * Concrete dialog methods (select / confirm / input / notify / status / title)
- * are expressed as a *data table* of named entries keyed by interaction kind, not
- * as bespoke method bodies. {@link makeDialogMethods} closes that table over a
- * single bridge so a caller gets typed conveniences while the bridge keeps the
- * lone round-trip / fire-and-forget implementation.
- */
-import type { AskAnswer, ChannelTimings, DialogBridge, NdjsonFramer, WritableLine } from "../contract";
-/** Everything {@link createDialogBridge} needs to emit frames and time out. */
-export interface DialogBridgeDeps {
-    /** Sink the ask/tell frames are written to (already framed). */
-    readonly out: WritableLine;
-    /** Framer used to encode each frame to a line. */
-    readonly framer: NdjsonFramer;
-    /** Timings; only {@link ChannelTimings.dialogMs} is consulted here. */
-    readonly timings: ChannelTimings;
-}
-/**
- * A {@link DialogBridge} whose pending answers are fed by an external reader.
- *
- * The bridge itself does not read the stream — the server owns the single
- * decode loop and routes any inbound {@link AskAnswer} frame to
- * {@link LinkedDialogBridge.deliver}. This keeps one reader over the transport
- * (the server) rather than competing consumers.
- */
-export interface LinkedDialogBridge extends DialogBridge {
-    /**
-     * Resolve the pending {@link DialogBridge.ask} that minted `answer.id`.
-     *
-     * A no-op when no ask is pending under that id (a late or duplicate answer),
-     * so a misbehaving driver cannot throw into the read loop.
-     *
-     * @param answer the inbound answer frame
-     * @returns whether a pending ask was settled by this answer
-     */
-    deliver(answer: AskAnswer): boolean;
-    /**
-     * Reject every still-pending ask with its fallback (used on shutdown), so no
-     * awaiting handler is left suspended when the link closes.
-     */
-    drain(): void;
-}
-/**
- * Construct a {@link LinkedDialogBridge} over an injected sink + framer.
- *
- * `ask` writes an {@link Ask} frame, registers the pending resolver under a
- * fresh id, and arms a fallback timer; `deliver` settles the matching pending
- * resolver when the answer returns. `tell` writes a {@link Tell} frame and
- * returns at once. No stdio, no global state — every dependency is injected.
- */
-export declare function createDialogBridge(deps: DialogBridgeDeps): LinkedDialogBridge;
-/**
- * One concrete dialog method expressed as data, not code.
- *
- * `kind` is the wire interaction kind; `mode` selects which primitive carries
- * it (a round-trip `ask` or a fire-and-forget `tell`); `fallback` is the value a
- * round-trip resolves with on timeout / dismissal (unused for `tell`). The whole
- * dialog surface is this table — adding an interaction is adding a row.
- */
-export interface DialogSpec {
-    /** The wire interaction kind (the `Ask.kind` / `Tell.kind`). */
-    readonly kind: string;
-    /** Whether the method round-trips for an answer or is fire-and-forget. */
-    readonly mode: "ask" | "tell";
-    /** The value an `ask` resolves with when no answer arrives in time. */
-    readonly fallback?: unknown;
-}
-/**
- * The canonical dialog table: every concrete interaction the channel exposes,
- * each one row of data over the two primitives.
- *
- * Replaces a copied switch of bespoke UI-context methods: the bridge has exactly
- * one round-trip and one fire-and-forget body, and this table names the kinds.
- */
-export declare const DIALOG_TABLE: Readonly<{
-    select: {
-        kind: string;
-        mode: "ask";
-        fallback: null;
-    };
-    confirm: {
-        kind: string;
-        mode: "ask";
-        fallback: boolean;
-    };
-    input: {
-        kind: string;
-        mode: "ask";
-        fallback: null;
-    };
-    editor: {
-        kind: string;
-        mode: "ask";
-        fallback: null;
-    };
-    notify: {
-        kind: string;
-        mode: "tell";
-    };
-    status: {
-        kind: string;
-        mode: "tell";
-    };
-    title: {
-        kind: string;
-        mode: "tell";
-    };
-}>;
-/** The set of named dialog methods derived from {@link DIALOG_TABLE}. */
-export type DialogMethods = {
-    [K in keyof typeof DIALOG_TABLE]: (typeof DIALOG_TABLE)[K]["mode"] extends "ask" ? (payload?: unknown) => Promise<unknown> : (payload?: unknown) => void;
-};
-/**
- * Close the {@link DIALOG_TABLE} over one {@link DialogBridge} into typed,
- * named convenience methods.
- *
- * Each `ask` row becomes a thunk that round-trips through `bridge.ask` with the
- * row fallback; each `tell` row becomes a thunk that fires through `bridge.tell`.
- * There is no per-method choreography — the bodies are generated from the table.
- *
- * @param bridge the round-trip / fire-and-forget primitive pair
- * @returns the named method object projected from the table
- */
-export declare function makeDialogMethods(bridge: DialogBridge): DialogMethods;

package/dist/types/channels/link/driver.d.ts

@@ -1,81 +0,0 @@
-/**
- * Link driver — the generated client over the JSON-RPC link.
- *
- * The driver is the mirror of the server: it writes framed requests and reads
- * framed replies. Crucially it is *generated*, not hand-written — there is no
- * per-op client method. A {@link Proxy} turns any property access into a thunk
- * that frames `{ id, method, params } -> awaits { id, result | error }`, so the
- * driver satisfies the {@link LinkDriver} type projected from a registry with a
- * single body. Adding an op to the registry adds a callable method to the driver
- * for free.
- *
- * The driver owns the single reader over the inbound stream. Every decoded frame
- * is one of: a correlated {@link Reply} (settles the pending request under its
- * id), an uncorrelated {@link Signal} (fanned out to subscribers), or an
- * {@link Ask} (handed to an answerer that posts an {@link AskAnswer} back). One
- * reader, three routes — no competing consumers of the transport.
- */
-import { type Ask, type ChannelTimings, type LinkDriver, type NdjsonFramer, type OpError, type OpRegistry, type ReadableChunks, type Signal, type WritableLine } from "../contract";
-/** The injectable transport pair the driver writes to and reads from. */
-export interface LinkDriverIo {
-    /** Sink the driver writes framed requests to (defaults to the child stdin). */
-    readonly out: WritableLine;
-    /** Source the driver reads framed replies / signals from (defaults to child stdout). */
-    readonly in: ReadableChunks;
-}
-/** Optional overrides for a driver: a framer, the timings, and hooks. */
-export interface LinkDriverConfig {
-    /** Override the NDJSON framer (defaults to the shared one). */
-    readonly framer?: NdjsonFramer;
-    /** Override any subset of the channel timings. */
-    readonly timings?: Partial<ChannelTimings>;
-    /** Invoked for every uncorrelated {@link Signal} the server streams. */
-    readonly onSignal?: (signal: Signal) => void;
-    /**
-     * Invoked when the server asks a question; returns the answer value. When
-     * omitted the driver dismisses every ask (posts `null`), so a non-interactive
-     * driver never wedges the server.
-     */
-    readonly onAsk?: (ask: Ask) => unknown | Promise<unknown>;
-}
-/** A failed reply turned into a throwable error that carries the wire code. */
-export declare class LinkRequestError extends Error {
-    /** The JSON-RPC error code from the {@link OpError}. */
-    readonly code: number;
-    /** The structured detail, when the server supplied any. */
-    readonly data: unknown;
-    constructor(error: OpError);
-}
-/**
- * A live driver: the generated client plus its lifecycle.
- *
- * `client` is the {@link Proxy} typed as a {@link LinkDriver} for the registry
- * `Ops`; `done` resolves when the inbound stream ends; `close` rejects every
- * still-pending request and stops the reader.
- *
- * @typeParam Ops the {@link OpRegistry} the client type is projected from
- */
-export interface LinkDriverHandle<Ops extends OpRegistry> {
-    /** The generated, registry-typed client. */
-    readonly client: LinkDriver<Ops>;
-    /** Resolves when the reader loop drains (the inbound stream ended). */
-    readonly done: Promise<void>;
-    /** Reject all pending requests with `reason` and stop accepting replies. */
-    close(reason?: string): void;
-}
-/**
- * Build a {@link LinkDriverHandle} over an injected transport.
- *
- * The returned `client` is a {@link Proxy}: reading property `m` yields a thunk
- * `(params?) => Promise<result>` that mints an id (prefixed with
- * {@link REQUEST_ID_PREFIX}), writes the framed request, and resolves when the
- * matching {@link Reply} arrives (or rejects on a {@link ReplyErr} or timeout).
- * No method is hand-written; the registry type parameter only shapes the static
- * face. The reader loop classifies inbound frames into replies, signals, and
- * asks and routes each.
- *
- * @typeParam Ops the registry whose method set types the client
- * @param io     the injected request sink + reply source
- * @param config optional framer / timing / hook overrides
- */
-export declare function createLinkDriver<Ops extends OpRegistry = OpRegistry>(io: LinkDriverIo, config?: LinkDriverConfig): LinkDriverHandle<Ops>;

package/dist/types/channels/link/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Link channel — public barrel.
- *
- * The link channel is the long-lived, bidirectional half of the channels
- * subsystem: a JSON-RPC 2.0 server that dispatches framed requests through an
- * {@link OpRegistry} (`server.ts`), a generated {@link LinkDriver} client built
- * from a {@link Proxy} rather than hand-written methods (`driver.ts`), and the
- * ask / tell dialog bridge that both ends share (`dialog.ts`). Consumers import
- * the link surface from `src/channels/link` rather than the individual modules.
- */
-export { createLinkServer, type LinkServer, type LinkServerIo, type LinkServerConfig, } from "./server";
-export { createLinkDriver, LinkRequestError, type LinkDriverHandle, type LinkDriverIo, type LinkDriverConfig, } from "./driver";
-export { createDialogBridge, makeDialogMethods, DIALOG_TABLE, type LinkedDialogBridge, type DialogBridgeDeps, type DialogSpec, type DialogMethods, } from "./dialog";

package/dist/types/channels/link/server.d.ts

@@ -1,70 +0,0 @@
-/**
- * Link server — the data-driven JSON-RPC 2.0 dispatch loop.
- *
- * The server owns the single reader over the inbound stream. For each framed
- * line it decides what the frame is and routes it: a request frame is dispatched
- * through the {@link OpRegistry} (a map lookup, not a command switch) and its
- * outcome is framed back as a {@link Reply}; an inbound {@link AskAnswer} frame
- * is routed to the {@link DialogBridge} to settle a suspended `ask`. One round of
- * the protocol is `{ id, method, params } -> { id, result | error }`.
- *
- * Everything that touches the outside world is injected: the request source, the
- * reply sink, the framer, and the conductor all arrive through the context and
- * options, so a test serves the link over an in-memory pipe pair with no stdio.
- * The dispatch itself is delegated to {@link dispatch} from the ops module, so
- * the server holds no per-method knowledge.
- */
-import { type ChannelTimings, type NdjsonFramer, type OpRegistry, type ReadableChunks, type SessionConductor, type WritableLine } from "../contract";
-import { type LinkedDialogBridge } from "./dialog";
-/**
- * The injectable transport pair the server reads from and writes to.
- *
- * Named `io` at the call site; bundles the inbound request source and the
- * outbound reply/signal sink so tests pass in-memory pipes and production passes
- * stdin / stdout.
- */
-export interface LinkServerIo {
-    /** Framed inbound request / answer lines (defaults to stdin). */
-    readonly in: ReadableChunks;
-    /** Framed outbound reply / signal / dialog sink (defaults to stdout). */
-    readonly out: WritableLine;
-}
-/** Optional overrides for a server: a framer and the timings. */
-export interface LinkServerConfig {
-    /** Override the NDJSON framer (defaults to the shared one). */
-    readonly framer?: NdjsonFramer;
-    /** Override any subset of the channel timings. */
-    readonly timings?: Partial<ChannelTimings>;
-}
-/** A running server: a promise that settles when the inbound stream ends. */
-export interface LinkServer {
-    /** Resolves when the request stream is exhausted and the loop has drained. */
-    readonly done: Promise<void>;
-    /** The dialog bridge the running server feeds inbound answers to. */
-    readonly dialog: LinkedDialogBridge;
-}
-/**
- * Start a link server over an op registry, a conductor, and an injected
- * transport.
- *
- * Builds the shared {@link ChannelContext} (conductor + framer + the freshly
- * wired {@link DialogBridge}), then consumes the inbound stream with a single
- * `for await` loop. Each frame is classified:
- *
- *   - an answer frame is delivered to the dialog bridge;
- *   - a request frame is dispatched through `registry`; a request carrying an
- *     `id` gets exactly one correlated reply (result or error); a notification
- *     (no `id`) is dispatched for its effect and never replied to;
- *   - any other frame is ignored (a forward-compatible no-op).
- *
- * Parse failures from the framer surface as a thrown error in the loop and are
- * framed as a {@link OP_ERROR.parse} reply with no id (the offending frame had
- * none to correlate).
- *
- * @param registry the frozen {@link OpRegistry} that drives dispatch
- * @param conductor the session every op delegates to
- * @param io        the injected request source + reply sink
- * @param config    optional framer / timing overrides
- * @returns a handle whose `done` resolves when the inbound stream ends
- */
-export declare function createLinkServer(registry: OpRegistry, conductor: SessionConductor, io: LinkServerIo, config?: LinkServerConfig): LinkServer;

package/dist/types/channels/oneshot.d.ts

@@ -1,37 +0,0 @@
-/**
- * Oneshot channel — a single non-interactive run to settlement.
- *
- * Replaces the print mode. Given a {@link ChannelContext} and an
- * {@link OneshotRequest}, it submits every prompt to the conductor in order,
- * streams the answer to the channel sink, and resolves a process exit code.
- *
- * The shape (clean final text vs a streamed NDJSON event log) is chosen by
- * selecting an {@link OneshotStrategy} object rather than branching on a flag
- * through the runner body: each strategy supplies an optional `onStart`, an
- * optional `onSignal`, and a mandatory `finish` that turns the settled state
- * into the exit code. The runner itself is shape-agnostic — it subscribes the
- * strategy to the conductor signal stream, runs the prompts, and hands the final
- * state to `finish`.
- */
-import type { ChannelContext, DialogBridge, OneshotRequest } from "./contract";
-/**
- * A dialog bridge for a non-interactive oneshot run: no driver is attached to
- * answer a question, so every `ask` resolves immediately with its caller-supplied
- * fallback and every `tell` is dropped. Keeps the agent from wedging on a prompt
- * during a headless single run while never writing dialog frames to the sink.
- */
-export declare const inertDialog: DialogBridge;
-/**
- * Run one non-interactive request to settlement.
- *
- * Selects the {@link OneshotStrategy} for `opts.shape`, subscribes it to the
- * conductor signal stream, runs `onStart`, then submits each prompt in order and
- * awaits its settlement. The state from the final prompt is handed to the
- * strategy's `finish`, whose return value is the resolved exit code. The
- * subscription is always torn down before returning.
- *
- * @param ctx  the channel context (conductor, sink, framer, dialog) — fully injected
- * @param opts the request: output shape, the prompts to run, and any images
- * @returns the process exit code (0 on a clean settlement, 1 on a fault)
- */
-export declare function runOneshot(ctx: ChannelContext, opts: OneshotRequest): Promise<number>;

package/dist/types/channels/ops.d.ts

@@ -1,89 +0,0 @@
-/**
- * Operation registry — the single declarative source both halves of the link
- * consume.
- *
- * The contract defines {@link defineOps} (freeze a record of {@link Op}s into an
- * {@link OpRegistry}) and the {@link LinkDriver} type projected from a registry.
- * This module adds the runtime face the server needs and the driver leans on: a
- * built registry carries its `methods` list (so a {@link LinkDriver} can be
- * generated by walking the keys, never hand-written) and a `dispatch` seam that
- * looks an op up by `method` and runs its `handle` — the data-driven replacement
- * for a copied command switch.
- *
- * Nothing here knows about transport or framing: dispatch takes the already
- * parsed `method`/`params` and the shared {@link ChannelContext}, runs the op,
- * and returns its resolved result (or throws {@link UnknownOpError} when no op is
- * registered). The server frames the outcome into a {@link Reply}; the driver
- * uses `methods` to build its thunks. One frozen registry drives both.
- */
-import { defineOps } from "./contract";
-import type { ChannelContext, Op, OpRegistry } from "./contract";
-/** Re-exported so consumers mint registries from one module. */
-export { defineOps };
-/**
- * Thrown by {@link dispatch} (and {@link OpRegistryHandle.dispatch}) when the
- * requested `method` has no registered {@link Op}.
- *
- * Carries the frozen {@link OP_ERROR.unknownOp} code so the server can frame it
- * into a {@link ReplyErr} without re-deriving the category, and records the
- * offending `method` for logging.
- */
-export declare class UnknownOpError extends Error {
-    /** The JSON-RPC error category for an unregistered method. */
-    readonly code: number;
-    /** The method name that resolved to no operation. */
-    readonly method: string;
-    constructor(method: string);
-}
-/**
- * Run one operation by name against the shared context.
- *
- * Looks `method` up in `registry`, then awaits its `handle(params, ctx)`. The
- * lone dispatch path for the server: there is no per-method branch, only a map
- * lookup. Throws {@link UnknownOpError} when the method is not registered and
- * propagates whatever the handler throws (the server maps that to a
- * {@link ReplyErr}).
- *
- * @param registry the frozen {@link OpRegistry} to dispatch within
- * @param method   the wire method name to invoke
- * @param params   the already-parsed request payload (passed through verbatim)
- * @param ctx      the shared {@link ChannelContext}
- * @returns the operation result
- */
-export declare function dispatch(registry: OpRegistry, method: string, params: unknown, ctx: ChannelContext): Promise<unknown>;
-/** Whether `method` resolves to a registered {@link Op} in `registry`. */
-export declare function hasOp(registry: OpRegistry, method: string): boolean;
-/** The sorted wire method names a registry exposes — the driver's method set. */
-export declare function methodsOf<T extends OpRegistry>(registry: T): ReadonlyArray<keyof T & string>;
-/**
- * A built registry plus its runtime face: the method list and a bound
- * `dispatch`.
- *
- * `methods` is what a generated {@link LinkDriver} walks to build its thunks;
- * `dispatch` is what the server calls per request. Both are bound to the one
- * frozen `registry`, so the server-side dispatch and the client-side method set
- * can never drift from each other.
- *
- * @typeParam T the concrete registry shape (preserved for the generated driver)
- */
-export interface OpRegistryHandle<T extends OpRegistry> {
-    /** The frozen registry — the single source of truth. */
-    readonly registry: T;
-    /** The sorted method names this registry exposes. */
-    readonly methods: ReadonlyArray<keyof T & string>;
-    /** Invoke an op by name against `ctx`; see {@link dispatch}. */
-    dispatch(method: string, params: unknown, ctx: ChannelContext): Promise<unknown>;
-}
-/**
- * Build an {@link OpRegistryHandle} from a record of operation declarations.
- *
- * Freezes the input with {@link defineOps}, then bundles it with its derived
- * method list and a `dispatch` bound to that frozen registry. This is the lone
- * sanctioned way to produce the object the server and the driver both consume,
- * so the dispatch map and the driver method set always derive from one source.
- *
- * @param ops a record of method-name → {@link Op}
- * @returns the frozen registry handle, with the input's exact key/value types
- *          preserved for the generated {@link LinkDriver}
- */
-export declare function buildOps<T extends Record<string, Op<any, any>>>(ops: T): OpRegistryHandle<Readonly<T>>;

package/dist/types/channels/session-ops.d.ts

@@ -1,80 +0,0 @@
-/**
- * Session ops — the concrete operation registry that drives the link.
- *
- * This is the single declarative source of every operation the link server
- * dispatches and the {@link LinkDriver} client is generated from. Each op binds a
- * wire `method` name to a `handle` that delegates to the {@link SessionConductor}
- * carried on the {@link ChannelContext}; there is no per-method dispatch ladder
- * and no hand-written parallel client method. Adding a row here adds both a
- * server-handled method and a callable driver method.
- *
- * The ops also own the {@link LinkSnapshot} projection: the conductor exposes its
- * internal {@link ConductorState}, and {@link projectSnapshot} reshapes that into
- * the flat, serializable wire vocabulary a remote driver mirrors without holding
- * a live conductor.
- */
-import type { ConductorState, LinkSnapshot, Op, ThinkingLevel } from "./contract";
-/**
- * Project a conductor {@link ConductorState} onto the wire {@link LinkSnapshot}.
- *
- * The snapshot is the link vocabulary: flat, serializable, and derived from — not
- * a passthrough of — the conductor state. Busy flags are read off the coarse
- * phase, the model and session identity off the state and its head, and the
- * cumulative usage carried straight through.
- *
- * @param state the immutable conductor state
- * @param extra optional fields the conductor does not surface on its state
- */
-export declare function projectSnapshot(state: ConductorState, extra?: {
-    readonly thinking?: ThinkingLevel;
-    readonly sessionFile?: string;
-    readonly autoCondense?: boolean;
-    readonly messageCount?: number;
-    readonly queuedCount?: number;
-}): LinkSnapshot;
-/** Parameters for the {@link sessionOps.submit} op. */
-export interface SubmitParams {
-    /** The user message text for this turn. */
-    readonly input: string;
-}
-/** Parameters for the {@link sessionOps.resume} op. */
-export interface ResumeParams {
-    /** The persisted session to restore. */
-    readonly sessionId: string;
-}
-/** Parameters for the {@link sessionOps.cycleModel} op. */
-export interface CycleModelParams {
-    /** Canonical id of the model to switch to. */
-    readonly modelId: string;
-}
-/** One model entry returned by the {@link sessionOps.listModels} op. */
-export interface ModelEntry {
-    /** Canonical model id. */
-    readonly id: string;
-    /** Whether this is the model currently bound to the session. */
-    readonly active: boolean;
-}
-/**
- * The frozen link op set: every operation a driver can invoke, each delegating
- * to the conductor on the context.
- *
- *   - `submit`     — run a user turn to settlement and reply with a snapshot.
- *   - `abort`      — cancel the in-flight turn and reply with a snapshot.
- *   - `snapshot`   — read the current state, projected to a {@link LinkSnapshot}.
- *   - `resume`     — restore a persisted session and reply with a snapshot.
- *   - `listModels` — list the model bound to the session (the active entry).
- *   - `cycleModel` — rotate the active model and reply with a snapshot.
- *
- * The map is consumed verbatim by the server (data-driven dispatch) and by the
- * generated {@link LinkDriver} (its method set is exactly these keys).
- */
-export declare const SESSION_OPS: Readonly<{
-    submit: Op<SubmitParams, LinkSnapshot>;
-    abort: Op<void, LinkSnapshot>;
-    snapshot: Op<void, LinkSnapshot>;
-    resume: Op<ResumeParams, LinkSnapshot>;
-    listModels: Op<void, readonly ModelEntry[]>;
-    cycleModel: Op<CycleModelParams, LinkSnapshot>;
-}>;
-/** The concrete op-set type, for typing a {@link LinkDriver} over this surface. */
-export type SessionOps = typeof SESSION_OPS;