dsh-loop-engine 1.0.0-rc10

package/lib/types/engine-codex/appserver/mapping.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Maps completed app-server items and turn usage to dsh session-log events.
+ * Only these end-state projections live here: token-level streaming deltas are
+ * folded inline by the driver's step loop; this module turns the item that
+ * finished a stream into the durable tool/call + tool/result events and folds
+ * a finished turn's usage into a TokenUsage.
+ *
+ * @module dsh-loop-engine/engine-codex/appserver/mapping
+ */
+import type { TokenUsage, ToolResultMessage } from '@deepseek-ai/dsh-llm';
+import { ToolCallId } from '@deepseek-ai/dsh-llm';
+/** Map app-server turn usage to dsh TokenUsage. */
+export declare function mapUsage(usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+    reasoningOutputTokens?: number;
+}): TokenUsage;
+/** Map a completed commandExecution item to tool call and result message. */
+export declare function mapCommandExecution(item: {
+    id: string;
+    command?: string;
+    aggregatedOutput?: string | null;
+    exitCode?: number | null;
+    status?: string;
+}): {
+    call: {
+        callId: ToolCallId;
+        name: string;
+        arguments: string;
+    };
+    result: ToolResultMessage;
+};
+/** Map a completed fileChange item to tool call and result message. */
+export declare function mapFileChange(item: {
+    id: string;
+    changes?: unknown[];
+    status?: string;
+}): {
+    call: {
+        callId: ToolCallId;
+        name: string;
+        arguments: string;
+    };
+    result: ToolResultMessage;
+};
+/** Map a completed mcpToolCall item to tool call and result message. */
+export declare function mapMcpToolCall(item: {
+    id: string;
+    server?: string;
+    tool?: string;
+    arguments?: unknown;
+    result?: {
+        content?: unknown[];
+    };
+    error?: {
+        message?: string;
+    };
+}): {
+    call: {
+        callId: ToolCallId;
+        name: string;
+        arguments: string;
+    };
+    result: ToolResultMessage;
+};
+//# sourceMappingURL=mapping.d.ts.map

package/lib/types/engine-codex/appserver/thread.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Thread lifecycle management for the codex app-server. Wraps a codex thread
+ * and its turn-level streaming, producing dsh-native events from the
+ * app-server's JSON-RPC notifications.
+ *
+ * @module dsh-loop-engine/engine-codex/appserver/thread
+ */
+import type { AppServerClient } from './client.ts';
+import type { ErrorNotification, ItemCompletedNotification, ThreadStartParams, ThreadTokenUsageUpdatedNotification, TurnCompletedNotification, TurnInput } from './types.ts';
+/** An event yielded during a turn's streaming. */
+export type AppServerEvent = {
+    readonly kind: 'turn-started';
+    readonly turnId: string;
+} | {
+    readonly kind: 'item-started';
+    readonly itemType: string;
+    readonly itemId: string;
+} | {
+    readonly kind: 'agent-delta';
+    readonly itemId: string;
+    readonly delta: string;
+} | {
+    readonly kind: 'reasoning-summary-delta';
+    readonly itemId: string;
+    readonly delta: string;
+    readonly summaryIndex: number;
+} | {
+    readonly kind: 'reasoning-text-delta';
+    readonly itemId: string;
+    readonly delta: string;
+    readonly contentIndex: number;
+} | {
+    readonly kind: 'plan-delta';
+    readonly itemId: string;
+    readonly delta: string;
+} | {
+    readonly kind: 'item-completed';
+    readonly item: ItemCompletedNotification['item'];
+} | {
+    readonly kind: 'turn-completed';
+    readonly turn: TurnCompletedNotification['turn'];
+} | {
+    readonly kind: 'token-usage';
+    readonly usage: ThreadTokenUsageUpdatedNotification['tokenUsage'];
+} | {
+    readonly kind: 'error';
+    readonly error: ErrorNotification['error'];
+    readonly willRetry: boolean;
+};
+/** Wraps one codex thread and its streaming turns. */
+export declare class AppServerThread {
+    private readonly client;
+    readonly threadId: string;
+    constructor(client: AppServerClient, threadId: string);
+    /** Create a new thread on the app-server. */
+    static create(client: AppServerClient, params: ThreadStartParams): Promise<AppServerThread>;
+    /**
+     * Start a turn and stream its events as an async generator.
+     * The generator ends when the turn completes or an error occurs.
+     */
+    turn(input: readonly TurnInput[], options: {
+        signal?: AbortSignal;
+        params?: Partial<Omit<import('./types.ts').TurnStartParams, 'threadId' | 'input'>>;
+    }): AsyncGenerator<AppServerEvent, void, void>;
+}
+//# sourceMappingURL=thread.d.ts.map

