paseo-dsh 0.0.0-stage → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,107 @@
1
+ /**
2
+ * Idempotent provisioning of the DSH `paseo` profile the plugin drives.
3
+ *
4
+ * Paseo installs plugins from npm or git and runs no install scripts, so a
5
+ * plugin cannot rely on the repo's `install.sh`. Instead the plugin carries the
6
+ * DSH bridge bundle (embedded by `scripts/generate-bridge-assets.mjs`) and
7
+ * writes the whole profile on load: the profile files, the bridge itself under
8
+ * `node_modules/`, and a starter model-route patch when the user has none.
9
+ *
10
+ * Re-running on every load is deliberate — updating the installed plugin is the
11
+ * only step needed to update the bridge, because this rewrites it from the
12
+ * plugin's own embedded copy.
13
+ *
14
+ * @module dsh-paseo/server/bootstrap
15
+ */
16
+ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
17
+ import { homedir } from "node:os";
18
+ import { dirname, join } from "node:path";
19
+ import { BRIDGE_FILES, BRIDGE_PACKAGE_NAME, PROFILE_PATCH_TEMPLATE_BASE64 } from "./bridge-assets";
20
+
21
+ const CORDIS_YML = `# dsh profile root — an empty entry list. The tree is composed as patches:
22
+ # each bundle in package.json's dsh.profile.bundles, then cordis.patch.yml, then any
23
+ # --patch overlays. Edit cordis.patch.yml, not this file.
24
+ []
25
+ `;
26
+
27
+ const PNPM_WORKSPACE = `packages:
28
+ - .
29
+
30
+ nodeLinker: hoisted
31
+ autoInstallPeers: false
32
+ `;
33
+
34
+ /** The DSH profile name the bridge runs under. */
35
+ export function profileName(): string {
36
+ return process.env.DSH_PASEO_PROFILE ?? "paseo";
37
+ }
38
+
39
+ function dshHome(): string {
40
+ return process.env.DSH_HOME ?? join(homedir(), ".dsh");
41
+ }
42
+
43
+ function profilePackageJson(profile: string): string {
44
+ return `${JSON.stringify(
45
+ {
46
+ name: `dsh-profile-${profile}`,
47
+ private: true,
48
+ dsh: { profile: { bundles: ["@deepseek-ai/dsh-base", BRIDGE_PACKAGE_NAME] } },
49
+ },
50
+ null,
51
+ 2,
52
+ )}\n`;
53
+ }
54
+
55
+ /** Write only when the bytes differ, so a load never churns file mtimes. */
56
+ function writeIfChanged(path: string, content: string | Uint8Array): boolean {
57
+ try {
58
+ if (existsSync(path) && readFileSync(path).equals(Buffer.from(content as never))) return false;
59
+ } catch {
60
+ /* unreadable or absent: fall through to write */
61
+ }
62
+ writeFileSync(path, content);
63
+ return true;
64
+ }
65
+
66
+ export interface ProvisionResult {
67
+ profile: string;
68
+ dir: string;
69
+ bridgeFiles: number;
70
+ patchCreated: boolean;
71
+ }
72
+
73
+ /**
74
+ * Ensure `$DSH_HOME/profiles/<profile>` exists and carries the bridge.
75
+ *
76
+ * Throws only on a real filesystem failure; callers treat provisioning as a
77
+ * convenience and must not fail plugin load over it.
78
+ */
79
+ export function ensurePaseoProfile(): ProvisionResult {
80
+ const profile = profileName();
81
+ const dir = join(dshHome(), "profiles", profile);
82
+ mkdirSync(join(dir, "node_modules"), { recursive: true });
83
+
84
+ writeIfChanged(join(dir, "package.json"), profilePackageJson(profile));
85
+ writeIfChanged(join(dir, "cordis.yml"), CORDIS_YML);
86
+ writeIfChanged(join(dir, "pnpm-workspace.yaml"), PNPM_WORKSPACE);
87
+
88
+ // Replace whatever bridge is present — an older copy, or the symlink the
89
+ // repo's install.sh creates — so the profile always matches this plugin build.
90
+ const bridgeDir = join(dir, "node_modules", BRIDGE_PACKAGE_NAME);
91
+ if (existsSync(bridgeDir)) rmSync(bridgeDir, { recursive: true, force: true });
92
+ mkdirSync(bridgeDir, { recursive: true });
93
+ for (const [relativePath, encoded] of Object.entries(BRIDGE_FILES)) {
94
+ const target = join(bridgeDir, relativePath);
95
+ mkdirSync(dirname(target), { recursive: true });
96
+ writeFileSync(target, Buffer.from(encoded, "base64"));
97
+ }
98
+
99
+ // The one file the user owns: never overwrite an existing model route.
100
+ const patch = join(dir, "cordis.patch.yml");
101
+ const patchCreated = !existsSync(patch);
102
+ if (patchCreated) {
103
+ writeFileSync(patch, Buffer.from(PROFILE_PATCH_TEMPLATE_BASE64, "base64"));
104
+ }
105
+
106
+ return { profile, dir, bridgeFiles: Object.keys(BRIDGE_FILES).length, patchCreated };
107
+ }
@@ -0,0 +1,20 @@
1
+ // GENERATED FILE — do not edit by hand.
2
+ // Regenerate with: node scripts/generate-bridge-assets.mjs
3
+ //
4
+ // The DSH bridge bundle and profile patch template, embedded so the plugin can
5
+ // provision ~/.dsh/profiles/<name> at load without shipping the bridge as
6
+ // separate files (npm and git plugin installs run no install scripts).
7
+
8
+ export const BRIDGE_PACKAGE_NAME = "dsh-paseo-bridge";
9
+
10
+ /** Path -> base64 file content, relative to the bridge package root. */
11
+ export const BRIDGE_FILES: Readonly<Record<string, string>> = {
12
+ "cordis.patch.yml": "IyBUaGUgUGFzZW8gYnJpZGdlIGJ1bmRsZSBwYXRjaDogYW4gYXV0b21hdGlvbi1vbmx5IHN0ZGlvIHN1cmZhY2Ugb3ZlciBkc2gtYmFzZS4KIwojIFN0ZG91dCBjYXJyaWVzIHByb3RvY29sIGZyYW1lcyBvbmx5LiBUaGlzIHBhdGNoIG11c3QgbmV2ZXIgZW5hYmxlIGEgc3Rkb3V0CiMgbG9nZ2VyLiBJdCBtaXJyb3JzIHRoZSBzaGlwcGVkIHNkay1hcHAvYWNwLWFwcCBidW5kbGVzIHNvIHRoZSBzYW1lIGJhc2UKIyBhZGFwdGVycywgdG9vbHMsIHBlcnNpc3RlbmNlIGFuZCBwb2xpY3kgYXBwbHkuCgotIGlkOiBzeXN0ZW0tcHJvbXB0CiAgY29uZmlnOgogICAgcGVyc29uYVN1ZmZpeDogWW91ciB3b3JraW5nIGRpcmVjdG9yeSBpcyB7e2N3ZH19LgogICAgcGVyc29uYVByZWZpeDogPi0KICAgICAgWW91IGFyZSBhIGNvZGluZyBhZ2VudCBwb3dlcmVkIGJ5IHRoZSB7e21vZGVsfX0gbW9kZWwuCgotIGlkOiBzZXNzaW9uLXRpdGxlLWxsbQogIGRpc2FibGVkOiB0cnVlCgotIGluc2VydDoKICAgIC0gaWQ6IHBhc2VvLWJyaWRnZQogICAgICBuYW1lOiAnZHNoLXBhc2VvLWJyaWRnZScKICAgICAgaW5qZWN0OiBbY21kbGluZUFyZ3MsIGFnZW50c10KCi0gaWQ6IGhtcgogIGRpc2FibGVkOiB0cnVlCgojIFRoZSBxdWVzdGlvbiBzdXJmYWNlIGlzIG9wdC1pbiBwZXIgcHJlc2V0IGluIHRoZSBzaGlwcGVkIGJ1bmRsZXM7IHRoZSBicmlkZ2UKIyBuZWVkcyB0aGUgbW9kZWwtZmFjaW5nIHRvb2wgbW91bnRlZCBzbyB0aGUgbW9kZWwgY2FuIGFjdHVhbGx5IGFzay4KLSBpbnNlcnQ6CiAgICAtIGlkOiB0b29sLWFzay11c2VyCiAgICAgIG5hbWU6ICdAZGVlcHNlZWstYWkvZHNoLXRvb2wtYXNrLXVzZXInCg==",
13
+ "lib/index.js": "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",
14
+ "lib/server.js": "/**
 * A Paseo-drivable DeepSeek Harness runtime over one JSON-RPC transport peer.
 *
 * The surface is the shipped SDK contract (`initialize`, `session/prompt`,
 * `shutdown` plus the `session.event` / `session.status` notifications) with
 * three additions on top:
 *
 * - `paseo/plan/get` and `paseo/plan/set` drive the mounted plan-mode service.
 * - `paseo/config/set` mutates the live per-agent model selection, which is how
 *   the thinking-effort control takes effect without restarting the runtime.
 * - `paseo/question` is a *server -> client request*: the bridge sends it when
 *   the model calls the user-question tool and waits for the answer batch.
 *
 * @module dsh-paseo-bridge/server
 */
import { resolve } from 'node:path';
import { brandString } from '@deepseek-ai/dsh-brand';
import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
import { admitEncodedImages } from '@deepseek-ai/dsh-attachment';
import { installModelSelection } from '@deepseek-ai/dsh-agent';

function encodedImage(block) {
  return block.type === 'image' && 'data' in block;
}

/**
 * Media type read from the raster's own magic bytes, or undefined when the
 * bytes are not one of the formats DSH admits.
 *
 * The prompt's declared `mimeType` is not trustworthy: Paseo derives it from
 * the upload's filename extension, so a JPEG saved as `foo.png` arrives as
 * `{mimeType: "image/png", data: <jpeg>}`. DSH verifies the declared type
 * against the decoded bytes and refuses a mismatch, which would reject a
 * perfectly readable picture. The bytes are the authoritative answer, and this
 * is a trusted translator rather than a caller asserting content, so read the
 * type from them.
 */
function sniffImageMediaType(bytes) {
  if (bytes.length >= 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
    return 'image/png';
  }
  if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
    return 'image/jpeg';
  }
  if (bytes.length >= 6 && bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38) {
    return 'image/gif';
  }
  if (
    bytes.length >= 12
    && bytes.toString('ascii', 0, 4) === 'RIFF'
    && bytes.toString('ascii', 8, 12) === 'WEBP'
  ) {
    return 'image/webp';
  }
  return undefined;
}

