lark-remote 0.1.6 → 0.1.8

package/dist/runner/dsh/runner.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DshRunner — workspace-lifetime runner bridging to the DSH Web Host
+ * (DeepSeek Harness) over plain HTTP. No local subprocess is spawned.
+ *
+ * Flow per run: session.create(cwd) (when no sessionId) → synthetic system/init
+ * (DSH has no init event) → open per-session mux subscription → session.prompt
+ * (mode:'queue') → consume subscription until turn/end → result event.
+ *
+ * stop() → session.cancel + abort the mux subscription. killOrphan /
+ * registerExitHandlers are no-ops (no local process). approval/requested is
+ * surfaced as a WARN log + an assistant text prompt pointing to the DSH Web UI
+ * (never silently parked — the turn stays live until the user resolves it in
+ * the UI or the turn is cancelled/times out).
+ */
+import type { AgentEvent, AgentSessionReader, AgentStatusInfo, SpawnOptions } from '../types.js';
+import type { AgentRunner } from '../types.js';
+import { DshClient, type WebSocketFactory } from './client.js';
+/** DSH selectModel provider（deepseek-official 是 rc.7 模型目录的 provider）。 */
+export declare const DSH_MODEL_PROVIDER = "deepseek-official";
+export interface DshRunnerOptions {
+    kind: 'dsh';
+    sessionReader: AgentSessionReader;
+    /** DSH Web Host base URL, e.g. http://127.0.0.1:3080. */
+    host?: string;
+    /** Session preset（agentPreset）固定于 session 创建时；undefined = 服务端默认。 */
+    agentPreset?: string;
+    /** Display model name. */
+    model?: string;
+    /** 推理强度（off/low/high/max）；undefined = 服务端默认。 */
+    reasoningEffort?: string;
+    /** Injectable fetch for tests. */
+    fetchImpl?: typeof fetch;
+    /** Injectable WebSocket factory (defaults to global WebSocket). */
+    webSocketImpl?: WebSocketFactory;
+}
+export declare class DshRunner implements AgentRunner {
+    readonly kind: "dsh";
+    readonly sessionReader: AgentSessionReader;
+    readonly client: DshClient;
+    /** 用户配置的模型 ID（run 前 selectModel 对齐用）；undefined = 服务端默认。 */
+    private readonly configuredModel;
+    private readonly agentPreset;
+    private readonly reasoningEffort;
+    private activeAbort;
+    private activeSessionId;
+    private running;
+    constructor(opts: DshRunnerOptions);
+    get isRunning(): boolean;
+    getStatusInfo(): AgentStatusInfo;
+    run(message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
+    stop(_opts?: {
+        immediate?: boolean;
+    }): Promise<void>;
+    killOrphan(): void;
+    registerExitHandlers(): void;
+    unregisterExitHandlers(): void;
+}

package/dist/runner/dsh/runner.js

@@ -0,0 +1,191 @@
+/**
+ * DshRunner — workspace-lifetime runner bridging to the DSH Web Host
+ * (DeepSeek Harness) over plain HTTP. No local subprocess is spawned.
+ *
+ * Flow per run: session.create(cwd) (when no sessionId) → synthetic system/init
+ * (DSH has no init event) → open per-session mux subscription → session.prompt
+ * (mode:'queue') → consume subscription until turn/end → result event.
+ *
+ * stop() → session.cancel + abort the mux subscription. killOrphan /
+ * registerExitHandlers are no-ops (no local process). approval/requested is
+ * surfaced as a WARN log + an assistant text prompt pointing to the DSH Web UI
+ * (never silently parked — the turn stays live until the user resolves it in
+ * the UI or the turn is cancelled/times out).
+ */
+import { DshClient } from './client.js';
+import { DshTranslator } from './translator.js';
+import { getLogger } from '../../logger/index.js';
+/** DSH selectModel provider（deepseek-official 是 rc.7 模型目录的 provider）。 */
+export const DSH_MODEL_PROVIDER = 'deepseek-official';
+export class DshRunner {
+    kind = 'dsh';
+    sessionReader;
+    client;
+    /** 用户配置的模型 ID（run 前 selectModel 对齐用）；undefined = 服务端默认。 */
+    configuredModel;
+    agentPreset;
+    reasoningEffort;
+    activeAbort = null;
+    activeSessionId = null;
+    running = false;
+    constructor(opts) {
+        this.sessionReader = opts.sessionReader;
+        this.configuredModel = opts.model;
+        this.agentPreset = opts.agentPreset;
+        this.reasoningEffort = opts.reasoningEffort;
+        this.client = new DshClient(opts.host ?? 'http://127.0.0.1:3080', opts.fetchImpl, opts.webSocketImpl);
+    }
+    get isRunning() {
+        return this.running;
+    }
+    getStatusInfo() {
+        const extras = { host: this.client.baseUrl };
+        if (this.agentPreset)
+            extras.preset = this.agentPreset;
+        if (this.reasoningEffort)
+            extras.reasoning = this.reasoningEffort;
+        return {
+            kind: this.kind,
+            model: this.configuredModel ?? 'DSH',
+            extras,
+        };
+    }
+    async *run(message, opts) {
+        const abort = new AbortController();
+        this.activeAbort = abort;
+        this.running = true;
+        let sessionId = opts.sessionId;
+        if (!sessionId) {
+            const created = await this.client.createSession({
+                cwd: opts.cwd,
+                ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
+            });
+            sessionId = created.sessionId;
+        }
+        this.activeSessionId = sessionId;
+        // 模型/推理强度变更 = 保留 session，每次 run 前对齐（§4.3）：
+        // 该调用同时会写服务端全局默认；失败仅告警不阻断 run（模型校验由 DSH 负责）。
+        if (this.configuredModel) {
+            try {
+                await this.client.selectModel({
+                    sessionId,
+                    provider: DSH_MODEL_PROVIDER,
+                    model: this.configuredModel,
+                    ...(this.reasoningEffort ? { reasoningEffort: this.reasoningEffort } : {}),
+                });
+            }
+            catch (err) {
+                getLogger().warn(`[dsh] selectModel failed for session ${sessionId} (run continues): ${err.message}`);
+            }
+        }
+        yield {
+            type: 'system',
+            subtype: 'init',
+            session_id: sessionId,
+            cwd: opts.cwd,
+            model: this.configuredModel ?? 'DSH',
+        };
+        let terminalEmitted = false;
+        try {
+            // Snapshot the pre-prompt high-water mark before mutating the session.
+            // DSH session.history returns the whole session, so starting from seq 0
+            // would replay the first completed turn on every follow-up prompt.
+            const prePromptSeq = await this.client.latestEventSeq(sessionId);
+            await this.client.unary('session.prompt', {
+                sessionId,
+                mode: 'queue',
+                content: [{ type: 'text', text: message }],
+            });
+            const translator = new DshTranslator();
+            try {
+                for await (const item of this.client.sessionEvents(sessionId, opts.cwd, abort.signal, prePromptSeq)) {
+                    if (abort.signal.aborted)
+                        break;
+                    if (item.kind === 'approval') {
+                        getLogger().warn(`[dsh] approval requested approvalId=${item.approvalId} tool=${item.toolName} — resolve in DSH Web UI`);
+                        yield {
+                            type: 'assistant',
+                            message: {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: `⚠️ 需要授权（${item.toolName}）：请在 DSH Web UI 处理 ${this.client.baseUrl}`,
+                                    },
+                                ],
+                            },
+                        };
+                        continue;
+                    }
+                    for (const ev of translator.eventToAgentEvents(item.event, sessionId)) {
+                        yield ev;
+                        if (ev.type === 'result') {
+                            terminalEmitted = true;
+                            return;
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (abort.signal.aborted)
+                    throw err;
+                getLogger().error(`[dsh] run consume error: ${err.message}`);
+                yield {
+                    type: 'result',
+                    subtype: 'error',
+                    session_id: sessionId,
+                    errorMessage: `DSH stream error: ${err.message}`,
+                };
+                terminalEmitted = true;
+            }
+        }
+        catch (err) {
+            if (!abort.signal.aborted) {
+                yield {
+                    type: 'result',
+                    subtype: 'error',
+                    session_id: sessionId,
+                    errorMessage: `DSH run failed: ${err.message}`,
+                };
+                terminalEmitted = true;
+            }
+        }
+        finally {
+            this.running = false;
+            this.activeSessionId = null;
+            this.activeAbort = null;
+        }
+        if (!terminalEmitted) {
+            yield {
+                type: 'result',
+                subtype: abort.signal.aborted ? 'interrupted' : 'error',
+                session_id: sessionId,
+                errorMessage: abort.signal.aborted ? 'run stopped' : 'turn ended without a terminal event',
+            };
+        }
+    }
+    async stop(_opts) {
+        const sessionId = this.activeSessionId;
+        const abort = this.activeAbort;
+        if (abort && !abort.signal.aborted)
+            abort.abort();
+        if (sessionId) {
+            try {
+                await this.client.unary('session.cancel', { sessionId });
+                getLogger().info(`[dsh] cancelled session ${sessionId}`);
+            }
+            catch (err) {
+                getLogger().warn(`[dsh] session.cancel failed: ${err.message}`);
+            }
+        }
+    }
+    killOrphan() {
+        // No local subprocess for DSH — nothing to reap.
+    }
+    registerExitHandlers() {
+        // No local subprocess for DSH — nothing to register.
+    }
+    unregisterExitHandlers() {
+        // No-op (see registerExitHandlers).
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/runner/dsh/translator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DshTranslator — maps DSH SessionEvents to AgentEvents.
+ *
+ * Per-turn stateful: accumulates usage from assistant/message.usage records and
+ * converts assistant/chunk deltas to assistant text/thinking events.
+ *
+ * Mapping (task spec + DSH SessionEventMap):
+ *   assistant/chunk {chunk:{type:'text-delta',text}}     → assistant text (incremental)
+ *   assistant/chunk {chunk:{type:'reasoning-delta',text}} → assistant thinking (incremental)
+ *   assistant/message {usage?}                            → records usage (no event)
+ *   turn/end {reason.kind}                                → result:
+ *       completed → success; aborted/interrupted → interrupted;
+ *       blocked/error/max-tokens → error (errorMessage carries the reason)
+ *
+ * DSH TokenUsage: {inputTokens, outputTokens, cacheReadTokens?, cacheWriteTokens?}
+ *   → ResultEvent.usage: input_tokens/output_tokens/cache_read_tokens/
+ *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
+ */
+import type { AgentEvent, ResultEvent } from '../types.js';
+import type { DshSessionEvent, DshTokenUsage } from './types.js';
+export declare class DshTranslator {
+    private liveUsage?;
+    private hasUsage;
+    /** Translate one session event into AgentEvents (may be empty). */
+    eventToAgentEvents(ev: DshSessionEvent, sessionId: string): AgentEvent[];
+}
+/** Map DSH TokenUsage → ResultEvent.usage (cacheWrite = cache creation). */
+export declare function mapUsage(u: DshTokenUsage): NonNullable<ResultEvent['usage']>;

package/dist/runner/dsh/translator.js

@@ -0,0 +1,98 @@
+/**
+ * DshTranslator — maps DSH SessionEvents to AgentEvents.
+ *
+ * Per-turn stateful: accumulates usage from assistant/message.usage records and
+ * converts assistant/chunk deltas to assistant text/thinking events.
+ *
+ * Mapping (task spec + DSH SessionEventMap):
+ *   assistant/chunk {chunk:{type:'text-delta',text}}     → assistant text (incremental)
+ *   assistant/chunk {chunk:{type:'reasoning-delta',text}} → assistant thinking (incremental)
+ *   assistant/message {usage?}                            → records usage (no event)
+ *   turn/end {reason.kind}                                → result:
+ *       completed → success; aborted/interrupted → interrupted;
+ *       blocked/error/max-tokens → error (errorMessage carries the reason)
+ *
+ * DSH TokenUsage: {inputTokens, outputTokens, cacheReadTokens?, cacheWriteTokens?}
+ *   → ResultEvent.usage: input_tokens/output_tokens/cache_read_tokens/
+ *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
+ */
+export class DshTranslator {
+    liveUsage;
+    hasUsage = false;
+    /** Translate one session event into AgentEvents (may be empty). */
+    eventToAgentEvents(ev, sessionId) {
+        switch (ev.type) {
+            case 'assistant/chunk': {
+                const chunk = ev.data.chunk;
+                if (!chunk)
+                    return [];
+                const ts = new Date(ev.time).toISOString();
+                if (chunk.type === 'text-delta' && chunk.text) {
+                    return [
+                        {
+                            type: 'assistant',
+                            message: { content: [{ type: 'text', text: chunk.text }] },
+                            timestamp: ts,
+                        },
+                    ];
+                }
+                if (chunk.type === 'reasoning-delta' && chunk.text) {
+                    return [
+                        {
+                            type: 'assistant',
+                            message: { content: [{ type: 'thinking', thinking: chunk.text }] },
+                            timestamp: ts,
+                        },
+                    ];
+                }
+                return [];
+            }
+            case 'assistant/message': {
+                const raw = ev.data.usage;
+                if (raw && typeof raw === 'object') {
+                    this.liveUsage = raw;
+                    this.hasUsage = true;
+                }
+                return [];
+            }
+            case 'turn/end': {
+                const reason = ev.data.reason?.kind;
+                const subtype = reason === 'completed'
+                    ? 'success'
+                    : reason === 'aborted' || reason === 'interrupted'
+                        ? 'interrupted'
+                        : 'error';
+                const result = {
+                    type: 'result',
+                    subtype,
+                    session_id: sessionId,
+                    timestamp: new Date(ev.time).toISOString(),
+                };
+                if (this.hasUsage && this.liveUsage) {
+                    result.usage = mapUsage(this.liveUsage);
+                }
+                if (subtype === 'error') {
+                    result.errorMessage = `turn ended with reason: ${reason}`;
+                }
+                return [result];
+            }
+            default:
+                return [];
+        }
+    }
+}
+/** Map DSH TokenUsage → ResultEvent.usage (cacheWrite = cache creation). */
+export function mapUsage(u) {
+    const input = u.inputTokens ?? 0;
+    const output = u.outputTokens ?? 0;
+    const cacheRead = u.cacheReadTokens ?? 0;
+    const cacheWrite = u.cacheWriteTokens ?? 0;
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        cache_read_tokens: cacheRead,
+        cache_creation_tokens: cacheWrite,
+        total_tokens: input + output + cacheRead + cacheWrite,
+    };
+}
+//# sourceMappingURL=translator.js.map

package/dist/runner/dsh/types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * DSH wire type shapes (DeepSeek Harness HTTP proxy contract).
+ *
+ * Source of truth: packages/host/apiproxy/src/api/{rpc,sessions,events}.ts and
+ * packages/core/session/src/types.ts in the deepseek-harness repo. Only the
+ * fields DshClient/DshRunner/DshSessionReader consume are declared here.
+ *
+ * Unary: POST /api/<method>, body `{type:'client-request',rpcId,method,payload}`,
+ * response `{type:'server-response',rpcId,result:{ok:true,value}|{ok:false,error}}`.
+ * Stream: SSE GET /api/events.mux, frames `data: {type:'server-request',rpcId,
+ * method:<frame.type>, payload:<MuxFrame>}\n\n`.
+ */
+/** One SessionEvent entry (core SessionEvent<T> — seq/time/data discriminated on type). */
+export interface DshSessionEvent {
+    type: string;
+    seq: number;
+    time: number;
+    data: Record<string, unknown>;
+}
+/** assistant/chunk chunk payload (StreamChunk). */
+export interface DshChunk {
+    type: string;
+    index?: number;
+    text?: string;
+}
+/** TokenUsage from assistant/message.usage (dsh-llm TokenUsage). */
+export interface DshTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+}
+/** SessionSummary row from session.list items[]. */
+export interface DshSessionSummary {
+    sessionId: string;
+    updatedAt: number;
+    running: boolean;
+    blank: boolean;
+    cwd?: string;
+    /** 创建时固定的 preset（/resume preset 一致性校验用）。 */
+    agentPreset?: string;
+}
+/** session.list → value. */
+export interface DshSessionListValue {
+    items: DshSessionSummary[];
+}
+/** session.history → value.events[].event. */
+export interface DshHistoryEntry {
+    event: DshSessionEvent;
+    view?: unknown;
+}
+/** session.history → value. */
+export interface DshSessionHistoryValue {
+    events: DshHistoryEntry[];
+    hasMore: boolean;
+}
+/** One model entry inside a provider group (llm.models / session.models groups[].models[]). */
+export interface DshCatalogModel {
+    id: string;
+    name: string;
+    description?: string;
+    reasoning?: {
+        efforts: Array<{
+            id: string;
+            name: string;
+        }>;
+        defaultEffort?: string;
+    };
+}
+/** One provider group of the model catalog (llm.models groups[]). */
+export interface DshModelGroup {
+    id: string;
+    name: string;
+    models: DshCatalogModel[];
+}
+/** llm.models → value. */
+export interface DshModelCatalogValue {
+    groups: DshModelGroup[];
+    failures?: Array<{
+        id: string;
+        name: string;
+        message: string;
+    }>;
+}
+/** Current model selection (session.models current / session.selectModel selected). */
+export interface DshModelSelection {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+/** session.models → value. */
+export interface DshSessionModelsValue {
+    current: DshModelSelection;
+    routable: boolean;
+    groups: DshModelGroup[];
+    failures?: Array<{
+        id: string;
+        name: string;
+        message: string;
+    }>;
+}
+/** One preset row of agentPreset.list. */
+export interface DshPresetEntry {
+    id: string;
+    trust: 'system' | 'user';
+    isDefault: boolean;
+    name?: string;
+    description?: string;
+    broken?: string;
+}
+/** agentPreset.list → value. */
+export interface DshPresetListValue {
+    presets: DshPresetEntry[];
+    authorable: boolean;
+    hasDocument: boolean;
+}
+/** Mux frame payloads we care about (subset of MuxFrame). */
+export type DshMuxFrame = {
+    type: 'session/event';
+    sessionId: string;
+    event: DshSessionEvent;
+} | {
+    type: 'approval/requested';
+    sessionId: string;
+    approvalId: string;
+    toolName: string;
+    callId?: string;
+    reason?: string;
+} | {
+    type: 'stream/error';
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/** ServerRequest envelope (frame.method === frame.payload.type). */
+export interface DshServerRequest {
+    type: 'server-request';
+    rpcId: string;
+    method: string;
+    payload: unknown;
+}
+/** Unified per-session subscription item: a session event or an approval notice. */
+export type DshStreamItem = {
+    kind: 'event';
+    sessionId: string;
+    event: DshSessionEvent;
+} | {
+    kind: 'approval';
+    sessionId: string;
+    approvalId: string;
+    toolName: string;
+    reason?: string;
+};

package/dist/runner/dsh/types.js

@@ -0,0 +1,14 @@
+/**
+ * DSH wire type shapes (DeepSeek Harness HTTP proxy contract).
+ *
+ * Source of truth: packages/host/apiproxy/src/api/{rpc,sessions,events}.ts and
+ * packages/core/session/src/types.ts in the deepseek-harness repo. Only the
+ * fields DshClient/DshRunner/DshSessionReader consume are declared here.
+ *
+ * Unary: POST /api/<method>, body `{type:'client-request',rpcId,method,payload}`,
+ * response `{type:'server-response',rpcId,result:{ok:true,value}|{ok:false,error}}`.
+ * Stream: SSE GET /api/events.mux, frames `data: {type:'server-request',rpcId,
+ * method:<frame.type>, payload:<MuxFrame>}\n\n`.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runner/index.d.ts

@@ -8,10 +8,11 @@
  * （共享工具由消费方直接 import `common/*` 具体模块，不走 barrel）
  */
 export { ClaudeRunner } from './claude/index.js';
-export { CodexExecRunner, CodexAppServerRunner, createCodexRunner } from './codex/index.js';
-export { OpencodeExecRunner } from './opencode/index.js';
-export { PiRunner } from './pi/index.js';
-export { KimiRunner } from './kimi/index.js';
+export { CodexAppServerRunner } from './codex/index.js';
+export { OpencodeAcpRunner } from './opencode/index.js';
+export { PiRpcRunner } from './pi/index.js';
+export { KimiAcpRunner } from './kimi/index.js';
+export { DshRunner } from './dsh/index.js';
 export { BashProcessRunner, type BashRunner } from './bash/index.js';
 export { AgentRegistry } from './registry.js';
 export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, } from './types.js';

package/dist/runner/index.js

@@ -9,10 +9,11 @@
  */
 // Re-export AgentRunner 实现（从各 agent 目录）
 export { ClaudeRunner } from './claude/index.js';
-export { CodexExecRunner, CodexAppServerRunner, createCodexRunner } from './codex/index.js';
-export { OpencodeExecRunner } from './opencode/index.js';
-export { PiRunner } from './pi/index.js';
-export { KimiRunner } from './kimi/index.js';
+export { CodexAppServerRunner } from './codex/index.js';
+export { OpencodeAcpRunner } from './opencode/index.js';
+export { PiRpcRunner } from './pi/index.js';
+export { KimiAcpRunner } from './kimi/index.js';
+export { DshRunner } from './dsh/index.js';
 export { BashProcessRunner } from './bash/index.js';
 // Re-export registry
 export { AgentRegistry } from './registry.js';