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

package/lib/types/client/time-zone.d.ts

@@ -0,0 +1,8 @@
+/** Browser-owned time-zone sampling for prompt RPC provenance. */
+/**
+ * Resolve the current browser IANA zone for one outbound operation.
+ * @returns The browser-provided canonical zone.
+ * @throws when the runtime cannot provide a non-empty zone.
+ */
+export declare function resolvedClientTimeZone(): string;
+//# sourceMappingURL=time-zone.d.ts.map

package/lib/types/client/time-zone.js

@@ -0,0 +1,14 @@
+/** Browser-owned time-zone sampling for prompt RPC provenance. */
+/**
+ * Resolve the current browser IANA zone for one outbound operation.
+ * @returns The browser-provided canonical zone.
+ * @throws when the runtime cannot provide a non-empty zone.
+ */
+export function resolvedClientTimeZone() {
+    const timeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (typeof timeZone !== 'string' || timeZone.length === 0) {
+        throw new Error('browser time zone is unavailable');
+    }
+    return timeZone;
+}
+//# sourceMappingURL=time-zone.js.map

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

@@ -0,0 +1,73 @@
+/** Session-specific adapters for Gateway-owned Remote stream lifecycles. */
+import { RemoteJournalStream, RemoteSnapshotStream, RemoteStreamCarrierError, type ClientRemote, type RemoteJournalFrame } from '@deepseek-ai/dsh-api-gateway/client';
+import type { SessionAddress, SessionControlFrame, SessionHistoryRecord, SessionPage, SessionPageRequest, SessionProjectionBaseline } from '../types.ts';
+import type { SessionEventLikeEntry, SessionLiveEventEntry } from './contract/events.ts';
+import type { SessionRemotes } from './sessions/remotes.ts';
+export { SESSION_SEARCH_RESULT_LIMIT, SESSION_SEARCH_SNIPPET_MAX_CODE_POINTS, } from '../types.ts';
+/** Pagination fields bound to an already-addressed Session journal. */
+export type ClientSessionPageRequest = Omit<SessionPageRequest, 'address' | 'throughSeq'>;
+/** Complete generated `ctx.remote.session` namespace. */
+export type SessionRemote = ClientRemote['session'];
+/** Opening metadata carried only by a follow snapshot, never by loadOlder pages. */
+interface SessionJournalPage extends SessionPage {
+    readonly projections?: SessionProjectionBaseline;
+}
+/** One complete publication from the Session journal stream. */
+export type SessionJournalChange = {
+    readonly type: 'replace' | 'prepend';
+    readonly page: SessionJournalPage;
+    readonly entries: readonly SessionEventLikeEntry[];
+    readonly hasMore: boolean;
+} | {
+    readonly type: 'append';
+    readonly entry: SessionLiveEventEntry;
+};
+type SessionControlBaselineFrame = Extract<SessionControlFrame, {
+    type: 'baseline';
+}>;
+type SessionControlDeltaFrame = Exclude<SessionControlFrame, SessionControlBaselineFrame>;
+/** Gateway-owned control snapshot stream configured for Session frames. */
+export type SessionControlStream = RemoteSnapshotStream<SessionControlBaselineFrame, SessionControlDeltaFrame>;
+/** Domain sinks used by the Host-wide Session control stream. */
+export interface SessionControlStreamOptions {
+    /** Apply a complete baseline or one later update. */
+    readonly accept: (frame: SessionControlFrame) => void;
+    /** Observe a retryable carrier loss before reconnection. */
+    readonly carrierFailed?: (error: RemoteStreamCarrierError) => void;
+    /** Publish a terminal business or protocol failure. */
+    readonly failed: (error: unknown) => void;
+}
+/** Domain sinks used by one addressed Session event journal. */
+export interface SessionEventStreamOptions {
+    /** Apply one complete event-window change. */
+    readonly publish: (change: SessionJournalChange) => void;
+    /** Observe a retryable carrier loss before reconnection. */
+    readonly carrierFailed?: (error: RemoteStreamCarrierError) => void;
+    /** Publish a terminal stream, page, or protocol failure after opening. */
+    readonly failed: (error: unknown) => void;
+}
+/**
+ * Create the Host-wide Session control snapshot stream.
+ * @param remote - generated Session namespace and Gateway stream factory.
+ * @param options - Session state destinations.
+ * @returns an unstarted stream owned by the Client Session runtime.
+ */
+export declare function createSessionControlStream(remote: SessionRemotes, options: SessionControlStreamOptions): SessionControlStream;
+/** Gateway-owned event journal bound to one ordinary or direct-subagent Session address. */
+export declare class SessionEventStream extends RemoteJournalStream<SessionJournalPage, SessionHistoryRecord, number, ClientSessionPageRequest> {
+    private readonly remote;
+    private readonly address;
+    /**
+     * @param remote - generated Session namespace and Gateway stream factory.
+     * @param address - durable ordinary-Session or direct-subagent address.
+     * @param options - Session event-window destinations.
+     */
+    constructor(remote: SessionRemotes, address: SessionAddress, options: SessionEventStreamOptions);
+    /** @inheritdoc */
+    protected follow(request: ClientSessionPageRequest, signal: AbortSignal): AsyncIterable<RemoteJournalFrame<SessionHistoryRecord, number, SessionJournalPage>>;
+    /** @inheritdoc */
+    protected readPage(request: ClientSessionPageRequest, throughSeq: number, signal: AbortSignal): Promise<SessionJournalPage>;
+    /** @inheritdoc */
+    protected repairRequest(request: ClientSessionPageRequest): ClientSessionPageRequest;
+}
+//# sourceMappingURL=transport.d.ts.map

