@crazx/dsh-api-session-controller 0.1.2-alpha.3.zw.1

package/lib/types/catalog.d.ts

@@ -0,0 +1,11 @@
+/** Shared projection of the live LLM registry into the browser model catalog. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ModelCatalog, ModelSelection } from './types.ts';
+/**
+ * Build the browser model catalog without requiring a Session.
+ * @param ctx - Host context carrying the live LLM registry.
+ * @param defaultSelection - deployment default used before a Session selects a model.
+ * @returns successful non-empty provider groups and isolated provider failures.
+ */
+export declare function buildModelCatalog(ctx: Context, defaultSelection?: ModelSelection): Promise<ModelCatalog>;
+//# sourceMappingURL=catalog.d.ts.map

package/lib/types/catalog.js

@@ -0,0 +1,58 @@
+/** Shared projection of the live LLM registry into the browser model catalog. */
+/**
+ * Build the browser model catalog without requiring a Session.
+ * @param ctx - Host context carrying the live LLM registry.
+ * @param defaultSelection - deployment default used before a Session selects a model.
+ * @returns successful non-empty provider groups and isolated provider failures.
+ */
+export async function buildModelCatalog(ctx, defaultSelection = ctx.agentDefaultModel.currentSelection()) {
+    const providers = ctx.llm.listProviders();
+    const catalog = await Promise.all(providers.map(async (provider) => {
+        try {
+            const models = await ctx.llm.listModels(provider.id);
+            const entries = await Promise.all(models.map(async (model) => {
+                const resolved = await ctx.llm.resolveModelInfo(provider.id, model.id);
+                const reasoning = resolved.reasoning === undefined
+                    ? undefined
+                    : {
+                        efforts: resolved.reasoning.efforts.map(effort => ({
+                            id: effort.id,
+                            name: effort.name,
+                            ...(effort.description === undefined ? {} : { description: effort.description }),
+                        })),
+                        ...(resolved.reasoning.defaultEffort === undefined
+                            ? {}
+                            : { defaultEffort: resolved.reasoning.defaultEffort }),
+                    };
+                return {
+                    id: model.id,
+                    name: model.name,
+                    ...(model.description === undefined ? {} : { description: model.description }),
+                    ...(reasoning === undefined ? {} : { reasoning }),
+                };
+            }));
+            return {
+                kind: 'group',
+                group: { id: provider.id, name: provider.name, models: entries },
+            };
+        }
+        catch (error) {
+            return {
+                kind: 'failure',
+                failure: {
+                    id: provider.id,
+                    name: provider.name,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }));
+    return {
+        default: { ...defaultSelection },
+        routableProviders: providers.map(provider => provider.id),
+        groups: catalog.flatMap(item => item.kind === 'group' ? [item.group] : [])
+            .filter(group => group.models.length > 0),
+        failures: catalog.flatMap(item => item.kind === 'failure' ? [item.failure] : []),
+    };
+}
+//# sourceMappingURL=catalog.js.map

package/lib/types/client/contract/events.d.ts

@@ -0,0 +1,71 @@
+/** Observable contiguous Session event window consumed by domain assemblers. */
+import { type ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { SessionEvent } from '@deepseek-ai/dsh-session/types';
+import type { ChunkRowEvent } from '../../types.ts';
+/** Standard Session event or compact historical Assistant run. */
+export type SessionEventLike = SessionEvent | ChunkRowEvent;
+/** Client history entry retaining its coarse transport discriminator. */
+export type SessionEventLikeEntry = {
+    readonly type: 'event';
+    readonly event: SessionEvent;
+} | {
+    readonly type: 'chunks';
+    readonly event: ChunkRowEvent;
+};
+/** Scalar live entry accepted by append-only Client paths. */
+export type SessionLiveEventEntry = Extract<SessionEventLikeEntry, {
+    readonly type: 'event';
+}>;
+/** Exact delta that produced the latest event-window revision. */
+export type SessionEventChange = {
+    readonly kind: 'replace';
+    readonly entries: readonly SessionEventLikeEntry[];
+} | {
+    readonly kind: 'prepend';
+    readonly entries: readonly SessionEventLikeEntry[];
+} | {
+    readonly kind: 'append';
+    readonly entries: readonly SessionLiveEventEntry[];
+};
+/** Current contiguous event window and its latest synchronous delta. */
+export interface SessionEventWindow {
+    readonly entries: readonly SessionEventLikeEntry[];
+    readonly hasMore: boolean;
+    readonly revision: number;
+    readonly change: SessionEventChange;
+}
+/** Conversation-facing event source exposed by one Session binding. */
+export type SessionEventSource = ObservableSnapshot<SessionEventWindow>;
+/** Session-owned event feed; every accepted window mutation publishes synchronously. */
+export declare class MutableSessionEventSource implements SessionEventSource {
+    private readonly listeners;
+    private window;
+    private snapshot;
+    /** @returns the cached event-window snapshot. */
+    getSnapshot(): SessionEventWindow;
+    /**
+     * Subscribe to synchronous window publication.
+     * @param listener - invalidation callback.
+     * @returns unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Replace the complete contiguous window.
+     * @param entries - complete window.
+     * @param hasMore - whether older history remains.
+     */
+    replace(entries: readonly SessionEventLikeEntry[], hasMore: boolean): void;
+    /**
+     * Prepend one older contiguous page.
+     * @param entries - newly loaded older entries.
+     * @param hasMore - whether still older history remains.
+     */
+    prepend(entries: readonly SessionEventLikeEntry[], hasMore: boolean): void;
+    /**
+     * Append one contiguous live entry.
+     * @param entry - live tail entry.
+     */
+    append(entry: SessionLiveEventEntry): void;
+    private publish;
+}
+//# sourceMappingURL=events.d.ts.map

package/lib/types/client/contract/events.js

@@ -0,0 +1,91 @@
+/** Observable contiguous Session event window consumed by domain assemblers. */
+import { notifySubscribers } from '@deepseek-ai/dsh-client-store';
+function leaf(entries) {
+    return { kind: 'leaf', entries, length: entries.length };
+}
+function concat(left, right) {
+    return { kind: 'concat', left, right, length: left.length + right.length };
+}
+function materialize(node) {
+    if (node.kind === 'leaf')
+        return node.entries;
+    const entries = new Array(node.length);
+    const pending = [node];
+    let index = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current.kind === 'concat') {
+            pending.push(current.right, current.left);
+            continue;
+        }
+        for (const entry of current.entries) {
+            entries[index] = entry;
+            index += 1;
+        }
+    }
+    return entries;
+}
+function windowSnapshot(node, hasMore, revision, change) {
+    let entries;
+    return {
+        get entries() {
+            entries ??= materialize(node);
+            return entries;
+        },
+        hasMore,
+        revision,
+        change,
+    };
+}
+/** Session-owned event feed; every accepted window mutation publishes synchronously. */
+export class MutableSessionEventSource {
+    listeners = new Set();
+    window = leaf([]);
+    snapshot = windowSnapshot(this.window, false, 0, { kind: 'replace', entries: [] });
+    /** @returns the cached event-window snapshot. */
+    getSnapshot() { return this.snapshot; }
+    /**
+     * Subscribe to synchronous window publication.
+     * @param listener - invalidation callback.
+     * @returns unsubscribe function.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    /**
+     * Replace the complete contiguous window.
+     * @param entries - complete window.
+     * @param hasMore - whether older history remains.
+     */
+    replace(entries, hasMore) {
+        this.window = leaf(entries);
+        this.publish(hasMore, { kind: 'replace', entries });
+    }
+    /**
+     * Prepend one older contiguous page.
+     * @param entries - newly loaded older entries.
+     * @param hasMore - whether still older history remains.
+     */
+    prepend(entries, hasMore) {
+        this.window = concat(leaf(entries), this.window);
+        this.publish(hasMore, { kind: 'prepend', entries });
+    }
+    /**
+     * Append one contiguous live entry.
+     * @param entry - live tail entry.
+     */
+    append(entry) {
+        const entries = [entry];
+        this.window = concat(this.window, leaf(entries));
+        this.publish(this.snapshot.hasMore, {
+            kind: 'append',
+            entries,
+        });
+    }
+    publish(hasMore, change) {
+        this.snapshot = windowSnapshot(this.window, hasMore, this.snapshot.revision + 1, change);
+        notifySubscribers(this.listeners, '[session-controller] event feed');
+    }
+}
+//# sourceMappingURL=events.js.map

package/lib/types/client/contract/session.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The outward session face. Feature packages never see the concrete Session
+ * class: components read lifecycle state through `useSession` (the
+ * ObservableSnapshot half), and orchestration code calls the behavior verbs
+ * below — nothing else. Widening this interface is the explicit act of
+ * widening what features may do to a session (and what every test fixture
+ * must stub); implementation-internal entry points (history staging, wire-frame
+ * dispatch) stay on the class, invisible out here.
+ */
+import type { AttachmentIdType, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { PromptContentPart, QueueAction, SessionRequestId } from '../../types.ts';
+import type { PendingSubmissionImage, SessionSnapshot } from './snapshot.ts';
+/**
+ * Why a local submission echo left the snapshot: `observed` when its durable
+ * `user/message` event or host queue occurrence arrived (with the admitted
+ * image references in prompt order), `failed` when the prompt was rejected,
+ * threw, or was aborted before acceptance.
+ */
+export type PendingSubmissionRetirement = {
+    readonly reason: 'observed';
+    readonly attachments: readonly ImageAttachmentRef[];
+} | {
+    readonly reason: 'failed';
+};
+/** Input registering one local submission echo ahead of its prompt call. */
+export interface BeginSubmissionInput {
+    /** Delivery mode used with the upcoming prompt. */
+    readonly mode: 'queue' | 'steer';
+    /** Prompt text exactly as the upcoming prompt will send it. */
+    readonly text: string;
+    /** Ordered image previews matching the upcoming prompt's image parts. */
+    readonly images: readonly PendingSubmissionImage[];
+    /** Settlement callback fired exactly once when the echo retires. */
+    readonly onRetire?: (retirement: PendingSubmissionRetirement) => void;
+}
+/** One registered submission echo: the identity its prompt must carry, and the pre-prompt escape hatch. */
+export interface SubmissionHandle {
+    /** The prompt RPC identity; pass it to {@link ISession.prompt}. */
+    readonly requestId: SessionRequestId;
+    /** Retire the echo as failed when the caller cannot reach prompt() (serialization failure); no-op after any other settlement. */
+    abandon(): void;
+}
+/** Key-addressed projection read face (the useProjection resolution path; see ProjectionValueStore). */
+export interface ProjectionsFace {
+    /**
+     * The identity-stable bare observable for one projection key (absence is
+     * an `undefined` snapshot, never a missing face).
+     * @param key - projection key.
+     * @returns the key's value face.
+     */
+    faceOf(key: string): ObservableSnapshot<unknown>;
+}
+/** Identity plus the behavior verbs features may invoke on a session. */
+export interface ISession {
+    /** The session's host identity (agent id — same axis). */
+    readonly sessionId: SessionId;
+    /** Host-computed projection values by key (the useProjection seat). */
+    readonly projections: ProjectionsFace;
+    /**
+     * Register one local submission echo in `snapshot.pendingSubmissions`,
+     * synchronously, before the caller serializes and sends the prompt. The
+     * echo retires when a durable `user/message` event or queue occurrence
+     * carrying the returned identity arrives, or when the identified prompt
+     * call fails.
+     * @param input - echo content and the optional settlement callback.
+     * @returns the minted identity for {@link prompt} plus the pre-prompt abandon path.
+     */
+    beginSubmission(input: BeginSubmissionInput): SubmissionHandle;
+    /**
+     * Send a prompt into the session.
+     * @param content - text plus browser-owned temporary image uploads.
+     * @param mode - 'queue' appends a turn; 'steer' interrupts the running one.
+     * @param signal - optional caller cancellation for the complete admission round-trip.
+     * @param requestId - identity from {@link beginSubmission}; a failed identified prompt retires its echo.
+     * @returns acceptance, or the business error (also mirrored into snapshot.promptError).
+     */
+    prompt(content: PromptContentPart[], mode: 'queue' | 'steer', signal?: AbortSignal, requestId?: SessionRequestId): Promise<RemoteResult<{
+        accepted: true;
+    }>>;
+    /**
+     * Resolve one durable image referenced by this session.
+     * @param attachmentId - opaque id found in the folded session log.
+     * @returns the authenticated reference and decoded bytes.
+     */
+    readAttachment(attachmentId: AttachmentIdType): Promise<RemoteResult<{
+        attachment: ImageAttachmentRef;
+        data: Uint8Array;
+    }>>;
+    /**
+     * Apply one edit, remove, or strict steer action to a still-pending queue occurrence.
+     * @param itemId - agent-owned inbox occurrence identity.
+     * @param action - requested queue operation.
+     * @returns acceptance, or a business/transport error.
+     */
+    updateQueue(itemId: MessageId, action: QueueAction): Promise<RemoteResult<{
+        accepted: true;
+    }>>;
+    /**
+     * Cancel the running turn. Pending queued work remains and resumes in FIFO
+     * order after the Host reaches cancellation quiescence.
+     * @returns acceptance, or the business error.
+     */
+    cancel(): Promise<RemoteResult<{
+        accepted: true;
+    }>>;
+    /**
+     * Rename this session (explicit user title; pins it against automatic
+     * regeneration).
+     * @param title - raw title text (the host normalizes acceptance).
+     * @returns the normalized accepted title and its event seq, or the business error.
+     */
+    rename(title: string): Promise<RemoteResult<{
+        title: string;
+        seq: number;
+    }>>;
+    /**
+     * Extend the history window backwards (older messages pagination).
+     * @returns completion; failures land in snapshot.openState/loadingOlder.
+     */
+    loadOlder(): Promise<void>;
+    /**
+     * Page history backwards until the window covers `seq` (inclusive) — the
+     * turn-jump loader. Repeated calls while a jump is paging lower its shared
+     * target and return the in-flight completion; `snapshot.loadingOlder` is
+     * the busy signal for the whole jump.
+     * @param seq - durable event seq the window must reach (a turn's `turn/start` seq).
+     * @returns completion once covered, exhausted, superseded, or failed soft.
+     */
+    loadThrough(seq: number): Promise<void>;
+    /**
+     * Execute one slash-command line against this session's agent — pure
+     * admission semantics (the host executor durably logs the lifecycle).
+     * @param line - the full command line, leading slash included.
+     * @returns the admission result, or the Remote face's error branch.
+     */
+    command(line: string): Promise<RemoteResult<{
+        matched: boolean;
+    }>>;
+}
+/**
+ * The full outward face: behavior verbs plus the Session lifecycle read side
+ * (the `useSession` hook source). This is the type carried by
+ * `SessionBinding.session` and the provide channel.
+ */
+export type SessionFace = ISession & ObservableSnapshot<SessionSnapshot>;
+//# sourceMappingURL=session.d.ts.map

package/lib/types/client/contract/session.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session.js.map

package/lib/types/client/contract/sessions.d.ts

@@ -0,0 +1,125 @@
+/**
+ * The outward sessions-service face — what `ctx.sessions` exposes to feature
+ * packages. Transport entry points and implementation internals stay on
+ * the concrete class. Widening this interface is the
+ * explicit act of widening what features may do to the sessions domain.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { WorkspaceId } from '@deepseek-ai/dsh-workspace/types';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { AgentContext } from '../scope.ts';
+import type { SessionSearchResultItem } from '../sessions/manager.ts';
+import type { SessionBinding, SessionListState } from '../sessions/service.ts';
+import type { SessionFace } from './session.ts';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+export type { AgentContext } from '../scope.ts';
+/** The sessions-service face injected as `ctx.sessions`. */
+export interface ISessions {
+    /** The useSessions standard feed (list rows + current selection; read face — writes stay inside the domain). */
+    readonly list: ObservableSnapshot<SessionListState>;
+    /**
+     * The `session.search` result bound the wire schema fixes, exposed to
+     * presentation as injected data. Not per-connection state: every transport
+     * (fixture included) reports the same number.
+     */
+    readonly searchResultLimit: number;
+    /**
+     * Create or adopt a Session on the Host.
+     * @param opts - target workspace, directory, and optional preallocated identity.
+     * @returns the Session identity after its local binding is addressable.
+     */
+    create(opts?: {
+        workspaceId?: WorkspaceId;
+        cwd?: string;
+        sessionId?: SessionId;
+    }): Promise<SessionId>;
+    /**
+     * Select a session as current.
+     * @param id - session id (must exist in the list; unknown ids fail loud).
+     */
+    open(id: SessionId): void;
+    /**
+     * Open a healthy catalog child through its exact direct-parent address.
+     * @param address - catalog-derived parent and child ids.
+     */
+    openSubagent(address: SubagentAddress): void;
+    /**
+     * Resolve an already discovered direct-parent address without opening it.
+     * @param id - possible addressed child id.
+     * @returns the retained address, when present.
+     */
+    subagentAddress(id: SessionId): SubagentAddress | undefined;
+    /**
+     * Mark whether a catalog menu is consuming live membership updates.
+     * @param parentSessionId - catalog owner.
+     * @param open - current menu state.
+     */
+    setSubagentCatalogOpen(parentSessionId: SessionId, open: boolean): void;
+    /**
+     * Refresh one direct-child catalog.
+     * @param parentSessionId - catalog owner.
+     * @returns completion of the current or newly started refresh.
+     */
+    refreshSubagents(parentSessionId: SessionId): Promise<void>;
+    /** Clear the current selection into the no-session view state. */
+    clear(): void;
+    /**
+     * Refresh the Host-authoritative Session list.
+     * @returns completion of the current or newly started Session-list refresh.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Search the Host's visible message-content index. Results stay
+     * request-local; the list snapshot remains the metadata authority.
+     * @param query - non-blank literal phrase.
+     * @param signal - cancellation for a superseded search.
+     * @returns bounded results, or a business/transport error.
+     */
+    search(query: string, signal: AbortSignal): Promise<RemoteResult<{
+        items: SessionSearchResultItem[];
+        hasMore: boolean;
+    }>>;
+    /**
+     * Fork a session from a completed-turn prefix of the source; on resolution
+     * the child is in the list store and `open()` can target it.
+     * @param opts - source session id, the optional event seq anchoring the
+     *   cut (the boundary is the first turn/end at or after it; an in-log
+     *   anchor in an open turn is unavailable rather than clipped backward),
+     *   and whether to increment an inherited durable title before resolving.
+     * @returns the child session id.
+     * @throws when the fork fails, or when a requested child-title rename fails after creation.
+     */
+    fork(opts: {
+        sessionId: SessionId;
+        atSeq?: number;
+        increaseTitle?: boolean;
+    }): Promise<SessionId>;
+    /**
+     * Resolve an Agent-scoped context view (use-and-discard).
+     * @param id - session id.
+     * @returns scoped ctx, or undefined for a session neither listed nor already scoped.
+     */
+    scope(id: SessionId): AgentContext | undefined;
+    /**
+     * Read the Agent scope tag off a context (service-method boundary: fetch
+     * bundles must reach scope resolution through ctx.sessions).
+     * @param ctx - any client context.
+     * @returns the session id, or undefined on root contexts.
+     */
+    scopeOf(ctx: Context): SessionId | undefined;
+    /**
+     * Resolve the session face behind an Agent-scoped context.
+     * @param ctx - an Agent-scoped context.
+     * @returns the session face, or undefined when the ctx is untagged or its scope was pruned.
+     */
+    sessionOf(ctx: Context): SessionFace | undefined;
+    /**
+     * Resolve the stable session binding (scope-addressed assembly feed).
+     * @param id - session id.
+     * @returns binding, or undefined for a session neither listed nor already scoped.
+     */
+    binding(id: SessionId): SessionBinding | undefined;
+}
+//# sourceMappingURL=sessions.d.ts.map

package/lib/types/client/contract/sessions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sessions.js.map

package/lib/types/client/contract/snapshot.d.ts

@@ -0,0 +1,82 @@
+/** Session-owned observable state excluding Conversation target data. */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
+import type { RemoteFailure } from '@deepseek-ai/dsh-typert-protocol';
+import type { SessionRequestId } from '../../types.ts';
+/** One transient inbox occurrence from the authoritative queue snapshot. */
+export interface QueuedMessage {
+    readonly id: MessageId;
+    readonly messageId: MessageId;
+    readonly placement: 'queued' | 'steering' | 'context';
+    /** Prompt-RPC identity of a browser-submitted occurrence; correlates the local submission echo. */
+    readonly rpcId?: SessionRequestId;
+    readonly content: readonly ContentBlock[];
+    readonly preview: string;
+    readonly text: string | null;
+}
+/** One image displayed by a local submission echo before durable admission. */
+export interface PendingSubmissionImage {
+    /** Browser-owned preview URL; its lifecycle belongs to the submitter, never this snapshot. */
+    readonly previewUrl: string;
+    /** Browser file name, when the file had one. */
+    readonly name?: string;
+    /** Intrinsic pixel width, when the submitter has probed it. */
+    readonly width?: number;
+    /** Intrinsic pixel height, when the submitter has probed it. */
+    readonly height?: number;
+}
+/** Client surface selected when a local submission begins. */
+export type PendingSubmissionPlacement = 'transcript' | 'queued' | 'steering';
+/**
+ * One local prompt-submission echo: inserted synchronously when a submission
+ * begins, so the conversation can show the message before serialization,
+ * transport, and durable admission complete. Client-memory only — reload and
+ * reconnect rebuild the conversation from durable events alone.
+ */
+export interface PendingSubmission {
+    /** The prompt RPC identity; the durable `user/message` source echoes it as `rpcId`. */
+    readonly requestId: SessionRequestId;
+    /** Expected surface until the Host reports the admitted queue or durable occurrence. */
+    readonly placement: PendingSubmissionPlacement;
+    /** Client wall-clock ms when the submission began. */
+    readonly time: number;
+    /** Prompt text exactly as it will be sent (one text block). */
+    readonly text: string;
+    /** Ordered image previews matching the prompt's image parts. */
+    readonly images: readonly PendingSubmissionImage[];
+}
+/** History-open lifecycle of a Session event window. */
+export type OpenState = 'cold' | 'loading' | 'open' | 'error';
+/** Send/stop failure surfaced by Session consumers. */
+export interface PromptError {
+    readonly op: 'send' | 'stop';
+    readonly error: RemoteFailure;
+}
+/** Immutable Session lifecycle and control snapshot. */
+export interface SessionSnapshot {
+    readonly sessionId: SessionId;
+    readonly queue: readonly QueuedMessage[];
+    /** Local prompt-submission echoes not yet observed as durable events or queue occurrences. */
+    readonly pendingSubmissions: readonly PendingSubmission[];
+    readonly running: boolean;
+    readonly subagent: {
+        readonly address: SubagentAddress;
+        /** Absent until the direct-parent catalog resolves. */
+        readonly parentAvailable?: boolean;
+    } | null;
+    readonly removed: boolean;
+    readonly openState: OpenState;
+    readonly openError: RemoteFailure | null;
+    readonly hasMore: boolean;
+    readonly loadingOlder: boolean;
+    readonly promptError: PromptError | null;
+    readonly blank: boolean;
+    readonly lastAgentError: string | null;
+    /** A prompt call has begun on this Client Session object. */
+    readonly promptAttempted: boolean;
+    /** The first accepted prompt has not reached a durable `turn/start` event. */
+    readonly awaitingFirstTurn: boolean;
+}
+//# sourceMappingURL=snapshot.d.ts.map

package/lib/types/client/contract/snapshot.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot.js.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,30 @@
+/** Client Session object layer, Agent scopes, and Remote lifecycle wiring. */
+import type { Context } from '@deepseek-ai/cordis';
+export { createSessionControlStream, SessionEventStream, SESSION_SEARCH_RESULT_LIMIT, SESSION_SEARCH_SNIPPET_MAX_CODE_POINTS, } from './transport.ts';
+export type { ClientSessionPageRequest, SessionControlStream, SessionControlStreamOptions, SessionEventStreamOptions, SessionJournalChange, SessionRemote, } from './transport.ts';
+export { createScope, scopeOf } from './scope.ts';
+export type { AgentContext, AgentScopeHandle } from './scope.ts';
+export { SessionCreateError, SessionForkError } from './sessions/service.ts';
+export type { SessionBinding, SessionListState, SessionSummary } from './sessions/service.ts';
+export type { SessionListPhase, SessionListSnapshot, SessionSearchResultItem, SubagentCatalogSnapshot, } from './sessions/manager.ts';
+export type { Session } from './sessions/session.ts';
+export type { ProjectionsBaseline, ProjectionValueStore, SessionProjectionMap, UseProjection, } from './sessions/projection-store.ts';
+export type { BeginSubmissionInput, ISession, PendingSubmissionRetirement, ProjectionsFace, SessionFace, SubmissionHandle, } from './contract/session.ts';
+export type { ISessions } from './contract/sessions.ts';
+export { MutableSessionEventSource } from './contract/events.ts';
+export type { SessionEventChange, SessionEventLike, SessionEventLikeEntry, SessionEventSource, SessionEventWindow, SessionLiveEventEntry, } from './contract/events.ts';
+export type { OpenState, PendingSubmission, PendingSubmissionImage, PendingSubmissionPlacement, PromptError, QueuedMessage, SessionSnapshot, } from './contract/snapshot.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Client Session object layer and Agent scope owner. */
+        sessions: import('./contract/sessions.ts').ISessions;
+    }
+}
+/** Required Remote and Context projection services. */
+export declare const inject: string[];
+/**
+ * Install Client Session state and its reconnecting control stream.
+ * @param ctx - Client Cordis context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map