async function durablePromptContent(ctx, blocks) {
  const images = blocks.filter(encodedImage);
  if (images.length === 0) return blocks;
  const attachments = ctx.get('attachments');
  if (attachments === undefined) throw new Error('image prompt requires an attachment store');
  const refs = await admitEncodedImages(
    attachments,
    images.map((image) => {
      const bytes = Buffer.from(typeof image.data === 'string' ? image.data : '', 'base64');
      // Prefer the bytes; keep the declared type only when they are unreadable,
      // so an unsupported format still fails loudly with DSH's own error.
      const mediaType = sniffImageMediaType(bytes) ?? image.mimeType;
      return { data: image.data, mediaType };
    }),
  );
  let next = 0;
  return blocks.map((block) =>
    encodedImage(block) ? { type: 'image', attachment: refs[next++] } : block,
  );
}

function effortOf(value) {
  if (value === undefined || value === null || value === '') return undefined;
  return ReasoningEffortId(value);
}

export class PaseoHarnessServer {
  constructor(ctx, transport, options = {}) {
    this.ctx = ctx;
    this.transport = transport;
    this.options = options;

    this.cwd = process.cwd();
    // Deliberately unset: a hardcoded route would silently pick a provider for a
    // deployment that never configured one. `initialize` falls back to the
    // profile's own default instead, and fails loudly when there is none.
    this.provider = options.provider;
    this.model = options.model;
    this.reasoningEffort = effortOf(options.reasoningEffort);
    this.maxTokens = undefined;

    /**
     * Plan-mode intent recorded before a session's agent exists. Paseo opens a
     * session purely to read its composer features and never prompts it, so plan
     * and route changes must be queueable instead of requiring a live agent.
     */
    this.pendingPlanMode = false;

    /** sessionId -> { selection, dispose } for live per-agent model control. */
    this.controls = new Map();
    /** sessionId -> { handle } for agents this server owns. */
    this.sessions = new Map();
    this.sessionCreations = new Map();
    this.disposers = [];
    this.initialized = false;
    this.shuttingDown = false;
    this.shutdownTask = undefined;
    this.llmFiber = undefined;

    this.disposers.push(
      ctx.on('session/event', (session, event) => {
        this.transport.notify('session.event', { sessionId: String(session.id), event });
      }),
    );
    this.disposers.push(
      ctx.on('agent/status', ({ agent, status }) => {
        this.transport.notify('session.status', { sessionId: String(agent.session.id), status });
      }),
    );
  }

