paseo-dsh 0.2.0 → 0.2.2

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.
package/README.md CHANGED
@@ -16,6 +16,14 @@ including the stdio bridge bundle it carries — no shell script, no manual
16
16
  profile setup. The only thing left is your model route in
17
17
  `~/.dsh/profiles/paseo/cordis.patch.yml`.
18
18
 
19
+ This package also ships a small CLI for that setup:
20
+
21
+ ```bash
22
+ npx paseo-dsh doctor # check CLIs, profile, bridge, model route and credentials
23
+ npx paseo-dsh probe --base-url https://your-gateway/v1 \
24
+ --api-key-env YOUR_KEY_ENV --model your-model-id # discover reasoning levels etc.
25
+ ```
26
+
19
27
  What you get that the ACP boundary can't carry:
20
28
 
21
29
  - `ask_user_question` → real Paseo question cards
@@ -24,6 +32,8 @@ What you get that the ACP boundary can't carry:
24
32
  - Steer into the running turn
25
33
  - Images admitted into DSH's attachment store, delivered per the route's modality
26
34
  - A `/` menu with DSH's registered commands **and** user-invocable skills
35
+ - A **Permissions** select in the composer that switches DSH's sandbox preset
36
+ (read-only / workspace-write / danger-full-access)
27
37
 
28
38
  Full documentation, the adoption guide, and 18 real defects with their fixes
29
39
  live in the main repository: **https://github.com/liuxing7954/paseo-dsh**
