dsh-input-assistant 0.0.0-stage → 0.1.3

package/lib/host/rpc.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const rpcPayloadSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        status: "status";
+        generate: "generate";
+        cancel: "cancel";
+        "drafts/list": "drafts/list";
+        "drafts/save": "drafts/save";
+        "drafts/delete": "drafts/delete";
+        "drafts/clear": "drafts/clear";
+        "settings/get": "settings/get";
+        "settings/set": "settings/set";
+    }>;
+    data: z.ZodJSONSchema;
+}, z.core.$strict>;
+export type RpcPayload = z.infer<typeof rpcPayloadSchema>;
+/** Explicit strict codecs let the normal Gateway route our private method. */
+export declare const remoteInfo: import("@deepseek-ai/dsh-typert-protocol").TypertRemoteInfo<Readonly<Record<string, import("@deepseek-ai/dsh-typert-protocol").TypertRemoteMethod<object, unknown, "unary", never, unknown> | import("@deepseek-ai/dsh-typert-protocol").TypertRemoteMethod<object, unknown, "stream", unknown, unknown>>>>;
+export declare const hostContribution: {
+    package: string;
+    face: "host";
+    schemas: never[];
+    model: {
+        services: never[];
+        events: never[];
+        objects: never[];
+    };
+    invocations: readonly import("@deepseek-ai/dsh-typert-protocol").InvocationDescriptor[];
+};

package/lib/host/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { Session } from '@deepseek-ai/dsh-session';
+import { type AssistantStatus, type GenerationResult } from '../core/index';
+import { AssistantStorage } from './storage';
+import type { RpcPayload } from './rpc';
+export declare class AssistantHostRuntime {
+    private readonly ctx;
+    private readonly storage;
+    private readonly mount;
+    private readonly instances;
+    private readonly scheduler;
+    private disposed;
+    constructor(ctx: Context, storage: AssistantStorage);
+    private state;
+    private session;
+    private transcript;
+    private sessionRoute;
+    status(id: string, signal: AbortSignal): Promise<AssistantStatus>;
+    private result;
+    private current;
+    generate(input: unknown, signal: AbortSignal): Promise<GenerationResult>;
+    cancel(id: string, requestId?: string): boolean;
+    changed(session: Session): void;
+    dispose(): void;
+    invoke(payload: RpcPayload, signal: AbortSignal): Promise<unknown>;
+}

package/lib/host/storage.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { type Domain } from '@deepseek-ai/dsh-storage-domain';
+import { type AssistantConfig, type StoredDraft } from '../core/types';
+export declare function createDomainSpec(initial: AssistantConfig): {
+    name: string;
+    version: number;
+    layout: "per-record";
+    global: {
+        schema: z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>;
+        initial: {
+            version: 1;
+            settings: {
+                optimizeEnabled: boolean;
+                stashEnabled: boolean;
+                optimizationStrength: import("../core").OptimizationStrength;
+                nextEnabled: boolean;
+                completionEnabled: boolean;
+                displayMode: "ghost" | "panel";
+                debounceMs: number;
+                minIntervalMs: number;
+                maxHistoryChars: number;
+                maxDraftChars: number;
+                maxNextChars: number;
+                maxCompletionChars: number;
+                optimizeTimeoutMs: number;
+                suggestionTimeoutMs: number;
+                provider: string;
+                model: string;
+            };
+        };
+    };
+    tables: {
+        drafts: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            version: 1;
+            drafts: StoredDraft[];
+        }>;
+    };
+};
+export type AssistantDomain = Domain<ReturnType<typeof createDomainSpec>>;
+/** Serializes read-modify-write operations, including the very first save. */
+export declare class AssistantStorage {
+    private readonly domain;
+    private chain;
+    constructor(domain: () => Promise<AssistantDomain>);
+    private transaction;
+    settings(): Promise<AssistantConfig>;
+    updateSettings(patch: Partial<AssistantConfig>): Promise<AssistantConfig>;
+    list(sessionId: string): Promise<StoredDraft[]>;
+    save(sessionId: string, text: string, replaceId?: string): Promise<StoredDraft[]>;
+    delete(sessionId: string, id?: string): Promise<StoredDraft[]>;
+}