  /** Whether this server owns the live agent behind a session id. */
  owns(sessionId) {
    return this.sessions.has(sessionId) || this.sessionCreations.has(sessionId);
  }

  /**
   * The route the profile itself configured, used when neither the caller nor
   * the constructor named one. Undefined when no default-model service is
   * composed, which callers must treat as an error rather than guess around.
   */
  profileDefault() {
    try {
      const selection = this.ctx.get('agentDefaultModel')?.currentSelection?.();
      if (typeof selection?.provider === 'string' && typeof selection?.model === 'string') return selection;
    } catch {
      /* the deployment composes no default-model service */
    }
    return undefined;
  }

  /** Validate the route and record the defaults applied to every created agent. */
  async initialize(params) {
    if (params.cwd === undefined) throw new TypeError('initialize requires cwd');
    if (params.reasoningEffort !== undefined) effortOf(params.reasoningEffort);
    const cwd = resolve(params.cwd);
    const fallback = this.profileDefault();
    const provider = params.provider ?? this.provider ?? fallback?.provider;
    const model = params.model ?? this.model ?? fallback?.model;
    if (provider === undefined || model === undefined) {
      throw new Error('no provider/model was given and this profile configures no default model');
    }
    const reasoningEffort = params.reasoningEffort !== undefined
      ? effortOf(params.reasoningEffort)
      : this.reasoningEffort
        ?? (fallback?.reasoningEffort === undefined ? undefined : effortOf(fallback.reasoningEffort));

    if (!this.hasAdapterFor(provider)) {
      const adapter = this.options.adapters?.[provider];
      if (adapter === undefined) {
        throw new Error(
          `no adapter registered for provider "${provider}"; declare it in the profile's llm route `
          + 'or list it under the paseo-bridge `adapters` config',
        );
      }
      const mod = await import(adapter);
      this.llmFiber = await this.ctx.plugin(mod);
    }

    await this.ctx.get('llm').resolveCallConfig({
      provider,
      model,
      ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
      ...(params.maxTokens === undefined ? {} : { maxTokens: params.maxTokens }),
    });

    this.cwd = cwd;
    this.provider = provider;
    this.model = model;
    this.reasoningEffort = reasoningEffort;
    this.maxTokens = params.maxTokens;
    this.initialized = true;
    return {
      serverInfo: { name: 'deepseek-harness-paseo-bridge', version: '0.1.0' },
      route: { provider, model, reasoningEffort: reasoningEffort ?? null },
    };
  }

  /** Queue one identified prompt for a session, creating its agent on first use. */
  async prompt(params) {
    if (!this.initialized) throw new Error('paseo bridge is not initialized');
    const rec = await this.getOrCreateSession(params.sessionId);
    this.assertLiveAgent(rec, params.sessionId);
    const content = await durablePromptContent(this.ctx, params.contentBlocks ?? []);
    this.assertLiveAgent(rec, params.sessionId);
    const message = createUserMessage({ content, source: { kind: 'user' } });
    // A steer belongs inside the turn already running; a plain prompt starts the
    // next one. Without this distinction an interjection queues behind the very
    // turn it was meant to correct.
    if (params.delivery === 'steer') rec.handle.agent.steer(message);
    else rec.handle.agent.followup(message);
    return { messageId: String(message.id) };
  }

  /**
   * Cancel the running turn while keeping the session and its history alive, so
   * the conversation can continue afterwards.
   */
  async cancel(params) {
    const rec = this.requireSession(params.sessionId);
    rec.handle.agent.cancel({ kind: 'user' });
    return { canceled: true };
  }

  /** Report the mounted plan state for one session, or the queued intent before it exists. */
  async planGet(params) {
    const planMode = this.ctx.get('planMode');
    if (planMode === undefined) return { available: false, active: false, pending: false };
    const rec = this.sessions.get(params.sessionId);
    if (rec === undefined) {
      return { available: true, active: this.pendingPlanMode === true, pending: false };
    }
    this.assertLiveAgent(rec, params.sessionId);
    const state = planMode.get(rec.handle.agent);
    return { available: true, active: state.active === true, pending: state.pending === true };
  }

  /** Select plan mode for one session, queueing the intent until its agent exists. */
  async planSet(params) {
    const planMode = this.ctx.get('planMode');
    if (planMode === undefined) throw new Error('plan mode is not mounted in this profile');
    const active = params.active === true;
    const rec = this.sessions.get(params.sessionId);
    if (rec === undefined) {
      this.pendingPlanMode = active;
      return { available: true, active, pending: false, outcome: 'queued' };
    }
    this.assertLiveAgent(rec, params.sessionId);
    const outcome = planMode.set(rec.handle.agent, active);
    const state = planMode.get(rec.handle.agent);
    return {
      available: true,
      active: state.active === true,
      pending: state.pending === true,
      outcome,
    };
  }

  /** Mutate the per-agent route, or the default route while no agent exists yet. */
  async configSet(params) {
    const rec = this.sessions.get(params.sessionId);
    if (rec === undefined) {
      if (typeof params.provider === 'string') this.provider = params.provider;
      if (typeof params.model === 'string') this.model = params.model;
      if (params.reasoningEffort !== undefined) {
        this.reasoningEffort = effortOf(params.reasoningEffort);
      }
      return {
        provider: this.provider,
        model: this.model,
        reasoningEffort: this.reasoningEffort ?? null,
      };
    }
    this.assertLiveAgent(rec, params.sessionId);
    const selection = rec.control.selection;
    const next = { ...(selection.current ?? {}) };
    if (typeof params.provider === 'string') next.provider = params.provider;
    if (typeof params.model === 'string') next.model = params.model;
    if (params.reasoningEffort !== undefined) {
      const effort = effortOf(params.reasoningEffort);
      if (effort === undefined) delete next.reasoningEffort;
      else next.reasoningEffort = effort;
    }
    if (next.provider === undefined || next.model === undefined) {
      throw new Error('model selection requires both provider and model');
    }
    selection.current = next;
    return { ...next, reasoningEffort: next.reasoningEffort ?? null };
  }