@@ -0,0 +1,49 @@
1
+ #!/usr/bin/env node
2
+ /**
3
+ * `paseo-dsh` CLI — helper commands for a DeepSeek Harness × Paseo install.
4
+ *
5
+ * paseo-dsh doctor self-check the install (CLIs, profile, bridge, route, key)
6
+ * paseo-dsh probe probe a model route's reasoning/developer-role support
7
+ * paseo-dsh help
8
+ *
9
+ * Ships inside the `paseo-dsh` npm package, so it runs from `npx paseo-dsh ...`
10
+ * with no repository clone.
11
+ *
12
+ * @module paseo-dsh/bin
13
+ */
14
+ import { runDoctor } from "../lib/doctor.mjs";
15
+ import { runProbe } from "../lib/probe-provider.mjs";
16
+
17
+ const HELP = `paseo-dsh — DeepSeek Harness × Paseo helper
18
+
19
+ Usage:
20
+ paseo-dsh doctor Check this install: dsh/paseo, the DSH
21
+ profile, the bridge, the model route, keys.
22
+ paseo-dsh probe [options] Probe a model route before writing its config.
23
+ --base-url <url> OpenAI-compatible endpoint, e.g. https://gw/v1
24
+ --api-key-env <ENV_VAR> Env var holding the key (never printed)
25
+ --model <id> [--model <id>] One or more model ids
26
+ paseo-dsh help
27
+
28
+ Install the plugin itself with: paseo plugin add npm:paseo-dsh
29
+ `;
30
+
31
+ const [command, ...rest] = process.argv.slice(2);
32
+
33
+ switch (command) {
34
+ case undefined:
35
+ case "doctor":
36
+ runDoctor();
37
+ break;
38
+ case "probe":
39
+ await runProbe(rest, "paseo-dsh probe");
40
+ break;
41
+ case "help":
42
+ case "-h":
43
+ case "--help":
44
+ process.stdout.write(HELP);
45
+ break;
46
+ default:
47
+ process.stderr.write(`unknown command "${command}"\n\n${HELP}`);
48
+ process.exitCode = 2;
49
+ }
package/lib/doctor.mjs ADDED
@@ -0,0 +1,176 @@
1
+ /**
2
+ * `paseo-dsh doctor` — one-command self-check for a DeepSeek Harness × Paseo
3
+ * install.
4
+ *
5
+ * It verifies the things that silently break a fresh install: the CLIs are
6
+ * present, the plugin has provisioned the DSH profile (which only happens once
7
+ * the daemon loads the plugin), the bridge is materialized, a model route is
8
+ * actually configured, and every referenced `apiKeyEnv` has a credential. It
9
+ * only reads; it never changes anything.
10
+ *
11
+ * @module paseo-dsh/lib/doctor
12
+ */
13
+ import { execFileSync } from "node:child_process";
14
+ import { existsSync, readFileSync } from "node:fs";
15
+ import { homedir } from "node:os";
16
+ import { dirname, join } from "node:path";
17
+ import { fileURLToPath } from "node:url";
18
+
19
+ const HERE = dirname(fileURLToPath(import.meta.url));
20
+
21
+ const GREEN = "\u001b[32m";
22
+ const YELLOW = "\u001b[33m";
23
+ const RED = "\u001b[31m";
24
+ const DIM = "\u001b[2m";
25
+ const RESET = "\u001b[0m";
26
+
27
+ const results = [];
28
+ function report(level, label, detail) {
29
+ results.push(level);
30
+ const tag = level === "ok" ? `${GREEN}ok ${RESET}` : level === "warn" ? `${YELLOW}warn${RESET}` : `${RED}fail${RESET}`;
31
+ process.stdout.write(` [${tag}] ${label}${detail ? `\n ${DIM}${detail}${RESET}` : ""}\n`);
32
+ }
33
+
34
+ function run(cmd, args) {
35
+ try {
36
+ return execFileSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
37
+ } catch {
38
+ return undefined;
39
+ }
40
+ }
41
+
42
+ function findPaseo() {
43
+ // Prefer the app-bundled CLI: a `paseo` on PATH is often a stale npm install.
44
+ const bundled = "/Applications/Paseo.app/Contents/Resources/bin/paseo";
45
+ if (existsSync(bundled)) {
46
+ const v = run(bundled, ["--version"]);
47
+ if (v !== undefined) return { cmd: bundled, version: v };
48
+ }
49
+ const v = run("paseo", ["--version"]);
50
+ if (v !== undefined) return { cmd: "paseo", version: v };
51
+ return undefined;
52
+ }
53
+
54
+ function line(v) {
55
+ return v.split("\n").find((entry) => entry.trim() !== "") ?? v;
56
+ }
57
+
58
+ /** Strip full-line comments so "route configured?" isn't fooled by the template. */
59
+ function activeLines(text) {
60
+ return text
61
+ .split("\n")
62
+ .filter((l) => !l.trimStart().startsWith("#"))
63
+ .join("\n");
64
+ }
65
+
66
+ export function runDoctor() {
67
+ const pluginVersion = JSON.parse(readFileSync(join(HERE, "..", "package.json"), "utf8")).version;
68
+ const dshHome = process.env.DSH_HOME ?? join(homedir(), ".dsh");
69
+ const profile = process.env.DSH_PASEO_PROFILE ?? "paseo";
70
+ const profileDir = join(dshHome, "profiles", profile);
71
+
72
+ process.stdout.write(`\n${DIM}paseo-dsh doctor (plugin ${pluginVersion})${RESET}\n\n`);
73
+
74
+ // 1. CLIs
75
+ const dshVersion = run("dsh", ["--version"]);
76
+ if (dshVersion === undefined) {
77
+ report("fail", "dsh on PATH", "install the official DeepSeek Harness and put `dsh` on the daemon's PATH");
78
+ } else {
79
+ const dshLine = line(dshVersion);
80
+ const dshMM = dshLine.match(/(\d+)\.(\d+)/);
81
+ const pluginMM = pluginVersion.match(/^(\d+)\.(\d+)/);
82
+ if (dshMM && pluginMM && `${dshMM[1]}.${dshMM[2]}` !== `${pluginMM[1]}.${pluginMM[2]}`) {
83
+ report("warn", `dsh ${dshLine}`, `plugin ${pluginVersion} targets the ${pluginMM[1]}.${pluginMM[2]}.x DSH line`);
84
+ } else {
85
+ report("ok", `dsh ${dshLine}`);
86
+ }
87
+ }
88
+
89
+ const paseo = findPaseo();
90
+ if (paseo === undefined) {
91
+ report("fail", "paseo CLI not found", "expected `paseo` on PATH or /Applications/Paseo.app");
92
+ } else if (Number(paseo.version.match(/\d+\.(\d+)/)?.[1] ?? 0) < 9) {
93
+ report("warn", `paseo ${paseo.version}`, "needs Paseo >= 0.9.2 for the direct provider plugin API");
94
+ } else {
95
+ report("ok", `paseo ${paseo.version}`);
96
+ }
97
+
98
+ // 2. profile provisioned by the plugin
99
+ if (!existsSync(profileDir)) {
100
+ report(
101
+ "fail",
102
+ `DSH profile "${profile}" missing`,
103
+ `expected ${profileDir}. Install the plugin and restart the daemon — the plugin creates it on load.`,
104
+ );
105
+ finish(pluginVersion);
106
+ return;
107
+ }
108
+ report("ok", `DSH profile at ${profileDir}`);
109
+
110
+ const bridgeDir = join(profileDir, "node_modules", "dsh-paseo-bridge");
111
+ const bridgeEntry = join(bridgeDir, "lib", "server.js");
112
+ if (existsSync(bridgeEntry)) {
113
+ report("ok", "bridge bundle provisioned", bridgeDir);
114
+ } else {
115
+ report("fail", "bridge bundle missing", `expected ${bridgeEntry}; restart the daemon to let the plugin re-provision`);
116
+ }
117
+
118
+ // 3. model route
119
+ const patchPath = join(profileDir, "cordis.patch.yml");
120
+ if (!existsSync(patchPath)) {
121
+ report("fail", "no cordis.patch.yml", `the plugin should have written one at ${patchPath}`);
122
+ finish(pluginVersion);
123
+ return;
124
+ }
125
+ const patch = readFileSync(patchPath, "utf8");
126
+ const active = activeLines(patch);
127
+ const configured = active.includes("agent-default-model") && /providers:\s*$/m.test(active);
128
+ if (configured) {
129
+ const tail = active.split("agent-default-model").pop() ?? "";
130
+ const provider = tail.match(/provider:\s*([^\s#]+)/)?.[1];
131
+ const model = tail.match(/model:\s*([^\s#]+)/)?.[1];
132
+ report("ok", "model route configured", provider && model ? `default: ${provider} / ${model}` : undefined);
133
+ } else {
134
+ report(
135
+ "warn",
136
+ "model route not configured yet",
137
+ `edit ${patchPath} (see the README install walkthrough) then restart the daemon`,
138
+ );
139
+ }
140
+
141
+ // 4. credentials for every referenced apiKeyEnv
142
+ const credentialPath = join(dshHome, ".credentials.yaml");
143
+ const credentialText = existsSync(credentialPath) ? readFileSync(credentialPath, "utf8") : "";
144
+ const referenced = [...active.matchAll(/apiKeyEnv:\s*([A-Za-z0-9_]+)/g)].map((m) => m[1]);
145
+ const unique = [...new Set(referenced)];
146
+ if (unique.length === 0) {
147
+ report("warn", "no apiKeyEnv referenced", "the route above should name the credential to use");
148
+ } else {
149
+ for (const name of unique) {
150
+ const has = new RegExp(`(^|\\n)\\s*${name}\\s*:`).test(credentialText);
151
+ if (has) report("ok", `credential ${name} found`);
152
+ else
153
+ report(
154
+ "warn",
155
+ `credential ${name} missing`,
156
+ `add "${name}: <your-key>" under refs: in ${credentialPath}`,
157
+ );
158
+ }
159
+ }
160
+
161
+ finish(pluginVersion);
162
+ }
163
+
164
+ function finish() {
165
+ const fails = results.filter((r) => r === "fail").length;
166
+ const warns = results.filter((r) => r === "warn").length;
167
+ process.stdout.write("\n");
168
+ if (fails > 0) {
169
+ process.stdout.write(`${RED}${fails} blocking issue(s)${RESET}${warns ? `, ${warns} warning(s)` : ""}.\n`);
170
+ process.exitCode = 1;
171
+ } else if (warns > 0) {
172
+ process.stdout.write(`${YELLOW}${warns} warning(s)${RESET} — nothing blocking, but fix the above before relying on it.\n`);
173
+ } else {
174
+ process.stdout.write(`${GREEN}All checks passed.${RESET} New a session in Paseo with provider "DeepSeek Harness (native)".\n`);
175
+ }
176
+ }
@@ -0,0 +1,211 @@
1
+ #!/usr/bin/env node
2
+ /**
3
+ * Discover what a model route can actually do, so its capabilities can be
4
+ * declared in a DSH profile with evidence instead of guesswork.
5
+ *
6
+ * DSH resolves a route's reasoning support from its model metadata. A route the
7
+ * installed catalog knows nothing about — any self-hosted or self-configured
8
+ * provider — reports *no* reasoning at all, and DSH then rejects every effort
9
+ * with `UNSUPPORTED_REASONING_EFFORT`. That reads like a model limitation but is
10
+ * usually just a missing declaration, so this probes the endpoint itself.
11
+ *
12
+ * It answers the two questions that decide the profile config:
13
+ * 1. Does the route do reasoning, and which `reasoning_effort` spellings does
14
+ * it accept? (`off` is special: the parameter must be omitted entirely,
15
+ * because most gateways reject the literal string.)
16
+ * 2. Does it accept the OpenAI reasoning-model `developer` role? If not, the
17
+ * profile must set `compat.supportsDeveloperRole: false`, or every turn
18
+ * fails with a 422 the moment reasoning is declared.
19
+ *
20
+ * The key is read from the named environment variable and never printed.
21
+ *
22
+ * Exposed as a function so the `paseo-dsh` CLI and the repo's standalone
23
+ * `tools/probe-provider.mjs` share one implementation.
24
+ *
25
+ * @module paseo-dsh/lib/probe-provider
26
+ */
27
+ import { pathToFileURL } from "node:url";
28
+
29
+ const CANDIDATE_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"];
30
+
31
+ /** Parse `--flag value` pairs into a plain object. */
32
+ function parseArgs(argv) {
33
+ const out = {};
34
+ for (let i = 0; i < argv.length; i += 1) {
35
+ const token = argv[i];
36
+ if (!token.startsWith("--")) continue;
37
+ const key = token.slice(2);
38
+ const next = argv[i + 1];
39
+ if (next === undefined || next.startsWith("--")) {
40
+ out[key] = true;
41
+ } else {
42
+ out[key] = next;
43
+ i += 1;
44
+ }
45
+ }
46
+ return out;
47
+ }
48
+
49
+ function usage(program, message) {
50
+ if (message !== undefined) process.stderr.write(`error: ${message}\n\n`);
51
+ process.stderr.write(
52
+ `usage: ${program} --base-url <url> --api-key-env <ENV_VAR> --model <id> [--model <id>...]\n`,
53
+ );
54
+ process.exit(message === undefined ? 0 : 2);
55
+ }
56
+
57
+ /** One chat completion, reporting whether the endpoint accepted the request. */
58
+ async function attempt(endpoint, apiKey, body) {
59
+ let response;
60
+ try {
61
+ response = await fetch(endpoint, {
62
+ method: "POST",
63
+ headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
64
+ body: JSON.stringify(body),
65
+ signal: AbortSignal.timeout(120_000),
66
+ });
67
+ } catch (error) {
68
+ return { ok: false, status: 0, detail: error instanceof Error ? error.message : String(error) };
69
+ }
70
+ const text = await response.text();
71
+ let parsed;
72
+ try {
73
+ parsed = JSON.parse(text);
74
+ } catch {
75
+ parsed = undefined;
76
+ }
77
+ if (!response.ok) {
78
+ const detail = parsed?.error?.message ?? parsed?.message ?? text.slice(0, 240);
79
+ return { ok: false, status: response.status, detail: String(detail) };
80
+ }
81
+ return { ok: true, status: response.status, body: parsed };
82
+ }
83
+
84
+ /** The message object of the first choice, if the response carried one. */
85
+ function messageOf(body) {
86
+ return body?.choices?.[0]?.message;
87
+ }
88
+
89
+ function reasoningChars(message) {
90
+ return String(message?.reasoning_content ?? message?.reasoning ?? "").length;
91
+ }
92
+
93
+ async function probeModel(endpoint, apiKey, model) {
94
+ const findings = { levels: [], developerRole: undefined, reasonsAtBaseline: undefined };
95
+
96
+ const baseline = await attempt(endpoint, apiKey, {
97
+ model,
98
+ messages: [{ role: "user", content: "What is 17*23? Reply with just the number." }],
99
+ max_tokens: 256,
100
+ });
101
+ if (!baseline.ok) return { ...findings, fatal: baseline };
102
+
103
+ const baselineMessage = messageOf(baseline.body);
104
+ findings.reasonsAtBaseline =
105
+ baselineMessage === undefined ? false : "reasoning_content" in baselineMessage || reasoningChars(baselineMessage) > 0;
106
+
107
+ const developer = await attempt(endpoint, apiKey, {
108
+ model,
109
+ messages: [
110
+ { role: "developer", content: "You are terse." },
111
+ { role: "user", content: "What is 17*23? Reply with just the number." },
112
+ ],
113
+ max_tokens: 256,
114
+ });
115
+ findings.developerRole = developer.ok;
116
+
117
+ for (const level of CANDIDATE_LEVELS) {
118
+ const result = await attempt(endpoint, apiKey, {
119
+ model,
120
+ messages: [{ role: "user", content: "What is 17*23? Reply with just the number." }],
121
+ max_tokens: 256,
122
+ reasoning_effort: level,
123
+ });
124
+ findings.levels.push({ level, ok: result.ok, status: result.status, detail: result.detail });
125
+ }
126
+ return findings;
127
+ }
128
+
129
+ /** Render the profile fragment a user can paste after the probe. */
130
+ function profileSnippet(model, findings) {
131
+ const accepted = findings.levels.filter((entry) => entry.ok).map((entry) => entry.level);
132
+ const lines = [` - id: ${model}`, ` name: ${model}`];
133
+ if (accepted.length === 0) return lines.join("\n");
134
+ lines.push(" reasoningEfforts:");
135
+ // `off` must carry no value: omitting the parameter is what turns thinking
136
+ // off, while the literal string is rejected by most gateways.
137
+ lines.push(" off:");
138
+ for (const level of accepted) lines.push(` ${level}: ${level}`);
139
+ return lines.join("\n");
140
+ }
141
+
142
+ /**
143
+ * Run the probe. `argv` excludes the node/script prefix.
144
+ * @param {string[]} argv
145
+ * @param {string} program - Program name shown in usage/errors.
146
+ */
147
+ export async function runProbe(argv, program = "paseo-dsh probe") {
148
+ const args = parseArgs(argv);
149
+ if (args.help === true) usage(program);
150
+ const baseUrl = typeof args["base-url"] === "string" ? args["base-url"].replace(/\/$/, "") : undefined;
151
+ const keyEnv = typeof args["api-key-env"] === "string" ? args["api-key-env"] : undefined;
152
+ const models = [];
153
+ for (let i = 0; i < argv.length; i += 1) {
154
+ if (argv[i] === "--model" && argv[i + 1] !== undefined) models.push(argv[i + 1]);
155
+ }
156
+ if (baseUrl === undefined) usage(program, "--base-url is required");
157
+ if (keyEnv === undefined) usage(program, "--api-key-env is required");
158
+ if (models.length === 0) usage(program, "at least one --model is required");
159
+
160
+ const apiKey = process.env[keyEnv];
161
+ if (apiKey === undefined || apiKey === "") {
162
+ process.stderr.write(`error: environment variable ${keyEnv} is empty or unset\n`);
163
+ process.exit(2);
164
+ }
165
+
166
+ const endpoint = `${baseUrl}/chat/completions`;
167
+ process.stdout.write(`endpoint: ${endpoint}\n\n`);
168
+
169
+ for (const model of models) {
170
+ process.stdout.write(`model: ${model}\n`);
171
+ const findings = await probeModel(endpoint, apiKey, model);
172
+ if (findings.fatal !== undefined) {
173
+ process.stdout.write(
174
+ ` baseline call .......... FAILED (${findings.fatal.status || "network"}) ${findings.fatal.detail}\n`,
175
+ );
176
+ process.stdout.write(" cannot probe further; check the base URL, key, and model id\n\n");
177
+ continue;
178
+ }
179
+ process.stdout.write(
180
+ ` baseline call .......... ok (reasoning content at baseline: ${
181
+ findings.reasonsAtBaseline ? "yes" : "no"
182
+ })\n`,
183
+ );
184
+ process.stdout.write(
185
+ ` role=developer ......... ${
186
+ findings.developerRole ? "accepted" : "REJECTED -> needs compat.supportsDeveloperRole: false"
187
+ }\n`,
188
+ );
189
+ for (const entry of findings.levels) {
190
+ process.stdout.write(
191
+ ` reasoning_effort=${entry.level.padEnd(8)} ${entry.ok ? "accepted" : `rejected (${entry.status})`}\n`,
192
+ );
193
+ }
194
+ const accepted = findings.levels.filter((entry) => entry.ok);
195
+ process.stdout.write("\n profile fragment:\n\n");
196
+ process.stdout.write(`${profileSnippet(model, findings)}\n`);
197
+ if (accepted.length === 0) {
198
+ process.stdout.write(
199
+ "\n no reasoning_effort spelling was accepted; declare `reasoningEfforts: false`\n"
200
+ + " for this model so DSH reports it as a non-reasoning route\n",
201
+ );
202
+ }
203
+ process.stdout.write("\n");
204
+ }
205
+ }
206
+
207
+ const invokedDirectly =
208
+ process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
209
+ if (invokedDirectly) {
210
+ await runProbe(process.argv.slice(2), "node lib/probe-provider.mjs");
211
+ }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "paseo-dsh",
3
- "version": "0.2.0",
3
+ "version": "0.2.2",
4
4
  "description": "DeepSeek Harness (dsh) as a native Paseo provider: question cards, plan mode, thinking levels, steering, images and a real slash menu.",
5
5
  "keywords": [
6
6
  "paseo",
@@ -19,10 +19,15 @@
19
19
  },
20
20
  "homepage": "https://github.com/liuxing7954/paseo-dsh#readme",
21
21
  "bugs": "https://github.com/liuxing7954/paseo-dsh/issues",
22
+ "bin": {
23
+ "paseo-dsh": "bin/paseo-dsh.mjs"
24
+ },
22
25
  "files": [
23
26
  "paseo-plugin.json",
24
27
  "index.server.ts",
25
28
  "server/",
29
+ "lib/",
30
+ "bin/",
26
31
  "icon.svg",
27
32
  "README.md",
28
33
  "LICENSE"
@@ -11,7 +11,7 @@ export const BRIDGE_PACKAGE_NAME = "dsh-paseo-bridge";
11
11
  export const BRIDGE_FILES: Readonly<Record<string, string>> = {
12
12
  "cordis.patch.yml": "IyBUaGUgUGFzZW8gYnJpZGdlIGJ1bmRsZSBwYXRjaDogYW4gYXV0b21hdGlvbi1vbmx5IHN0ZGlvIHN1cmZhY2Ugb3ZlciBkc2gtYmFzZS4KIwojIFN0ZG91dCBjYXJyaWVzIHByb3RvY29sIGZyYW1lcyBvbmx5LiBUaGlzIHBhdGNoIG11c3QgbmV2ZXIgZW5hYmxlIGEgc3Rkb3V0CiMgbG9nZ2VyLiBJdCBtaXJyb3JzIHRoZSBzaGlwcGVkIHNkay1hcHAvYWNwLWFwcCBidW5kbGVzIHNvIHRoZSBzYW1lIGJhc2UKIyBhZGFwdGVycywgdG9vbHMsIHBlcnNpc3RlbmNlIGFuZCBwb2xpY3kgYXBwbHkuCgotIGlkOiBzeXN0ZW0tcHJvbXB0CiAgY29uZmlnOgogICAgcGVyc29uYVN1ZmZpeDogWW91ciB3b3JraW5nIGRpcmVjdG9yeSBpcyB7e2N3ZH19LgogICAgcGVyc29uYVByZWZpeDogPi0KICAgICAgWW91IGFyZSBhIGNvZGluZyBhZ2VudCBwb3dlcmVkIGJ5IHRoZSB7e21vZGVsfX0gbW9kZWwuCgotIGlkOiBzZXNzaW9uLXRpdGxlLWxsbQogIGRpc2FibGVkOiB0cnVlCgotIGluc2VydDoKICAgIC0gaWQ6IHBhc2VvLWJyaWRnZQogICAgICBuYW1lOiAnZHNoLXBhc2VvLWJyaWRnZScKICAgICAgaW5qZWN0OiBbY21kbGluZUFyZ3MsIGFnZW50c10KCi0gaWQ6IGhtcgogIGRpc2FibGVkOiB0cnVlCgojIFRoZSBxdWVzdGlvbiBzdXJmYWNlIGlzIG9wdC1pbiBwZXIgcHJlc2V0IGluIHRoZSBzaGlwcGVkIGJ1bmRsZXM7IHRoZSBicmlkZ2UKIyBuZWVkcyB0aGUgbW9kZWwtZmFjaW5nIHRvb2wgbW91bnRlZCBzbyB0aGUgbW9kZWwgY2FuIGFjdHVhbGx5IGFzay4KLSBpbnNlcnQ6CiAgICAtIGlkOiB0b29sLWFzay11c2VyCiAgICAgIG5hbWU6ICdAZGVlcHNlZWstYWkvZHNoLXRvb2wtYXNrLXVzZXInCg==",
13
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;
  }
}
",
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 session's permission preset and the switchable ones. */
  async permission(params) {
    const service = this.ctx.get('permissionPresets');
    if (service === undefined) return { available: false, current: null, presets: [] };
    const rec = await this.getOrCreateSession(params.sessionId);
    this.assertLiveAgent(rec, params.sessionId);
    return {
      available: true,
      current: service.current(rec.handle.agent.session),
      presets: [...service.names],
    };
  }

  /** 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/permission':
        return this.permission(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
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
16
  "package.json": "ewogICJuYW1lIjogImRzaC1wYXNlby1icmlkZ2UiLAogICJ2ZXJzaW9uIjogIjAuMS4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgImRlc2NyaXB0aW9uIjogIkRTSCBwcm9maWxlIGJ1bmRsZSB0aGF0IHNlcnZlcyBhIFBhc2VvLWRyaXZhYmxlIHJ1bnRpbWUgb3ZlciBzdGRpbyBKU09OLVJQQywgaW5jbHVkaW5nIHVzZXItcXVlc3Rpb24gY2FyZHMsIHBsYW4gbW9kZSBhbmQgdGhpbmtpbmctZWZmb3J0IGNvbnRyb2wuIiwKICAiYXV0aG9yIjogImppeHkgPDQ2NzY3NzUyN0BxcS5jb20+IiwKICAicmVwb3NpdG9yeSI6IHsKICAgICJ0eXBlIjogImdpdCIsCiAgICAidXJsIjogImdpdCtodHRwczovL2dpdGh1Yi5jb20vbGl1eGluZzc5NTQvcGFzZW8tZHNoLmdpdCIsCiAgICAiZGlyZWN0b3J5IjogImRzaC1icmlkZ2UiCiAgfSwKICAiaG9tZXBhZ2UiOiAiaHR0cHM6Ly9naXRodWIuY29tL2xpdXhpbmc3OTU0L3Bhc2VvLWRzaCNyZWFkbWUiLAogICJidWdzIjogImh0dHBzOi8vZ2l0aHViLmNvbS9saXV4aW5nNzk1NC9wYXNlby1kc2gvaXNzdWVzIiwKICAidHlwZSI6ICJtb2R1bGUiLAogICJtYWluIjogImxpYi9pbmRleC5qcyIsCiAgImV4cG9ydHMiOiB7CiAgICAiLiI6ICIuL2xpYi9pbmRleC5qcyIsCiAgICAiLi9jb3JkaXMucGF0Y2gueW1sIjogIi4vY29yZGlzLnBhdGNoLnltbCIsCiAgICAiLi9wYWNrYWdlLmpzb24iOiAiLi9wYWNrYWdlLmpzb24iCiAgfSwKICAiZmlsZXMiOiBbCiAgICAibGliIiwKICAgICJjb3JkaXMucGF0Y2gueW1sIgogIF0sCiAgImxpY2Vuc2UiOiAiTUlUIiwKICAiZHNoIjogewogICAgImJ1bmRsZSI6IHsKICAgICAgInBhdGNoIjogIi4vY29yZGlzLnBhdGNoLnltbCIKICAgIH0KICB9LAogICJwZWVyRGVwZW5kZW5jaWVzIjogewogICAgIkBkZWVwc2Vlay1haS9jb3JkaXMiOiAifjQuMC40IgogIH0KfQo=",
17
17
  };
@@ -211,6 +211,13 @@ export class DshProcess {
211
211
  })) as { kind: "success" | "error"; text?: string };
212
212
  }
213
213
 
214
+ /** Read the session's current permission preset and the switchable ones. */
215
+ async permission(): Promise<{ available: boolean; current: string | null; presets: string[] }> {
216
+ return (await this.#request("paseo/permission", {
217
+ sessionId: this.#options.sessionId,
218
+ })) as { available: boolean; current: string | null; presets: string[] };
219
+ }
220
+
214
221
  /** Send one text prompt. Resolves when the bridge accepts it, not when the turn ends. */
215
222
  async prompt(
216
223
  text: string,
@@ -276,6 +276,7 @@ class DshConnection implements ProviderConnection {
276
276
  // than failing the whole open.
277
277
  try {
278
278
  await session.loadCommands();
279
+ await session.loadPermission();
279
280
  } catch (error) {
280
281
  process.stderr.write(`[${PROVIDER_ID}] command catalog failed: ${messageOf(error)}\n`);
281
282
  }
package/server/session.ts CHANGED
@@ -77,6 +77,9 @@ export class DshSession {
77
77
  #pendingPermissions = new Map<string, (response: ProviderPermissionResponse) => void>();
78
78
  /** Slash-menu entries by name, tagging why each exists. */
79
79
  #commandKinds = new Map<string, "command" | "skill">();
80
+ /** Current DSH permission preset name, and the ones it can switch to. */
81
+ #permission: string | null = null;
82
+ #permissionPresets: string[] = [];
80
83
  #closed = false;
81
84
 
82
85
  constructor(options: DshSessionOptions) {
@@ -119,6 +122,18 @@ export class DshSession {
119
122
  /** The committed configuration Paseo renders in the composer. */
120
123
  configState(): ProviderConfigState {
121
124
  const settings: ProviderSetting[] = [];
125
+ // Surface DSH's permission presets as a composer control, so switching
126
+ // between sandboxed and full access doesn't require typing /permission.
127
+ if (this.#permissionPresets.length > 0) {
128
+ settings.push({
129
+ type: "select",
130
+ id: "permission",
131
+ label: "Permissions",
132
+ description: "DSH sandbox + approval preset for this session.",
133
+ value: this.#permission,
134
+ options: this.#permissionPresets.map((name) => ({ label: name, value: name })),
135
+ });
136
+ }
122
137
  const thinkingOptions = this.#thinking();
123
138
  return {
124
139
  model: `${this.#route.provider}/${this.#route.model}`,
@@ -173,6 +188,14 @@ export class DshSession {
173
188
  });
174
189
  }
175
190
 
191
+ /** Read the current permission preset and the switchable ones, for the composer. */
192
+ async loadPermission(): Promise<void> {
193
+ const permission = await this.#require().permission();
194
+ if (!permission.available) return;
195
+ this.#permission = permission.current;
196
+ this.#permissionPresets = permission.presets;
197
+ }
198
+
176
199
  /** Accept one prompt and start its turn. */
177
200
  async prompt(prompt: ProviderPrompt): Promise<void> {
178
201
  const process = this.#require();
@@ -307,6 +330,21 @@ export class DshSession {
307
330
  this.#mode = changes.mode === "plan" ? "plan" : "build";
308
331
  await process.setPlan(this.#mode === "plan");
309
332
  }
333
+
334
+ const requestedPermission = changes.settings?.["permission"];
335
+ if (
336
+ typeof requestedPermission === "string" &&
337
+ requestedPermission !== "" &&
338
+ requestedPermission !== this.#permission
339
+ ) {
340
+ // Switch the DSH permission preset through its own `/permission` command,
341
+ // which owns both the sandbox mode and the approval policy.
342
+ const result = await process.runCommand("permission", requestedPermission);
343
+ if (result.kind === "error") {
344
+ throw new Error(result.text ?? `could not set permission preset "${requestedPermission}"`);
345
+ }
346
+ this.#permission = requestedPermission;
347
+ }
310
348
  }
311
349
 
312
350
  /** Answer a pending question card. */