package/lib/types/engine-codex/appserver/types.d.ts

@@ -0,0 +1,215 @@
+/**
+ * App-server protocol type definitions. A minimal subset of the types generated
+ * by `codex app-server generate-ts`, covering only what the driver needs for
+ * streaming (initialize, thread/start, turn/start, notifications).
+ *
+ * @module dsh-loop-engine/engine-codex/appserver/types
+ */
+/** A JSON-RPC 2.0 request sent to the app-server. */
+export interface JsonRpcRequest {
+    readonly jsonrpc: '2.0';
+    readonly id: number;
+    readonly method: string;
+    readonly params?: unknown;
+}
+/** A JSON-RPC 2.0 response (success or error). */
+export interface JsonRpcResponse {
+    readonly id: number;
+    readonly result?: unknown;
+    readonly error?: {
+        readonly code: number;
+        readonly message: string;
+    };
+}
+/** A JSON-RPC 2.0 notification (no id). */
+export interface JsonRpcNotification {
+    readonly method: string;
+    readonly params: unknown;
+}
+export interface InitializeParams {
+    readonly clientInfo: {
+        readonly name: string;
+        readonly title: string | null;
+        readonly version: string;
+    };
+    readonly capabilities: {
+        readonly experimentalApi: boolean;
+        readonly requestAttestation: boolean;
+    } | null;
+}
+export interface InitializeResult {
+    readonly userAgent: string;
+    readonly codexHome: string;
+    readonly platformFamily: string;
+    readonly platformOs: string;
+}
+/** Sandbox mode accepted by `thread/start`; unlike turn policies, this is a string enum. */
+export type SandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+/** Internally tagged sandbox override accepted by `turn/start`. */
+export type SandboxPolicy = {
+    readonly type: 'dangerFullAccess';
+} | {
+    readonly type: 'readOnly';
+    readonly networkAccess: boolean;
+} | {
+    readonly type: 'externalSandbox';
+    readonly networkAccess: 'restricted' | 'enabled';
+} | {
+    readonly type: 'workspaceWrite';
+    readonly writableRoots: readonly string[];
+    readonly networkAccess: boolean;
+    readonly excludeTmpdirEnvVar: boolean;
+    readonly excludeSlashTmp: boolean;
+};
+export interface ThreadStartParams {
+    readonly model?: string | null;
+    readonly modelProvider?: string | null;
+    readonly cwd?: string | null;
+    readonly approvalPolicy?: string | null;
+    readonly sandbox?: SandboxMode | null;
+    readonly ephemeral?: boolean | null;
+    readonly [key: string]: unknown;
+}
+export interface ThreadInfo {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly modelProvider: string;
+    readonly [key: string]: unknown;
+}
+export interface ThreadStartResult {
+    readonly thread: ThreadInfo;
+}
+export interface ThreadResumeParams {
+    readonly threadId: string;
+    readonly cwd?: string | null;
+    readonly approvalPolicy?: string | null;
+    readonly sandbox?: string | null;
+    readonly [key: string]: unknown;
+}
+export interface TurnStartParams {
+    readonly threadId: string;
+    readonly input: readonly TurnInput[];
+    readonly cwd?: string | null;
+    readonly approvalPolicy?: string | null;
+    readonly sandboxPolicy?: SandboxPolicy | null;
+    readonly model?: string | null;
+    readonly [key: string]: unknown;
+}
+export interface TurnInput {
+    readonly type: 'text';
+    readonly text: string;
+}
+export interface TurnInfo {
+    readonly id: string;
+    readonly status: string;
+    readonly error: {
+        readonly message: string;
+    } | null;
+    readonly items: readonly unknown[];
+    readonly [key: string]: unknown;
+}
+export interface TurnStartResult {
+    readonly turn: TurnInfo;
+}
+export interface TurnInterruptParams {
+    readonly threadId: string;
+    readonly turnId: string;
+}
+/** item/agentMessage/delta — agent message token delta. */
+export interface AgentMessageDeltaNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly delta: string;
+}
+/** item/reasoning/summaryTextDelta — reasoning summary token delta. */
+export interface ReasoningSummaryTextDeltaNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly delta: string;
+    readonly summaryIndex: number;
+}
+/** item/reasoning/textDelta — reasoning content token delta. */
+export interface ReasoningTextDeltaNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly delta: string;
+    readonly contentIndex: number;
+}
+/** item/plan/delta — plan delta. */
+export interface PlanDeltaNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly delta: string;
+}
+/** item/started — item lifecycle start. */
+export interface ItemStartedNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly item: {
+        readonly type: string;
+        readonly id: string;
+        readonly [key: string]: unknown;
+    };
+    readonly startedAtMs: number;
+}
+/** item/completed — item lifecycle end. */
+export interface ItemCompletedNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly item: {
+        readonly type: string;
+        readonly id: string;
+        readonly text?: string;
+        readonly [key: string]: unknown;
+    };
+    readonly completedAtMs: number;
+}
+/** turn/completed — turn end with usage. */
+export interface TurnCompletedNotification {
+    readonly threadId: string;
+    readonly turn: TurnInfo & {
+        readonly usage?: {
+            readonly inputTokens: number;
+            readonly cachedInputTokens?: number;
+            readonly outputTokens: number;
+            readonly reasoningOutputTokens?: number;
+        };
+    };
+}
+/** thread/tokenUsage/updated — token usage update. */
+export interface ThreadTokenUsageUpdatedNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly tokenUsage: {
+        readonly total: {
+            readonly totalTokens: number;
+            readonly inputTokens: number;
+            readonly cachedInputTokens: number;
+            readonly outputTokens: number;
+            readonly reasoningOutputTokens: number;
+        };
+        readonly last: {
+            readonly totalTokens: number;
+            readonly inputTokens: number;
+            readonly cachedInputTokens: number;
+            readonly outputTokens: number;
+            readonly reasoningOutputTokens: number;
+        };
+    };
+}
+/** error notification. */
+export interface ErrorNotification {
+    readonly threadId: string;
+    readonly turnId: string;
+    readonly error: {
+        readonly message: string;
+        readonly codexErrorInfo?: string | null;
+        readonly additionalDetails?: string | null;
+    };
+    readonly willRetry: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/engine-codex/loop.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Codex loop engine module: hosts the AgentFactory that drives every session
+ * through the OpenAI Codex SDK, one stateless thread per dsh step, with the
+ * durable session log as the sole source of model context. dsh-loop-engine
+ * constructs this factory when the Codex engine is selected; this module is a
+ * library, not a Cordis plugin entry. The Codex SDK spawns its own CLI binary
+ * (no spawn injection seam), so this loop deliberately does not inject the dsh
+ * subprocess service.
+ *
+ * @module dsh-loop-engine/engine-codex
+ */
+import { Service } from '@deepseek-ai/cordis';
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { AgentFactory, AgentHandle, CreateAgentOptions, ResumeAgentOptions } from '@deepseek-ai/dsh-agent';
+import type { CodexApprovalPolicy, CodexSandboxMode, ResolvedConfig } from './types.ts';
+/** Codex CLI sandbox modes a deployment may pin. */
+export declare const CODEX_SANDBOX_MODES: readonly CodexSandboxMode[];
+/** Codex CLI approval policies a deployment may pin. */
+export declare const CODEX_APPROVAL_POLICIES: readonly CodexApprovalPolicy[];
+/** Deployment-owned configuration for the Codex loop plugin. */
+export interface Config {
+    /**
+     * Pinned sandbox mode for every thread. When omitted, each query follows the
+     * session's dsh permission knobs (`sandbox/mode` and `approval/policy`):
+     * full access maps to `danger-full-access`, an `ask` policy maps to
+     * `workspace-write`, and anything else fails closed with `read-only`.
+     */
+    sandboxMode?: CodexSandboxMode;
+    /**
+     * Pinned approval policy for every thread. When omitted, each query follows
+     * the session's dsh permission knobs: an `ask` policy maps to `on-request`
+     * (the CLI's own interactive prompt degrades to a denial in the unattended
+     * dsh runtime) and anything else maps to `never`.
+     */
+    approvalPolicy?: CodexApprovalPolicy;
+    /** Explicit environment entries layered over the credential-scrubbed parent environment. */
+    env?: Record<string, string>;
+    /** Model override for the SDK; Codex native settings own the model when omitted. */
+    model?: string;
+}
+/** Schema of the Codex loop plugin configuration. */
+export declare const Config: z<Config>;
+/** Host-face ctx key for the Codex loop service. */
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        agentLoopCodex: CodexLoop;
+    }
+}
+/**
+ * Concrete AgentFactory and driver service of the Codex loop. Creation and
+ * resume follow the registry factory contract and the shared publication
+ * transaction: prepare, run setup, then publish through both registries,
+ * announce, and emit `agent/session-start`.
+ */
+export declare class CodexLoop extends Service implements AgentFactory {
+    /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
+    static inject: string[];
+    /** Validated configuration owned by the loop plugin. */
+    readonly config: ResolvedConfig;
+    private readonly ownership;
+    /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
+    private readonly runtime;
+    constructor(ctx: Context, config: Config);
+    /**
+     * Construct the driver, scope, and one memoized reverse teardown for a new
+     * agent. The teardown is registered with the factory and the owner fiber
+     * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
+     * fuses caller cancellation with lifecycle teardown for setup awaits.
+     */
+    private prepare;
+    /** Prepare one Agent around an acquired Session, run setup, and publish it. */
+    private setupAndPublish;
+    /**
+     * Create an agent and session under one caller-supplied identity, owned by
+     * the accessing fiber. When a persistence backend is mounted, the session's
+     * durable identity is stored before publication.
+     * @param ownerCtx - caller context that structurally owns the lifecycle.
+     * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
+     * @returns the published handle.
+     */
+    createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /**
+     * Take a fresh session's write ownership when persistence is mounted.
+     * Nothing is appended here: the constructor seed (which never re-emits
+     * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+     * publication commit point, so a failed or cancelled setup closes an
+     * unmaterialized handle and leaves no stored residue — the same id can be
+     * created again.
+     * @param session - the unpublished session to store.
+     * @param signal - optional cancellation forwarded to the backend create.
+     * @returns the owned handle and stored cursor, or `undefined` without a backend.
+     */
+    private createStoredSession;
+    /**
+     * Durably store the session events appended since the last stored cursor.
+     * Pre-publication appends (constructor seed markers, setup-window events)
+     * never re-emit through `session/event`, so publication must flush them
+     * through the handle before live events start routing into it.
+     * @param stored - the session's owned handle and stored cursor, if any.
+     * @param session - the unpublished session whose suffix is stored.
+     */
+    private appendUnstoredSuffix;
+    /**
+     * Resume an owned agent from the configured persistence service.
+     * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
+     * @param options - persisted identity, loop options, setup, and cancellation.
+     * @returns the published handle.
+     */
+    resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
+    /** Resume through an explicit persistence service. */
+    private resumeWith;
+}
+//# sourceMappingURL=loop.d.ts.map