  /**
   * The slash-commands the composer may offer for one session: the registered
   * human commands plus every user-invocable skill.
   *
   * Skills ship a `userInvocable` policy precisely so a human-facing catalog can
   * advertise them next to commands, and DSH injects a skill from a bare
   * `/name` token in user input. They are not registered commands, so the two
   * are tagged and handled differently when run.
   */
  async commands(params) {
    const rec = await this.getOrCreateSession(params.sessionId);
    this.assertLiveAgent(rec, params.sessionId);
    const agent = rec.handle.agent;
    const out = [];
    const seen = new Set();
    const commands = this.ctx.get('commands');
    if (commands !== undefined) {
      for (const command of commands.list(agent)) {
        if (seen.has(command.name)) continue;
        seen.add(command.name);
        out.push({
          name: command.name,
          description: command.description,
          ...(command.input?.hint === undefined ? {} : { argumentHint: command.input.hint }),
          kind: 'command',
        });
      }
    }
    const skills = this.ctx.get('skills');
    if (skills !== undefined) {
      let list;
      try {
        list = await skills.list({ cwd: this.cwd, scope: agent });
      } catch {
        // A skill source that fails discovery must not take commands down with it.
        list = [];
      }
      for (const skill of list) {
        if (skill.invocation?.userInvocable !== true) continue;
        if (seen.has(skill.name)) continue;
        seen.add(skill.name);
        out.push({ name: skill.name, description: skill.description, kind: 'skill' });
      }
    }
    return { commands: out };
  }

  /**
   * Run one registered command for a session. A skill is not handled here: the
   * plugin sends its `/name` line as ordinary user input, which is how DSH's own
   * `skill` tool injects it.
   */
  async runCommand(params) {
    const rec = this.requireSession(params.sessionId);
    const commands = this.ctx.get('commands');
    if (commands === undefined) throw new Error('command registry is not mounted in this profile');
    const line = typeof params.arguments === 'string' && params.arguments.trim() !== ''
      ? `/${params.name} ${params.arguments}`
      : `/${params.name}`;
    const execution = await commands.execute(rec.handle.agent, line, [], new AbortController().signal);
    if (execution === undefined) throw new Error(`unknown command "${params.name}"`);
    return {
      kind: execution.result.kind,
      ...(execution.result.text === undefined ? {} : { text: execution.result.text }),
    };
  }

  /** Report the routes and models the runtime can serve, for the Paseo catalog. */
  async catalog() {
    const llm = this.ctx.get('llm');
    if (llm === undefined) {
      return { providers: [], models: [], planMode: this.ctx.get('planMode') !== undefined };
    }
    const providers = llm.listProviders().map((entry) => ({ id: entry.id, name: entry.name }));
    const models = [];
    // A provider with no credential, or a model with no resolved capability
    // record, reports nothing; it must not take the whole catalog down.
    for (const provider of providers) {
      try {
        for (const model of await llm.listModels(provider.id)) {
          let reasoning;
          try {
            const info = await llm.resolveModelInfo(provider.id, model.id);
            if (info?.reasoning !== undefined) {
              reasoning = {
                ...(info.reasoning.defaultEffort === undefined
                  ? {}
                  : { defaultEffort: String(info.reasoning.defaultEffort) }),
                efforts: (info.reasoning.efforts ?? []).map((effort) => ({
                  id: String(effort.id),
                  name: effort.name,
                  ...(effort.description === undefined ? {} : { description: effort.description }),
                })),
              };
            }
          } catch {
            /* model declares no reasoning control */
          }
          models.push({
            provider: model.provider,
            id: model.id,
            name: model.name,
            ...(model.description === undefined ? {} : { description: model.description }),
            ...(reasoning === undefined ? {} : { reasoning }),
          });
        }
      } catch {
        /* provider advertises no usable catalog */
      }
    }
    // A catalog read happens before any session pins a route, so the profile's
    // configured default is the honest answer.
    let defaultProvider = this.provider;
    let defaultModel = this.model;
    let defaultReasoningEffort = this.reasoningEffort ?? null;
    const selection = this.profileDefault();
    if (selection !== undefined) {
      defaultProvider = selection.provider;
      defaultModel = selection.model;
      defaultReasoningEffort = selection.reasoningEffort ?? null;
    }
    return {
      providers,
      models,
      defaultProvider,
      defaultModel,
      defaultReasoningEffort,
      planMode: this.ctx.get('planMode') !== undefined,
    };
  }

  /** Dispose server-owned agents, the fallback adapter and subscriptions. */
  shutdown() {
    this.shutdownTask ??= this.performShutdown();
    return this.shutdownTask;
  }

  async performShutdown() {
    this.shuttingDown = true;
    await Promise.allSettled([...this.sessionCreations.values()]);
    this.sessionCreations.clear();
    const records = [...this.sessions.values()];
    this.sessions.clear();
    const failures = [];
    while (this.disposers.length > 0) {
      try {
        this.disposers.pop()?.();
      } catch (error) {
        failures.push(error);
      }
    }
    for (const rec of records) {
      try {
        rec.control?.dispose?.();
      } catch (error) {
        failures.push(error);
      }
    }
    this.controls.clear();
    const teardown = await Promise.allSettled([
      ...records.map((rec) => Promise.resolve().then(() => rec.handle.dispose())),
      ...(this.llmFiber === undefined
        ? []
        : [Promise.resolve().then(() => this.llmFiber?.dispose())]),
    ]);
    this.llmFiber = undefined;
    failures.push(
      ...teardown.filter((result) => result.status === 'rejected').map((result) => result.reason),
    );
    if (failures.length === 1) throw failures[0];
    if (failures.length > 1) throw new AggregateError(failures, 'paseo bridge teardown failed');
    return {};
  }

  /** Dispatch one incoming JSON-RPC request to its typed handler. */
  async handleRequest(method, params) {
    switch (method) {
      case 'initialize':
        return this.initialize(params);
      case 'session/prompt':
        return this.prompt(params);
      case 'session/cancel':
        return this.cancel(params);
      case 'paseo/catalog':
        return this.catalog();
      case 'paseo/commands':
        return this.commands(params);
      case 'paseo/command/run':
        return this.runCommand(params);
      case 'paseo/plan/get':
        return this.planGet(params);
      case 'paseo/plan/set':
        return this.planSet(params);
      case 'paseo/config/set':
        return this.configSet(params);
      case 'shutdown':
        return this.shutdown();
      default:
        throw new Error(`unknown paseo bridge method: ${method}`);
    }
  }

  requireSession(sessionId) {
    const rec = this.sessions.get(sessionId);
    if (rec === undefined) throw new Error(`unknown or not-yet-created session: ${sessionId}`);
    this.assertLiveAgent(rec, sessionId);
    return rec;
  }

  assertLiveAgent(rec, sessionId) {
    if (this.ctx.agents.get(rec.handle.agent.id) !== rec.handle.agent) {
      throw new Error(`session agent was disposed outside the server: ${sessionId}`);
    }
  }

  async getOrCreateSession(sessionId) {
    if (this.shuttingDown) throw new Error('paseo bridge is shutting down');
    const existing = this.sessions.get(sessionId);
    if (existing !== undefined) return existing;
    const pending = this.sessionCreations.get(sessionId);
    if (pending !== undefined) return pending;
    const creation = this.createSession(sessionId);
    this.sessionCreations.set(sessionId, creation);
    creation.then(
      () => this.sessionCreations.delete(sessionId),
      () => this.sessionCreations.delete(sessionId),
    );
    return creation;
  }

