@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,435 @@
+import { CompactionAgentContext, CompactionEngine, CompactionResult, ManualCompactAgentContext, compactCheckpointSource } from "@deepseek-ai/dsh-compaction";
+import { GenerateOptions, LlmAdapter, LlmModelInfo, LlmResolvedModelInfo, Message, StreamChunk, UserMessage } from "@deepseek-ai/dsh-llm";
+import { AgentCancelCause, Session, SessionId, SessionSeq } from "@deepseek-ai/dsh-session";
+import { KvTable } from "@deepseek-ai/dsh-storage-domain";
+import { PromptAssembly } from "@deepseek-ai/dsh-system-prompt";
+import { CompactionOutcome, CompactionReplacedEventPayload, HistoryItem, HistorySeed, NamedTool, SessionSnapshot, ToolDefinition } from "../vendor/nanocodex/node/index.d.mts";
+import { CredentialRef } from "@deepseek-ai/dsh-credentials";
+import z from "@deepseek-ai/schemastery";
+import { AttachmentStore } from "@deepseek-ai/dsh-attachment";
+import { Agent as Agent$1, AgentFactory, AgentHandle, AgentOptions, AgentStatus, CancelOptions, CreateAgentOptions, Inbox, ResumeAgentOptions } from "@deepseek-ai/dsh-agent";
+import { FileSystem } from "@deepseek-ai/dsh-fs";
+import { ToolDefinition as ToolDefinition$1, ToolExecutionResult, ToolRunContext, ToolRuntime } from "@deepseek-ai/dsh-tools";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/constants.d.ts
+export declare const INTERRUPTED_TOOL_OUTPUT = "Tool execution was interrupted before a complete result was recorded. It may have had side effects; inspect the current state before retrying.";
+export declare const PLUGIN_NAME: "dsh-nanocodex";
+export declare const APPLY_PATCH_NAME: "apply_patch";
+export declare const APPLY_PATCH_DESCRIPTION: "Apply a raw Codex patch to text files in the active workspace. Call apply_patch(input: string) with a complete Add File/Update File patch. Supports Add File and Update File with contextual hunks; Delete File and Move to are not supported.";
+export declare const APPLY_PATCH_GRAMMAR: string;
+export declare const DEFAULT_MAX_PATCH_CHARS = 4000000;
+export declare const DEFAULT_MAX_PATCH_FILES = 64;
+export declare const DEFAULT_MAX_PATCH_FILE_BYTES = 4000000;
+export declare const MODEL_CONTEXT_WINDOW = 200000;
+export declare const SUPPORTED_MODELS: readonly ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra"];
+export type NanocodexModel = (typeof SUPPORTED_MODELS)[number];
+export declare function isSupportedModel(value: string | undefined): value is NanocodexModel;
+export declare function isSupportedRoute(provider: string | undefined, api: string | undefined): boolean;
+//#endregion
+//#region src/engine.d.ts
+export interface NanocodexCompactionResult {
+  readonly summary: string;
+  readonly outcome: CompactionOutcome;
+  readonly selection: NanocodexCompactionSelection;
+  /** The engine-owned checkpoint captured immediately after installation. */
+  readonly snapshot: SessionSnapshot;
+  readonly provider: string;
+  readonly model: NanocodexModel;
+}
+export interface NanocodexAutomaticCompaction {
+  readonly outcome: CompactionOutcome;
+  readonly phase: CompactionReplacedEventPayload["phase"];
+  readonly afterModelCallIndex: number;
+  /** DSH surface nodes admitted to the engine at this compaction boundary. */
+  readonly admittedSurfaceSeqs: readonly SessionSeq[];
+}
+type NanocodexCompactionMappingBoundary = Pick<NanocodexAutomaticCompaction, "phase" | "afterModelCallIndex" | "admittedSurfaceSeqs">;
+export interface NanocodexCompactionSelection {
+  readonly shadowedRange: {
+    readonly start: SessionSeq;
+    readonly end: SessionSeq;
+  };
+  readonly shadowedSeqs: readonly SessionSeq[];
+}
+export interface EngineRunResult {
+  readonly provider: string;
+  readonly model: NanocodexModel;
+  /** The exact public Nanocodex snapshot at the successful DSH boundary. */
+  readonly snapshot: SessionSnapshot;
+  /**
+   * Nanocodex may compact its private model context during a normal turn. The
+   * adapter projects the validated private checkpoint into DSH only after the
+   * turn has completed successfully.
+   */
+  readonly automaticCompactions: readonly NanocodexAutomaticCompaction[];
+}
+interface SurfaceBoundary {
+  readonly replaceGeneration: number;
+  readonly surfaceSeqs: readonly SessionSeq[];
+  readonly messageCount: number;
+  readonly fingerprint: string;
+}
+export interface NanocodexCheckpoint {
+  readonly version: 1;
+  readonly provider: string;
+  readonly model: NanocodexModel;
+  readonly boundary: SurfaceBoundary;
+  readonly snapshot: SessionSnapshot;
+}
+export type NanocodexCheckpointStore = Pick<KvTable<SessionId, NanocodexCheckpoint>, "get" | "put">;
+export declare const nanocodexCheckpointDomain: {
+  name: string;
+  version: number;
+  layout: "per-record";
+  tables: {
+    sessions: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<SessionId, NanocodexCheckpoint>;
+  };
+};
+/** The only provider-facing owner in the DSH Nanocodex package. */
+export declare class NanocodexEngine {
+  private readonly ctx;
+  private readonly checkpoints;
+  private quickJsPromise;
+  private readonly requestSurfaceGeneration;
+  private readonly runtimes;
+  constructor(ctx: Context, checkpoints: NanocodexCheckpointStore);
+  private quickJs;
+  run(agent: Agent$1, previousMessages: readonly Message[], messages: readonly UserMessage[], assembly: PromptAssembly, turn: number, step: number, signal: AbortSignal, advanceStep: () => number): Promise<EngineRunResult>;
+  /** Release the retained Nanocodex host after DSH has drained the Agent. */
+  dispose(agent: Agent$1): Promise<void>;
+  /** Invalidate a runtime whose private context no longer matches DSH. */
+  invalidate(agent: Agent$1): Promise<void>;
+  /** Mark the retained runtime at the current authoritative DSH surface. */
+  markSurfaceBoundary(agent: Agent$1): void;
+  private consumeCompactionOutcome;
+  private runtimeFor;
+  /**
+   * Map Nanocodex's exact retained-tail identities to the current DSH surface.
+   * The engine owns the selection; DSH never guesses from a fixed message count.
+   */
+  mapCompactionOutcome(agent: Pick<Agent$1, "session">, outcome: CompactionOutcome, signal: AbortSignal, mapping?: NanocodexCompactionMappingBoundary): Promise<NanocodexCompactionSelection>;
+  private resolveCompactionInstruction;
+  /** Persist the exact successful engine snapshot at the current DSH surface. */
+  persistCheckpoint(agent: Agent$1, provider: string, model: NanocodexModel, snapshot: SessionSnapshot, signal: AbortSignal): Promise<void>;
+  private createNodeAgent;
+  private closeRuntime;
+  /** Run custom compaction on the already-live Nanocodex runtime. */
+  compact(agent: Agent$1, signal: AbortSignal): Promise<NanocodexCompactionResult>;
+  private appendRequestFacts;
+  private appendToolResult;
+}
+//#endregion
+//#region src/agent.d.ts
+/**
+ * DSH's public Agent handle backed by Nanocodex turns. DSH owns the queue and
+ * durable log; each model step is hydrated from the active surface.
+ */
+export declare class NanocodexAgent implements Agent$1 {
+  readonly id: Agent$1["id"];
+  readonly options: AgentOptions;
+  readonly session: Session;
+  readonly inbox: Inbox;
+  readonly ctx: Context;
+  private readonly loopCtx;
+  private readonly engine;
+  private readonly scope;
+  private readonly dispatch;
+  private phase;
+  private activityDone;
+  private runtimeContextText;
+  constructor(loopCtx: Context, id: Agent$1["id"], options: AgentOptions, session: Session, engine: NanocodexEngine);
+  get status(): AgentStatus;
+  send(message: UserMessage, target: "next-turn" | "next-step", wakeup: boolean): void;
+  followup(message: UserMessage): void;
+  steer(message: UserMessage): void;
+  inject(message: UserMessage): void;
+  cancel(cause: AgentCancelCause, options?: CancelOptions): void;
+  whenIdle(): Promise<void>;
+  private waitForIdle;
+  runMaintenance<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;
+  wakeDriver(wakeAfterAbort?: boolean): void;
+  dispose(): Promise<void>;
+  private kick;
+  private preStep;
+  private turn;
+  private findRuntimeContext;
+  private projectRuntimeContext;
+}
+//#endregion
+//#region src/compaction-engine.d.ts
+type CommandId = NonNullable<Parameters<typeof compactCheckpointSource>[1]>;
+/**
+ * Minimal DSH compaction owner. The checkpoint is model-private and lands only
+ * as the normal non-expandable compact checkpoint message. The selected range
+ * and all transaction markers remain fully durable in DSH's event log.
+ */
+export declare class NanocodexCompactionEngine extends CompactionEngine {
+  private readonly engine;
+  constructor(ctx: Context, engine: NanocodexEngine);
+  compactIfNeeded(agent: CompactionAgentContext, _trigger: "pressure" | "context-overflow", signal: AbortSignal): Promise<CompactionResult | null>;
+  compactNow(agent: ManualCompactAgentContext, signal: AbortSignal, sourceCommandId?: CommandId): Promise<CompactionResult | null>;
+  compactRegion(start: SessionSeq, end: SessionSeq, agent: CompactionAgentContext, signal?: AbortSignal): Promise<CompactionResult>;
+  /**
+   * Commit a summary produced by Nanocodex's automatic private compaction.
+   * Nanocodex owns the model call; DSH still owns the durable surface and the
+   * non-expandable checkpoint visible to Companion.
+   */
+  commitAutomaticSummary(agent: CompactionAgentContext, automatic: NanocodexAutomaticCompaction, signal: AbortSignal): Promise<CompactionResult>;
+  private compactSelection;
+  private beginCompaction;
+  private endFailedCompaction;
+  private commitSummary;
+}
+//#endregion
+//#region src/factory.d.ts
+/** AgentFactory implementation installed by the selected Cordis row. */
+export declare class NanocodexFactory implements AgentFactory {
+  private readonly ctx;
+  private readonly engine;
+  private readonly live;
+  private closed;
+  constructor(ctx: Context, engine: NanocodexEngine);
+  createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+  resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
+  disposeAll(): Promise<void>;
+  private publish;
+}
+//#endregion
+//#region src/history.d.ts
+export interface HistoryContext {
+  readonly attachments: AttachmentStore;
+}
+/** Pi Responses IDs store call_id|item_id; only the call part pairs results. */
+export declare function historyToolCallId(value: string): string;
+export interface HistoryProjectionItem {
+  readonly message: Message;
+  readonly item: HistoryItem;
+}
+export interface HistoryProjection extends HistorySeed {
+  readonly items: readonly HistoryProjectionItem[];
+}
+/**
+ * Convert the authoritative active DSH surface to Nanocodex's typed history.
+ * Tool calls are represented as history items only; no handler is invoked while
+ * hydrating a session.
+ */
+export declare function buildHistoryProjection(messages: readonly Message[], ctx: HistoryContext, signal?: AbortSignal): Promise<HistoryProjection>;
+export declare function buildHistorySeed(messages: readonly Message[], ctx: HistoryContext, signal?: AbortSignal): Promise<HistorySeed>;
+export interface PromptInputContext {
+  readonly attachments: AttachmentStore;
+}
+export type NanocodexPromptItem = {
+  readonly type: "text";
+  readonly text: string;
+} | {
+  readonly type: "image";
+  readonly image_url: string;
+  readonly detail: "auto";
+};
+/** Convert newly admitted DSH user content into one Nanocodex prompt. */
+export declare function buildPromptInput(messages: readonly Message[], ctx: PromptInputContext, signal?: AbortSignal): Promise<string | readonly NanocodexPromptItem[]>;
+export declare function plainText(messages: readonly Message[]): string;
+//#endregion
+//#region src/llm-adapter.d.ts
+/** Native DSH model-catalog adapter for the Nanocodex-owned routes. */
+export declare class NanocodexLlmAdapter extends LlmAdapter {
+  private readonly ctx;
+  constructor(ctx: Context);
+  providerInfo(provider: string): {
+    id: "openai" | "openai-codex-responses";
+    name: string;
+  };
+  listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+  resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+  /**
+   * The retained session-title consumer uses this one-shot path. Ordinary
+   * conversation turns remain owned by NanocodexAgent/NanocodexEngine and do
+   * not recurse through DSH's LLM runtime.
+   */
+  stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+  private streamOneShot;
+}
+//#endregion
+//#region src/settings.d.ts
+export declare const SETTINGS_NAMESPACE: "llm-pi-ai";
+export declare const SUPPORTED_PROVIDERS: readonly ["openai", "openai-codex-responses"];
+export type NanocodexProvider = (typeof SUPPORTED_PROVIDERS)[number];
+/** The small part of the retired pi-ai profile that the adapter consumes. */
+export interface NanocodexProviderProfile {
+  readonly apiKeyEnv?: string;
+  readonly api?: string;
+  readonly baseURL?: string;
+  readonly websocketURL?: string;
+  readonly reasoning?: string;
+}
+export interface NanocodexSettings {
+  readonly providers: Record<string, NanocodexProviderProfile>;
+}
+/**
+ * Keep the existing settings namespace and profile shape readable by DSH
+ * configuration surfaces while accepting fields owned by older pi-ai
+ * profiles. Nanocodex intentionally validates only the route fields it can
+ * act on at request admission.
+ */
+export declare const NanocodexSettingsSchema: z<NanocodexSettings>;
+export declare function configuredNanocodexProviders(value: NanocodexSettings): NanocodexProvider[];
+export interface ResolvedNanocodexRoute {
+  readonly provider: string;
+  readonly model: NanocodexModel;
+  readonly apiKey: string;
+  readonly apiBaseUrl?: string;
+  readonly websocketUrl?: string;
+  readonly thinking?: "none" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+}
+export interface SettingsContext {
+  readonly settings: {
+    get(namespace: string): unknown;
+  };
+  readonly credentials: {
+    resolve(ref: CredentialRef): Promise<{
+      value: string;
+    } | undefined>;
+  };
+}
+export declare function supportedThinking(value: string | undefined): "none" | "low" | "medium" | "high" | "xhigh" | "max" | "pro" | undefined;
+/** Resolve one explicit DSH route without provider or credential fallbacks. */
+export declare function resolveNanocodexRoute(ctx: SettingsContext, options: AgentOptions): Promise<ResolvedNanocodexRoute>;
+//#endregion
+//#region src/session-id.d.ts
+/** Convert the DSH `session-<UUID>` identity to Nanocodex's UUID identity. */
+export declare function normalizeNanocodexSessionId(value: string): string;
+//#endregion
+//#region src/tool-bridge.d.ts
+export interface ToolBridgeCallbacks {
+  onCall(call: {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+    readonly parentCallId?: string;
+  }): SessionSeq | undefined | Promise<SessionSeq | undefined>;
+  onResult(call: {
+    readonly id: string;
+    readonly callSeq: SessionSeq | undefined;
+    readonly result: ToolExecutionResult;
+    readonly parentCallId?: string;
+  }): void | Promise<void>;
+}
+export interface ToolBridgeContext {
+  readonly tools: ToolRuntime;
+  readonly agent: Agent$1;
+  readonly callbacks: ToolBridgeCallbacks;
+  readonly signal: AbortSignal;
+  /** Provider-native definitions for tools whose wire input is not JSON. */
+  readonly customDefinitions?: ReadonlyMap<string, ToolDefinition>;
+}
+/** Build one model-facing tool set from the active DSH scope. */
+export declare function createToolBridge(context: ToolBridgeContext): NamedTool[];
+export type ToolBridge = ReturnType<typeof createToolBridge>;
+//#endregion
+//#region src/apply-patch/types.d.ts
+/** The deliberately small operation set accepted by the direct Codex tool. */
+type PatchOperation = AddFileOperation | UpdateFileOperation;
+interface AddFileOperation {
+  readonly kind: "add";
+  readonly path: string;
+  content: string;
+  readonly line: number;
+}
+interface UpdateFileOperation {
+  readonly kind: "update";
+  readonly path: string;
+  chunks: UpdateChunk[];
+  readonly line: number;
+}
+interface UpdateChunk {
+  readonly changeContext?: string;
+  readonly oldLines: string[];
+  readonly newLines: string[];
+  readonly contextLineIndices: Array<readonly [oldIndex: number, newIndex: number]>;
+  isEndOfFile: boolean;
+  readonly line: number;
+}
+interface ParsedPatch {
+  readonly operations: PatchOperation[];
+  readonly normalizedPatch: string;
+}
+interface PresentationDiff {
+  readonly path: string;
+  readonly oldText: string | null;
+  readonly newText: string;
+}
+//#endregion
+//#region src/apply-patch/tool.d.ts
+interface ApplyPatchLimits {
+  readonly maxPatchChars: number;
+  readonly maxPatchFiles: number;
+  readonly maxPatchFileBytes: number;
+}
+interface ApplyPatchServices {
+  readonly fs: FileSystem;
+  readonly ctx: Context;
+}
+type PatchOperationStatus = "committed" | "failed" | "unattempted";
+interface PatchOperationOutcome {
+  readonly path: string;
+  readonly action: "add" | "update";
+  readonly status: PatchOperationStatus;
+  readonly error?: {
+    readonly code: string;
+    readonly message: string;
+  };
+}
+interface ApplyPatchOutcome {
+  readonly status: "applied" | "partial" | "failed" | "cancelled";
+  readonly summary: string;
+  readonly diff: string;
+  readonly operations: PatchOperationOutcome[];
+  readonly diffs: PresentationDiff[];
+  readonly error?: {
+    readonly code: string;
+    readonly message: string;
+  };
+}
+interface PatchProgress {
+  readonly outcome: ApplyPatchOutcome;
+}
+type PatchExecution = Pick<ToolRunContext, "agent" | "signal">;
+/**
+ * Preflight and publish a supported Codex patch through the DSH filesystem.
+ *
+ * Every operation is resolved, observed, read, matched, and calculated before
+ * the first guarded atomic write. Publication is ordered and intentionally
+ * non-transactional: a later failure leaves committed earlier files in place
+ * and returns their diffs with explicit per-operation progress.
+ */
+export declare function applyPatchToFileSystem(input: string, services: ApplyPatchServices, exec: PatchExecution, limits?: ApplyPatchLimits): Promise<ApplyPatchOutcome>;
+/** Build the registry definition for the direct raw patch tool. */
+export declare function createApplyPatchTool(services: ApplyPatchServices, progressByExecution: WeakMap<object, PatchProgress>, limits?: ApplyPatchLimits): ToolDefinition$1;
+//#endregion
+//#region src/apply-patch/errors.d.ts
+type PatchErrorCode = "PATCH_INVALID" | "PATCH_UNSUPPORTED" | "PATCH_CONTEXT_NOT_FOUND" | "PATCH_TOO_LARGE" | "PATCH_PATH_INVALID";
+export declare class PatchError extends Error {
+  readonly code: PatchErrorCode;
+  readonly line?: number;
+  constructor(message: string, code: PatchErrorCode, options?: ErrorOptions & {
+    line?: number;
+  });
+}
+//#endregion
+//#region src/apply-patch/matcher.d.ts
+/** Codex's exact, trimmed, and Unicode-normalized context matching order. */
+export declare function seekSequence(lines: readonly string[], pattern: readonly string[], start: number, atEnd: boolean): number | undefined;
+/** Apply update chunks entirely in memory before a filesystem write. */
+export declare function applyChunks(content: string, path: string, chunks: readonly UpdateChunk[]): string;
+//#endregion
+//#region src/apply-patch/parser.d.ts
+/** Parse the supported Add File and Update File Codex patch subset. */
+export declare function parsePatch(input: string): ParsedPatch;
+//#endregion
+//#region src/index.d.ts
+export declare const name: "dsh-nanocodex";
+export declare const inject: readonly ["agents", "sessions", "settings", "credentials", "llm", "attachments", "commands", "systemPrompt", "tools", "fs", "storageDomain"];
+/** Install the selected Nanocodex AgentFactory and private compaction owner. */
+export declare function apply(ctx: Context): Promise<void>;
+//#endregion
+export type { ApplyPatchLimits, ApplyPatchOutcome, PatchOperationOutcome };