package/lib/types/client/transport.js

@@ -0,0 +1,106 @@
+/** Session-specific adapters for Gateway-owned Remote stream lifecycles. */
+import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+import { RemoteJournalStream, RemoteSnapshotStream, RemoteStreamCarrierError, } from '@deepseek-ai/dsh-api-gateway/client';
+import { historyEntries, historyRecordFirstSeq, historyRecordLastSeq, } from "./sessions/history-records.js";
+export { SESSION_SEARCH_RESULT_LIMIT, SESSION_SEARCH_SNIPPET_MAX_CODE_POINTS, } from "../types.js";
+function toSessionJournalChange(change) {
+    switch (change.type) {
+        case 'replace':
+        case 'prepend':
+            return { ...change, entries: historyEntries(change.entries) };
+        case 'append': {
+            if (change.entry.type !== 'event') {
+                throw new RemoteError('gateway/internal', 'session live stream emitted a packed history record', {});
+            }
+            return {
+                type: 'append',
+                entry: change.entry,
+            };
+        }
+    }
+}
+/**
+ * Create the Host-wide Session control snapshot stream.
+ * @param remote - generated Session namespace and Gateway stream factory.
+ * @param options - Session state destinations.
+ * @returns an unstarted stream owned by the Client Session runtime.
+ */
+export function createSessionControlStream(remote, options) {
+    const stream = remote.$stream({
+        name: 'session control stream',
+        open: signal => remote.session.control(signal),
+        ended: accepted => accepted
+            ? new RemoteStreamCarrierError('session control stream ended without a terminal result')
+            : new Error('session control stream ended before its opening snapshot'),
+        ...(options.carrierFailed === undefined ? {} : { carrierFailed: options.carrierFailed }),
+    });
+    return new RemoteSnapshotStream(stream, {
+        name: 'session control stream',
+        isSnapshot: (frame) => frame.type === 'baseline',
+        replace: options.accept,
+        update: options.accept,
+        failed: options.failed,
+    });
+}
+/** Gateway-owned event journal bound to one ordinary or direct-subagent Session address. */
+export class SessionEventStream extends RemoteJournalStream {
+    remote;
+    address;
+    /**
+     * @param remote - generated Session namespace and Gateway stream factory.
+     * @param address - durable ordinary-Session or direct-subagent address.
+     * @param options - Session event-window destinations.
+     */
+    constructor(remote, address, options) {
+        super(remote, {
+            name: 'session event stream',
+            emptyCursor: -1,
+            entries: page => page.records,
+            hasMore: page => page.hasMore,
+            first: historyRecordFirstSeq,
+            last: historyRecordLastSeq,
+            compare: (left, right) => left - right,
+            follows: (left, right) => right === left + 1,
+            publish: (change) => { options.publish(toSessionJournalChange(change)); },
+            ...(options.carrierFailed === undefined
+                ? {}
+                : { carrierFailed: options.carrierFailed }),
+            failed: options.failed,
+        });
+        this.remote = remote;
+        this.address = address;
+    }
+    /** @inheritdoc */
+    async *follow(request, signal) {
+        for await (const frame of this.remote.session.follow({
+            address: this.address,
+            ...(request.maxMessages === undefined ? {} : { maxMessages: request.maxMessages }),
+        }, signal)) {
+            if (frame.type === 'snapshot') {
+                yield {
+                    type: 'opened',
+                    cursor: frame.cursor,
+                    page: {
+                        records: frame.records,
+                        hasMore: frame.hasMore,
+                        projections: frame.projections,
+                    },
+                };
+                continue;
+            }
+            yield { type: 'entry', entry: frame };
+        }
+    }
+    /** @inheritdoc */
+    async readPage(request, throughSeq, signal) {
+        const result = await this.remote.session.page({ address: this.address, throughSeq, ...request }, signal);
+        if (!result.ok)
+            throw result.error;
+        return result.value;
+    }
+    /** @inheritdoc */
+    repairRequest(request) {
+        return request.maxMessages === undefined ? {} : { maxMessages: request.maxMessages };
+    }
+}
+//# sourceMappingURL=transport.js.map