package/lib/types/engine-codex/permission.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Mapping from the dsh session's durable permission knobs to one Codex query's
+ * declarative permission stance. Codex has no interactive approval callback:
+ * permissions are the `sandboxMode` + `approvalPolicy` pair chosen when the
+ * thread starts, so the fold maps the session's `sandbox/mode` and
+ * `approval/policy` events directly, mirroring the web surface's presets:
+ *   - full access → `danger-full-access` + `never` (no native checks at all),
+ *   - an `ask` policy → `workspace-write` + `on-request` (the CLI's own
+ *     interactive prompt degrades to a denial in the unattended dsh runtime),
+ *   - anything else fails closed → `read-only` + `never`.
+ *
+ * @module dsh-loop-engine/engine-codex/permission
+ */
+import type { PermissionEvent } from '../driver-core/permission-knobs.ts';
+import type { CodexApprovalPolicy, CodexSandboxMode } from './types.ts';
+/** The declarative permission stance one Codex thread runs under. */
+export interface CodexPermission {
+    readonly sandboxMode: CodexSandboxMode;
+    readonly approvalPolicy: CodexApprovalPolicy;
+}
+/** Conservative unattended default: read-only sandbox, never ask. */
+export declare const DEFAULT_CODEX_PERMISSION: CodexPermission;
+/**
+ * Resolve the session's effective Codex permission stance. Full access wins
+ * outright; otherwise an `ask` policy maps to the CLI's on-request approval
+ * inside a workspace-write sandbox; anything else — including a session with
+ * no recorded knobs — fails closed.
+ * @param events - the durable session log.
+ * @returns the stance one query should run under.
+ */
+export declare function resolveSessionPermission(events: readonly PermissionEvent[]): CodexPermission;
+//# sourceMappingURL=permission.d.ts.map