  async createSession(sessionId) {
    // Mirrors the ACP adapter: the durable option carries the initial route and
    // a scoped mutable selection ref installed during setup owns later switches.
    const initial = {
      provider: this.provider,
      model: this.model,
      ...(this.reasoningEffort === undefined ? {} : { reasoningEffort: this.reasoningEffort }),
    };
    const control = { selection: { current: initial, assembled: undefined }, dispose: undefined };
    const setup = (agentCtx) => {
      control.dispose = installModelSelection(agentCtx, control.selection);
    };
    const agentOptions = {
      ...initial,
      ...(this.maxTokens === undefined ? {} : { maxTokens: this.maxTokens }),
    };
    let handle;
    try {
      handle = await this.ctx.agents.create({
        sessionId: brandString(sessionId),
        meta: { cwd: this.cwd },
        agentOptions,
        setup,
      });
    } catch (error) {
      // DSH persists sessions, so opening an id it already knows is a conflict
      // rather than a failure. Paseo re-opens an agent with its existing session
      // id on refresh and reconnect, so resume the persisted session and keep
      // the conversation alive instead of failing the open.
      if (!/already exists/i.test(String(error?.message ?? error))) throw error;
      handle = await this.ctx.agents.resume({
        resumeSessionId: brandString(sessionId),
        agentOptions,
        setup,
      });
    }
    const rec = { handle, control };
    this.controls.set(sessionId, control);
    this.sessions.set(sessionId, rec);
    if (this.pendingPlanMode) {
      const planMode = this.ctx.get('planMode');
      if (planMode !== undefined) planMode.set(handle.agent, true);
    }
    return rec;
  }

  hasAdapterFor(provider) {
    return this.ctx.get('llm')?.listProviders().some((entry) => entry.id === provider) ?? false;
  }
}
",
15
+ "lib/transport.js": "/**
 * Newline-delimited JSON-RPC 2.0 over byte streams.
 *
 * This is deliberately modelled on the shipped `dsh-sdk-protocol` transport,
 * but it exists as a local copy for two reasons:
 *
 * 1. `@deepseek-ai/dsh-sdk-protocol` / `dsh-sdk-jsonrpc-server` are not
 *    published at the runtime version and are not resolvable from a profile,
 *    so importing them would drag an unresolvable dependency into the profile.
 * 2. The Paseo bridge needs the *server -> client request* direction, which the
 *    shipped SDK transport supports but never exercises.
 *
 * @module dsh-paseo-bridge/transport
 */
import { StringDecoder } from 'node:string_decoder';

/** A JSON-RPC error response, preserving the wire `code` and optional `data`. */
export class JsonRpcResponseError extends Error {
  constructor(code, message, data) {
    super(message);
    this.name = 'JsonRpcResponseError';
    this.code = code;
    this.data = data;
  }
}

export class PaseoTransport {
  #input;
  #output;
  #decoder = new StringDecoder('utf8');
  #buffer = '';
  #started = false;
  #closed = false;
  #requestHandler;
  #notificationHandler;
  #pending = new Map();
  #nextId = 1;

  constructor(input, output) {
    this.#input = input;
    this.#output = output;
  }