package/lib/host/transcript.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { HistoryMessage } from '../core/types';
+/** Host-only projection: never adds records or messages to the user's session. */
+export interface TranscriptState {
+    entries: HistoryMessage[];
+    currentTurn: number;
+    sourceTurnId: string | null;
+    running: boolean;
+    pendingAssistant: string | null;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        inputAssistantTranscript: TranscriptState;
+    }
+}
+export declare const transcriptSchema: z.ZodType<TranscriptState>;
+export declare function emptyTranscript(): TranscriptState;
+export declare function foldTranscript(state: TranscriptState, event: SessionEvent): TranscriptState;

package/lib/index.d.ts

@@ -0,0 +1,64 @@
+import type { Context } from '@deepseek-ai/cordis';
+import schema from '@deepseek-ai/schemastery';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { type AssistantConfig } from './core/index';
+import { AssistantHostRuntime } from './host/runtime';
+import { type RpcPayload } from './host/rpc';
+export type Config = Partial<AssistantConfig>;
+export declare const name = "input-assistant";
+export declare const inject: string[];
+export declare const Config: schema<Schemastery.ObjectS<NoInfer<{
+    optimizeEnabled: schema<boolean, boolean, "defined">;
+    stashEnabled: schema<boolean, boolean, "defined">;
+    optimizationStrength: schema<"light" | "standard" | "deep", "light" | "standard" | "deep", "defined">;
+    nextEnabled: schema<boolean, boolean, "defined">;
+    completionEnabled: schema<boolean, boolean, "defined">;
+    displayMode: schema<"ghost" | "panel", "ghost" | "panel", "defined">;
+    debounceMs: schema<number, number, "defined">;
+    minIntervalMs: schema<number, number, "defined">;
+    maxHistoryChars: schema<number, number, "defined">;
+    maxDraftChars: schema<number, number, "defined">;
+    maxNextChars: schema<number, number, "defined">;
+    maxCompletionChars: schema<number, number, "defined">;
+    optimizeTimeoutMs: schema<number, number, "defined">;
+    suggestionTimeoutMs: schema<number, number, "defined">;
+    provider: schema<string, string, "defined">;
+    model: schema<string, string, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    optimizeEnabled: schema<boolean, boolean, "defined">;
+    stashEnabled: schema<boolean, boolean, "defined">;
+    optimizationStrength: schema<"light" | "standard" | "deep", "light" | "standard" | "deep", "defined">;
+    nextEnabled: schema<boolean, boolean, "defined">;
+    completionEnabled: schema<boolean, boolean, "defined">;
+    displayMode: schema<"ghost" | "panel", "ghost" | "panel", "defined">;
+    debounceMs: schema<number, number, "defined">;
+    minIntervalMs: schema<number, number, "defined">;
+    maxHistoryChars: schema<number, number, "defined">;
+    maxDraftChars: schema<number, number, "defined">;
+    maxNextChars: schema<number, number, "defined">;
+    maxCompletionChars: schema<number, number, "defined">;
+    optimizeTimeoutMs: schema<number, number, "defined">;
+    suggestionTimeoutMs: schema<number, number, "defined">;
+    provider: schema<string, string, "defined">;
+    model: schema<string, string, "defined">;
+}>>, "plain">;
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        inputAssistant: InputAssistantService;
+    }
+}
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        'input-assistant/error': {
+            code: string;
+        };
+        'input-assistant/forbidden': Record<string, never>;
+    }
+}
+/** One strictly described Remote endpoint; the standard Gateway owns transport. */
+export declare class InputAssistantService extends TypertRemoteService {
+    private readonly runtime;
+    constructor(ctx: Context, runtime: AssistantHostRuntime);
+    call(payload: RpcPayload, signal: AbortSignal): Promise<unknown>;
+}
+export declare function apply(ctx: Context, config?: Config): void;