package/lib/types/engine-codex/skills.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Codex skill provider: exposes the codex CLI's instruction files as DSH
+ * skills.
+ *
+ * Codex has no per-skill catalog like the agents-skill standard; its
+ * instructions are `AGENTS.md` files read from the session cwd up to the git
+ * root, plus the global `~/.codex/AGENTS.md`. Each file set is surfaced as one
+ * user-invocable `agents-md` skill whose body is the concatenated file
+ * contents, so the dsh skill-injection seam (`/name` gestures) can carry it
+ * into the prompt.
+ *
+ * @module dsh-loop-engine/engine-codex/skills
+ */
+import type { SkillCandidate, SkillDefinition, SkillLookupOptions, SkillProvider, SkillProviderControl } from '../skills.ts';
+/**
+ * Skill provider that discovers `AGENTS.md` from every directory between the
+ * project cwd and the git root, plus the user home `~/.codex/AGENTS.md`.
+ */
+export declare class CodexSkillProvider implements SkillProvider {
+    private readonly control;
+    readonly name = "codex";
+    constructor(control: SkillProviderControl);
+    list(options: SkillLookupOptions): Promise<readonly SkillCandidate[]>;
+    get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
+    /** One merged `agents-md` candidate for a ranked file set. */
+    private agentsCandidate;
+}
+export default CodexSkillProvider;
+//# sourceMappingURL=skills.d.ts.map