  /** Attach stream listeners and begin reading frames. Idempotent. */
  start() {
    if (this.#started || this.#closed) return;
    this.#started = true;
    this.#input.on('data', this.#onData);
    this.#input.on('error', this.#onError);
    this.#input.on('end', this.#onEnd);
  }

  /** Detach listeners and reject pending requests without destroying streams. */
  close() {
    if (!this.#started) return;
    this.#started = false;
    this.#input.off('data', this.#onData);
    this.#input.off('error', this.#onError);
    this.#input.off('end', this.#onEnd);
    this.#failPending(new Error('paseo bridge transport closed'));
  }

  /** Install the handler for client -> server requests, replacing any prior one. */
  onRequest(handler) {
    this.#requestHandler = handler;
  }

  /** Install the handler for client -> server notifications, replacing any prior one. */
  onNotification(handler) {
    this.#notificationHandler = handler;
  }

  /** Wait for prior frame write callbacks; the empty barrier emits no bytes. */
  flush() {
    return new Promise((resolve) => {
      this.#output.write('', () => resolve());
    });
  }

  /** Send a notification; omitted params produce no `params` member. */
  notify(method, params) {
    this.#write(params === undefined ? { jsonrpc: '2.0', method } : { jsonrpc: '2.0', method, params });
  }

  /**
   * Send a server -> client request and await its response.
   * @param method - JSON-RPC method name.
   * @param params - request parameters.
   * @param signal - optional abandonment signal; aborting drops the pending entry.
   */
  request(method, params, signal) {
    if (this.#closed) return Promise.reject(new Error('paseo bridge transport closed'));
    if (signal?.aborted === true) return Promise.reject(signal.reason ?? new Error('aborted'));
    const id = this.#nextId++;
    return new Promise((resolve, reject) => {
      const entry = { resolve, reject, signal, onAbort: undefined };
      if (signal !== undefined) {
        entry.onAbort = () => {
          if (this.#pending.delete(id)) reject(signal.reason ?? new Error('aborted'));
        };
        signal.addEventListener('abort', entry.onAbort, { once: true });
      }
      this.#pending.set(id, entry);
      this.#write({
        jsonrpc: '2.0',
        id,
        method,
        ...(params === undefined ? {} : { params }),
      });
    });
  }

  #release(entry) {
    if (entry.signal !== undefined && entry.onAbort !== undefined) {
      entry.signal.removeEventListener('abort', entry.onAbort);
      entry.onAbort = undefined;
    }
  }

  #failPending(error) {
    const entries = [...this.#pending.values()];
    this.#pending.clear();
    for (const entry of entries) {
      this.#release(entry);
      entry.reject(error);
    }
  }

  #write(frame) {
    if (this.#closed) return;
    try {
      void this.#output.write(`${JSON.stringify(frame)}\n`);
    } catch {
      /* a dead stdout surface must not take the runtime down */
    }
  }

  #onData = (chunk) => {
    this.#buffer += typeof chunk === 'string' ? chunk : this.#decoder.write(chunk);
    const lines = this.#buffer.split('\n');
    this.#buffer = lines.pop() ?? '';
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed === '') continue;
      let frame;
      try {
        frame = JSON.parse(trimmed);
      } catch {
        continue;
      }
      void this.#handleFrame(frame);
    }
  };

  #onError = (error) => {
    this.#failPending(error);
  };

  #onEnd = () => {
    this.#failPending(new Error('paseo bridge input ended'));
  };

  async #handleFrame(frame) {
    if (frame === null || typeof frame !== 'object') return;
    const hasMethod = typeof frame.method === 'string';
    const hasId = frame.id !== undefined && frame.id !== null;
    if (hasMethod && hasId) return this.#handleIncomingRequest(frame);
    if (hasMethod) return this.#handleIncomingNotification(frame);
    if (hasId) return this.#handleIncomingResponse(frame);
  }

  async #handleIncomingRequest(frame) {
    try {
      if (this.#requestHandler === undefined) {
        throw new Error(`no request handler for ${frame.method}`);
      }
      const result = await this.#requestHandler(frame.method, frame.params ?? {});
      this.#write({ jsonrpc: '2.0', id: frame.id, result: result === undefined ? null : result });
    } catch (error) {
      this.#write({
        jsonrpc: '2.0',
        id: frame.id,
        error: { code: -32603, message: error instanceof Error ? error.message : String(error) },
      });
    }
  }

  #handleIncomingNotification(frame) {
    try {
      this.#notificationHandler?.(frame.method, frame.params ?? {});
    } catch {
      /* notifications are fire-and-forget */
    }
  }

  #handleIncomingResponse(frame) {
    const entry = this.#pending.get(frame.id);
    if (entry === undefined) return;
    this.#pending.delete(frame.id);
    this.#release(entry);
    if (frame.error !== undefined) {
      entry.reject(
        new JsonRpcResponseError(frame.error?.code, frame.error?.message ?? 'request failed', frame.error?.data),
      );
    } else {
      entry.resolve(frame.result);
    }
  }
}
",
16
+ "package.json": "ewogICJuYW1lIjogImRzaC1wYXNlby1icmlkZ2UiLAogICJ2ZXJzaW9uIjogIjAuMS4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgImRlc2NyaXB0aW9uIjogIkRTSCBwcm9maWxlIGJ1bmRsZSB0aGF0IHNlcnZlcyBhIFBhc2VvLWRyaXZhYmxlIHJ1bnRpbWUgb3ZlciBzdGRpbyBKU09OLVJQQywgaW5jbHVkaW5nIHVzZXItcXVlc3Rpb24gY2FyZHMsIHBsYW4gbW9kZSBhbmQgdGhpbmtpbmctZWZmb3J0IGNvbnRyb2wuIiwKICAiYXV0aG9yIjogImppeHkgPDQ2NzY3NzUyN0BxcS5jb20+IiwKICAicmVwb3NpdG9yeSI6IHsKICAgICJ0eXBlIjogImdpdCIsCiAgICAidXJsIjogImdpdCtodHRwczovL2dpdGh1Yi5jb20vbGl1eGluZzc5NTQvcGFzZW8tZHNoLmdpdCIsCiAgICAiZGlyZWN0b3J5IjogImRzaC1icmlkZ2UiCiAgfSwKICAiaG9tZXBhZ2UiOiAiaHR0cHM6Ly9naXRodWIuY29tL2xpdXhpbmc3OTU0L3Bhc2VvLWRzaCNyZWFkbWUiLAogICJidWdzIjogImh0dHBzOi8vZ2l0aHViLmNvbS9saXV4aW5nNzk1NC9wYXNlby1kc2gvaXNzdWVzIiwKICAidHlwZSI6ICJtb2R1bGUiLAogICJtYWluIjogImxpYi9pbmRleC5qcyIsCiAgImV4cG9ydHMiOiB7CiAgICAiLiI6ICIuL2xpYi9pbmRleC5qcyIsCiAgICAiLi9jb3JkaXMucGF0Y2gueW1sIjogIi4vY29yZGlzLnBhdGNoLnltbCIsCiAgICAiLi9wYWNrYWdlLmpzb24iOiAiLi9wYWNrYWdlLmpzb24iCiAgfSwKICAiZmlsZXMiOiBbCiAgICAibGliIiwKICAgICJjb3JkaXMucGF0Y2gueW1sIgogIF0sCiAgImxpY2Vuc2UiOiAiTUlUIiwKICAiZHNoIjogewogICAgImJ1bmRsZSI6IHsKICAgICAgInBhdGNoIjogIi4vY29yZGlzLnBhdGNoLnltbCIKICAgIH0KICB9LAogICJwZWVyRGVwZW5kZW5jaWVzIjogewogICAgIkBkZWVwc2Vlay1haS9jb3JkaXMiOiAifjQuMC40IgogIH0KfQo=",
17
+ };
18
+
19
+ /** The starter cordis.patch.yml written only when the profile has none. */
20
+ export const PROFILE_PATCH_TEMPLATE_BASE64 = "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";
@@ -0,0 +1,385 @@
1
+ /**
2
+ * One `dsh --profile paseo` child process, speaking the bridge's stdio JSON-RPC.
3
+ *
4
+ * A process owns exactly one agent session. DSH pins the working directory,
5
+ * provider, model and reasoning effort at `initialize`, so a session per
6
+ * process is what lets Paseo run several workspaces against one provider.
7
+ *
8
+ * @module dsh-paseo/server/dsh-process
9
+ */
10
+ import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
11
+ import { existsSync } from "node:fs";
12
+
13
+ /** Provider/model/thinking route pinned for the life of one process. */
14
+ export interface DshRoute {
15
+ provider: string;
16
+ model: string;
17
+ reasoningEffort?: string;
18
+ }
19
+
20
+ /** One question the model asked, mirroring DSH's `AskUserQuestionItem`. */
21
+ export interface DshQuestion {
22
+ id: string;
23
+ question: string;
24
+ detail?: string;
25
+ header?: string;
26
+ options?: Array<{ label: string; description?: string }>;
27
+ multiSelect?: boolean;
28
+ intent?: { kind: string; approve?: string; callId?: string };
29
+ }
30
+
31
+ /** One answer batch returned to DSH. */
32
+ export interface DshAnswer {
33
+ answers: Array<{ id: string; selected: string[]; custom?: string }>;
34
+ }
35
+
36
+ /** A server -> client question request raised by the DSH bridge. */
37
+ export interface DshQuestionRequest {
38
+ callId: string | null;
39
+ timed: boolean;
40
+ questions: DshQuestion[];
41
+ }
42
+
43
+ /** A `session.event` payload's outer envelope. */
44
+ export interface DshSessionEvent {
45
+ sessionId: string;
46
+ event: { type: string; [key: string]: unknown };
47
+ }
48
+
49
+ /** One model the runtime advertises, with its adapter-owned reasoning efforts. */
50
+ export interface DshCatalogModel {
51
+ provider: string;
52
+ id: string;
53
+ name: string;
54
+ description?: string;
55
+ reasoning?: {
56
+ defaultEffort?: string;
57
+ efforts: Array<{ id: string; name: string; description?: string }>;
58
+ };
59
+ }
60
+
61
+ /** The runtime's provider/model catalog. */
62
+ export interface DshCatalog {
63
+ providers: Array<{ id: string; name: string }>;
64
+ models: DshCatalogModel[];
65
+ defaultProvider?: string;
66
+ defaultModel?: string;
67
+ defaultReasoningEffort?: string | null;
68
+ planMode?: boolean;
69
+ }
70
+
71
+ /**
72
+ * One entry of the composer's `/` menu. `kind` decides how running it works:
73
+ * a registered `command` executes in the runtime, a `skill` rides a `/name`
74
+ * user message that DSH's skill tool turns into an injected instruction set.
75
+ */
76
+ export interface DshCommand {
77
+ name: string;
78
+ description: string;
79
+ argumentHint?: string;
80
+ kind: "command" | "skill";
81
+ }
82
+
83
+ export interface DshProcessHandlers {
84
+ onEvent(payload: DshSessionEvent): void;
85
+ onStatus(status: string): void;
86
+ onQuestion(request: DshQuestionRequest): Promise<DshAnswer>;
87
+ onLog(line: string): void;
88
+ onExit(code: number | null, signal: string | null): void;
89
+ onProtocolError(message: string): void;
90
+ }
91
+
92
+ export interface DshProcessOptions extends DshProcessHandlers {
93
+ cwd: string;
94
+ route: DshRoute;
95
+ sessionId: string;
96
+ /** Extra environment for the child; merged over the daemon's environment. */
97
+ env?: Record<string, string>;
98
+ /**
99
+ * Whether `start()` pins a route with `initialize`. Catalog reads skip it,
100
+ * because `paseo/catalog` needs no agent and a bad route must not hide the
101
+ * model list that would let the user pick a good one.
102
+ */
103
+ initializeRoute?: boolean;
104
+ }
105
+
106
+ const BINARY_CANDIDATES = [
107
+ process.env.DSH_BINARY,
108
+ "dsh",
109
+ `${process.env.HOME ?? ""}/.local/bin/dsh`,
110
+ ].filter((value): value is string => typeof value === "string" && value.length > 0);
111
+
112
+ function resolveBinary(): string {
113
+ for (const candidate of BINARY_CANDIDATES) {
114
+ if (candidate.includes("/") && existsSync(candidate)) return candidate;
115
+ if (!candidate.includes("/")) return candidate;
116
+ }
117
+ return "dsh";
118
+ }
119
+
120
+ function toError(value: unknown, fallback: string): Error {
121
+ if (value instanceof Error) return value;
122
+ if (typeof value === "object" && value !== null && "message" in value) {
123
+ return new Error(String((value as { message: unknown }).message));
124
+ }
125
+ return new Error(fallback);
126
+ }
127
+
128
+ interface Pending {
129
+ resolve(value: unknown): void;
130
+ reject(error: Error): void;
131
+ }
132
+
133
+ export class DshProcess {
134
+ readonly #options: DshProcessOptions;
135
+ #child: ChildProcessWithoutNullStreams | undefined;
136
+ #buffer = "";
137
+ #pending = new Map<number, Pending>();
138
+ #nextId = 1;
139
+ #closed = false;
140
+ #initializeTask: Promise<void> | undefined;
141
+
142
+ constructor(options: DshProcessOptions) {
143
+ this.#options = options;
144
+ }
145
+
146
+ /** Spawn the child and complete `initialize`. Idempotent. */
147
+ start(): Promise<void> {
148
+ this.#initializeTask ??= this.#start();
149
+ return this.#initializeTask;
150
+ }
151
+
152
+ async #start(): Promise<void> {
153
+ const child = spawn(resolveBinary(), ["--profile", process.env.DSH_PASEO_PROFILE ?? "paseo"], {
154
+ cwd: this.#options.cwd,
155
+ stdio: ["pipe", "pipe", "pipe"],
156
+ env: { ...process.env, ...this.#options.env },
157
+ });
158
+ this.#child = child;
159
+
160
+ child.stdout.setEncoding("utf8");
161
+ child.stdout.on("data", (chunk: string) => this.#consume(chunk));
162
+ child.stderr.setEncoding("utf8");
163
+ child.stderr.on("data", (chunk: string) => {
164
+ for (const line of chunk.split("\n")) {
165
+ if (line.trim() !== "") this.#options.onLog(line);
166
+ }
167
+ });
168
+ child.on("error", (error) => {
169
+ this.#failAll(error);
170
+ this.#options.onProtocolError(error.message);
171
+ });
172
+ child.on("exit", (code, signal) => {
173
+ this.#closed = true;
174
+ this.#failAll(new Error("DeepSeek Harness process ended"));
175
+ this.#options.onExit(code, signal);
176
+ });
177
+
178
+ if (this.#options.initializeRoute === false) return;
179
+
180
+ await this.#request("initialize", {
181
+ cwd: this.#options.cwd,
182
+ provider: this.#options.route.provider,
183
+ model: this.#options.route.model,
184
+ ...(this.#options.route.reasoningEffort === undefined
185
+ ? {}
186
+ : { reasoningEffort: this.#options.route.reasoningEffort }),
187
+ });
188
+ }
189
+
190
+ /** Read the runtime's provider/model catalog without creating an agent. */
191
+ async catalog(): Promise<DshCatalog> {
192
+ return (await this.#request("paseo/catalog", {}, 60000)) as DshCatalog;
193
+ }
194
+
195
+ /** List the session's registered commands and user-invocable skills. */
196
+ async commands(): Promise<DshCommand[]> {
197
+ const result = (await this.#request(
198
+ "paseo/commands",
199
+ { sessionId: this.#options.sessionId },
200
+ 60000,
201
+ )) as { commands?: DshCommand[] };
202
+ return result.commands ?? [];
203
+ }
204
+
205
+ /** Execute one registered slash command (skills are sent as text instead). */
206
+ async runCommand(name: string, args: string): Promise<{ kind: "success" | "error"; text?: string }> {
207
+ return (await this.#request("paseo/command/run", {
208
+ sessionId: this.#options.sessionId,
209
+ name,
210
+ arguments: args,
211
+ })) as { kind: "success" | "error"; text?: string };
212
+ }
213
+
214
+ /** Send one text prompt. Resolves when the bridge accepts it, not when the turn ends. */
215
+ async prompt(
216
+ text: string,
217
+ contentBlocks?: unknown[],
218
+ delivery?: "auto" | "steer",
219
+ ): Promise<void> {
220
+ await this.#request("session/prompt", {
221
+ sessionId: this.#options.sessionId,
222
+ contentBlocks: contentBlocks ?? [{ type: "text", text }],
223
+ ...(delivery === undefined ? {} : { delivery }),
224
+ });
225
+ }
226
+
227
+ /** Cancel the running turn while keeping the session usable afterwards. */
228
+ async cancel(): Promise<void> {
229
+ await this.#request("session/cancel", { sessionId: this.#options.sessionId });
230
+ }
231
+
232
+ /** Select plan mode and return the committed state. */
233
+ async setPlan(active: boolean): Promise<{ active: boolean; pending: boolean; outcome?: string }> {
234
+ return (await this.#request("paseo/plan/set", {
235
+ sessionId: this.#options.sessionId,
236
+ active,
237
+ })) as { active: boolean; pending: boolean; outcome?: string };
238
+ }
239
+
240
+ /** Read the committed plan state. */
241
+ async getPlan(): Promise<{ active: boolean; pending: boolean; available: boolean }> {
242
+ return (await this.#request("paseo/plan/get", {
243
+ sessionId: this.#options.sessionId,
244
+ })) as { active: boolean; pending: boolean; available: boolean };
245
+ }
246
+
247
+ /** Switch model and/or reasoning effort on the live agent. */
248
+ async setConfig(changes: {
249
+ model?: string;
250
+ provider?: string;
251
+ reasoningEffort?: string | null;
252
+ }): Promise<{ provider: string; model: string; reasoningEffort: string | null }> {
253
+ return (await this.#request("paseo/config/set", {
254
+ sessionId: this.#options.sessionId,
255
+ ...changes,
256
+ })) as { provider: string; model: string; reasoningEffort: string | null };
257
+ }
258
+
259
+ /** Ask the bridge to dispose the agent and exit. */
260
+ async shutdown(): Promise<void> {
261
+ if (this.#closed) return;
262
+ try {
263
+ await this.#request("shutdown", {}, 5000);
264
+ } catch {
265
+ /* the child may exit before answering */
266
+ }
267
+ this.kill();
268
+ }
269
+
270
+ /** Terminate the child without a protocol shutdown. */
271
+ kill(): void {
272
+ this.#closed = true;
273
+ this.#child?.kill("SIGTERM");
274
+ const child = this.#child;
275
+ setTimeout(() => {
276
+ if (child !== undefined && child.exitCode === null && child.signalCode === null) {
277
+ child.kill("SIGKILL");
278
+ }
279
+ }, 4000).unref?.();
280
+ }
281
+
282
+ #request(method: string, params: unknown, timeoutMs = 120000): Promise<unknown> {
283
+ if (this.#closed || this.#child === undefined) {
284
+ return Promise.reject(new Error("DeepSeek Harness process is not running"));
285
+ }
286
+ const id = this.#nextId++;
287
+ return new Promise<unknown>((resolve, reject) => {
288
+ const timer = setTimeout(() => {
289
+ if (this.#pending.delete(id)) reject(new Error(`DeepSeek Harness did not answer ${method}`));
290
+ }, timeoutMs);
291
+ timer.unref?.();
292
+ this.#pending.set(id, {
293
+ resolve: (value) => {
294
+ clearTimeout(timer);
295
+ resolve(value);
296
+ },
297
+ reject: (error) => {
298
+ clearTimeout(timer);
299
+ reject(error);
300
+ },
301
+ });
302
+ this.#send({ jsonrpc: "2.0", id, method, params });
303
+ });
304
+ }
305
+
306
+ #send(frame: unknown): void {
307
+ try {
308
+ this.#child?.stdin.write(`${JSON.stringify(frame)}\n`);
309
+ } catch (error) {
310
+ this.#options.onProtocolError(toError(error, "failed to write to the bridge").message);
311
+ }
312
+ }
313
+
314
+ #consume(chunk: string): void {
315
+ this.#buffer += chunk;
316
+ const lines = this.#buffer.split("\n");
317
+ this.#buffer = lines.pop() ?? "";
318
+ for (const line of lines) {
319
+ if (line.trim() === "") continue;
320
+ let frame: Record<string, unknown>;
321
+ try {
322
+ frame = JSON.parse(line) as Record<string, unknown>;
323
+ } catch {
324
+ this.#options.onLog(line);
325
+ continue;
326
+ }
327
+ void this.#dispatch(frame);
328
+ }
329
+ }
330
+
331
+ async #dispatch(frame: Record<string, unknown>): Promise<void> {
332
+ const method = typeof frame.method === "string" ? frame.method : undefined;
333
+ const id = frame.id;
334
+
335
+ if (method === "paseo/question" && id !== undefined) {
336
+ try {
337
+ const params = (frame.params ?? {}) as DshQuestionRequest;
338
+ const answer = await this.#options.onQuestion({
339
+ callId: params.callId ?? null,
340
+ timed: params.timed === true,
341
+ questions: params.questions ?? [],
342
+ });
343
+ this.#send({ jsonrpc: "2.0", id, result: answer });
344
+ } catch (error) {
345
+ this.#send({
346
+ jsonrpc: "2.0",
347
+ id,
348
+ error: { code: -32000, message: toError(error, "question cancelled").message },
349
+ });
350
+ }
351
+ return;
352
+ }
353
+
354
+ if (method === "session.event") {
355
+ this.#options.onEvent(frame.params as DshSessionEvent);
356
+ return;
357
+ }
358
+ if (method === "session.status") {
359
+ const params = frame.params as { status?: string } | undefined;
360
+ this.#options.onStatus(params?.status ?? "unknown");
361
+ return;
362
+ }
363
+ if (method !== undefined) {
364
+ if (id !== undefined) {
365
+ this.#send({ jsonrpc: "2.0", id, error: { code: -32601, message: `unsupported ${method}` } });
366
+ }
367
+ return;
368
+ }
369
+
370
+ if (id !== undefined && typeof id === "number") {
371
+ const entry = this.#pending.get(id);
372
+ if (entry === undefined) return;
373
+ this.#pending.delete(id);
374
+ const error = frame.error as { message?: string } | undefined;
375
+ if (error !== undefined) entry.reject(new Error(error.message ?? "bridge request failed"));
376
+ else entry.resolve(frame.result);
377
+ }
378
+ }
379
+
380
+ #failAll(error: Error): void {
381
+ const entries = [...this.#pending.values()];
382
+ this.#pending.clear();
383
+ for (const entry of entries) entry.reject(error);
384
+ }
385
+ }