package/lib/types/commands.d.ts

@@ -0,0 +1,69 @@
+/** Session commands whose activation policy is explicit at each Remote method. */
+import type { Context } from '@deepseek-ai/cordis';
+import { ApiSessionAgentController } from './agent.ts';
+import type { SessionAttachmentRequest, SessionAttachmentValue, SessionCancelRequest, SessionCancelValue, SessionCreateRequest, SessionCreateValue, SessionForkRequest, SessionForkValue, SessionPromptRequest, SessionPromptValue, SessionRenameRequest, SessionRenameValue, SessionSelectModelRequest, SessionSelectModelValue, SessionUpdateQueueRequest, SessionUpdateQueueValue } from './types.ts';
+/** Implements Session business commands delegated by the Session Controller Remote service. */
+export declare class SessionCommandController {
+    private readonly ctx;
+    private readonly agents;
+    private readonly defaultCwd;
+    /**
+     * @param ctx - Host context carrying Agent, model, attachment, title, and Workspace services.
+     * @param agents - sole owner of create, resume, and Session-local model selection.
+     * @param defaultCwd - project directory used when create names neither a Workspace nor a cwd.
+     */
+    constructor(ctx: Context, agents: ApiSessionAgentController, defaultCwd: string);
+    /**
+     * Create or idempotently adopt one ordinary Session.
+     * @param request - requested identity, location, and Agent preset.
+     * @returns the Session identity and resolved preset when configured.
+     */
+    create(request: SessionCreateRequest): Promise<SessionCreateValue>;
+    /**
+     * Validate and install one Session-local model selection.
+     * @param request - Session identity and requested model selection.
+     * @returns the normalized selection installed for the Session.
+     */
+    selectModel(request: SessionSelectModelRequest): Promise<SessionSelectModelValue>;
+    /**
+     * Normalize and append a user-owned Session title.
+     * @param request - Session identity and proposed title.
+     * @returns the accepted title and durable event sequence.
+     */
+    rename(request: SessionRenameRequest): Promise<SessionRenameValue>;
+    /**
+     * Create a new ordinary Session from one completed-turn prefix.
+     * @param request - source Session and optional event anchor.
+     * @returns the new Session identity.
+     */
+    fork(request: SessionForkRequest): Promise<SessionForkValue>;
+    /**
+     * Admit one browser prompt after explicit Agent resume and image validation.
+     * @param request - Session identity, prompt content, source metadata, and delivery mode.
+     * @returns acknowledgement that the Agent accepted the prompt.
+     */
+    prompt(request: SessionPromptRequest): Promise<SessionPromptValue>;
+    /**
+     * Read one durable image after proving the Session log references it.
+     * @param request - Session and attachment identities used for authorization.
+     * @returns the durable attachment reference and base64-encoded bytes.
+     */
+    attachment(request: SessionAttachmentRequest): Promise<SessionAttachmentValue>;
+    /**
+     * Mutate one still-pending queue occurrence without resuming a cold Agent.
+     * @param request - Session, queue item, and requested mutation.
+     * @returns acknowledgement that the queue mutation was applied.
+     */
+    updateQueue(request: SessionUpdateQueueRequest): SessionUpdateQueueValue;
+    /**
+     * Cancel one live ordinary Agent while retaining pending inbox work.
+     * @param request - Session whose active Agent turn is cancelled.
+     * @returns acknowledgement that cancellation was requested.
+     */
+    cancel(request: SessionCancelRequest): SessionCancelValue;
+    private resolveAgent;
+    private rejectCreation;
+    private readSessionState;
+    private forkWorkspace;
+}
+//# sourceMappingURL=commands.d.ts.map