package/lib/types/engine-codex/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Public types of the Codex loop driver. Types only — no runtime code.
+ *
+ * @module dsh-loop-engine/engine-codex/types
+ */
+/** Codex CLI sandbox modes, as spoken by the app-server `sandbox` field. */
+export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+/** Codex CLI approval policies, as spoken by the app-server `approvalPolicy` field. */
+export type CodexApprovalPolicy = 'never' | 'on-request' | 'on-failure' | 'untrusted';
+/** Driver configuration after defaults and load-time validation. */
+export interface ResolvedConfig {
+    /** Pinned sandbox mode; `undefined` follows the session's dsh permission knobs per query. */
+    readonly sandboxMode: CodexSandboxMode | undefined;
+    /** Pinned approval policy; `undefined` follows the session's dsh permission knobs per query. */
+    readonly approvalPolicy: CodexApprovalPolicy | undefined;
+    readonly env: Record<string, string>;
+    readonly model: string | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/engine-kimi/acp/client.d.ts

@@ -0,0 +1,76 @@
+/**
+ * JSON-RPC client for the `kimi acp` subprocess (Agent Client Protocol over
+ * stdio).
+ *
+ * The driver hands the client a process handle carrying its stdin/stdout/stderr
+ * (projected from the dsh subprocess seam). The client frames JSON-RPC 2.0
+ * records on a bare `\n` (via a byte decoder, tolerating a trailing `\r`),
+ * correlates request responses by `id`, dispatches every `session/update`
+ * notification to a buffered event stream, and answers the reverse-RPC
+ * `session/request_permission` requests the agent publishes. The child is
+ * long-lived (one per factory) and stepped over via `newSession` + `prompt`.
+ *
+ * @module dsh-loop-engine/engine-kimi/acp/client
+ */
+import type { KimiProcess, KimiSpawnCapability, KimiSpawnSpec } from '../process.ts';
+import { type AcpFrame, type AcpUpdate } from './types.ts';
+/** How the client answers one `session/request_permission`. */
+export type AcpPermissionHandler = (request: AcpFrame) => boolean | Promise<boolean>;
+/** Callback receiving every non-response event line. */
+export type AcpUpdateHandler = (update: AcpUpdate) => void;
+/**
+ * ACP client over one `kimi acp` child. Created once per driver scope and reused
+ * across steps, matching the Pi RPC client's lifecycle.
+ */
+export declare class AcpClient {
+    private readonly process;
+    private readonly pending;
+    private readonly updateBuffer;
+    private updateWake;
+    private updateHandler;
+    private permissionHandler;
+    private sealed;
+    private nextId;
+    private readonly decoder;
+    private buffer;
+    /** Whether this client was sealed or its process exited. */
+    get closed(): boolean;
+    /** Mount a client over an already-spawned `kimi acp` process. */
+    constructor(process: KimiProcess);
+    /**
+     * Create a client, spawning the `kimi acp` child through the supplied
+     * capability (or the default node spawn when none is given).
+     * @param spec - the `kimi acp` argv/cwd/env the child should run with.
+     * @param spawn - optional process-spawn capability (the subprocess seam).
+     * @returns the connected client.
+     */
+    static create(spec: KimiSpawnSpec, spawn?: KimiSpawnCapability): AcpClient;
+    /** Register the event dispatch handler. */
+    onUpdate(handler: AcpUpdateHandler): void;
+    /** Register the permission-approval handler (reverse-RPC answers). */
+    onPermission(handler: AcpPermissionHandler): void;
+    /** Send one request and await the correlated response. */
+    request(method: string, params: unknown): Promise<unknown>;
+    /** Send a notification (no correlated response awaited). */
+    notify(method: string, params: unknown): void;
+    /** Open the protocol handshake. */
+    initialize(): Promise<unknown>;
+    /** Start a fresh ACP session and resolve to its session id. */
+    newSession(cwd: string): Promise<string>;
+    /** Prompt the agent in a session and resolve when the turn completes. */
+    prompt(sessionId: string, text: string): Promise<unknown>;
+    /** Cancel the active turn in a session (fire-and-forget). */
+    cancel(sessionId: string): void;
+    /** Answer a pending `session/request_permission`. */
+    respondPermission(id: number, approved: boolean): void;
+    /** Consume every buffered update as an async generator. */
+    updates(): AsyncGenerator<AcpUpdate, void, void>;
+    /** Seal the client and request child termination. */
+    dispose(): void;
+    private feed;
+    /** Dispatch one parsed line: a response, an update notification, or a reverse-RPC request. */
+    private dispatch;
+    private settle;
+    private handlePermission;
+}
+//# sourceMappingURL=client.d.ts.map

package/lib/types/engine-kimi/acp/mapping.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Maps `kimi acp` `session/update` events to dsh session-log projections.
+ *
+ * Kimi streams incremental assistant text (`agent_message_chunk`), incremental
+ * thinking (`agent_thought_chunk`), a tool-call announcement (`tool_call`) and its
+ * progress/result stream (`tool_call_update`). This module is pure: it classifies
+ * an update, extracts chunk deltas, and projects the tool-call identity/result so
+ * the agent can fold them into the durable log. Content blocks use the observed
+ * kimi `{ type: 'content', content: { type: 'text', text } }` nesting; unknown
+ * block types are ignored.
+ *
+ * @module dsh-loop-engine/engine-kimi/acp/mapping
+ */
+import type { ToolResultMessage } from '@deepseek-ai/dsh-llm';
+import type { AcpContentBlock, AcpToolCallExt, AcpToolCallStreamExt, AcpUpdate } from './types.ts';
+/** Whether the update is an incremental assistant text chunk. */
+export declare function isTextChunk(update: AcpUpdate): update is AcpUpdate & {
+    readonly sessionUpdate: 'agent_message_chunk';
+    readonly content: AcpContentBlock;
+};
+/** Whether the update is an incremental thinking chunk. */
+export declare function isThoughtChunk(update: AcpUpdate): update is AcpUpdate & {
+    readonly sessionUpdate: 'agent_thought_chunk';
+    readonly content: AcpContentBlock;
+};
+/** Whether the update announces a tool call. */
+export declare function isToolCall(update: AcpUpdate): update is AcpToolCallExt;
+/** Whether the update streams a tool call's progress/result. */
+export declare function isToolCallUpdate(update: AcpUpdate): update is AcpToolCallStreamExt;
+/** The delta text of a text/thinking chunk. */
+export declare function chunkDelta(update: AcpUpdate): string;
+/** The raw tool-call id (+ content index) as the wire carries it. */
+export declare function toolCallIdOf(update: AcpUpdate): string;
+/** The tool display name (`title`). */
+export declare function toolCallName(update: AcpUpdate): string;
+/** Whether a tool stream status is settled (no longer streaming). */
+export declare function isToolSettledStatus(status: string): boolean;
+/** Whether a tool stream status denotes a failure. */
+export declare function isToolErrorStatus(status: string): boolean;
+/** Join the observed `{ type: 'content', content: { type: 'text', text } }` blocks. */
+export declare function toolContentText(update: AcpToolCallExt | AcpToolCallStreamExt): string;
+/** Project a completed tool call to a durable tool/result message. */
+export declare function toolResult(callId: string, text: string, isError: boolean): ToolResultMessage;
+//# sourceMappingURL=mapping.d.ts.map