paseo-dsh 0.2.11 → 0.2.13
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/OVERVIEW.md +1 -1
- package/client/react-native.d.ts +10 -0
- package/client/stream-stats.tsx +127 -0
- package/index.client.tsx +6 -0
- package/package.json +5 -2
- package/server/bridge-assets.ts +1 -1
- package/server/dsh-process.ts +24 -0
- package/server/session.ts +284 -116
- package/server/stream-replay.ts +0 -127
package/OVERVIEW.md
CHANGED
|
@@ -4,7 +4,7 @@ Each Paseo agent session starts one `dsh --profile paseo` child process on the d
|
|
|
4
4
|
|
|
5
5
|
DeepSeek Harness must be installed and logged in on the daemon machine, with `dsh` on the daemon's `PATH` or set through the provider command override. The plugin needs Paseo 0.9.2 or newer and Node.js 22 or newer on the daemon, and DSH 0.2.1-rc.2 is the tested line. On first use it provisions `~/.dsh/profiles/paseo`, and it never overwrites an existing profile file, so local edits to `cordis.patch.yml` survive reloads.
|
|
6
6
|
|
|
7
|
-
Composer features are passed to DSH rather than emulated. Attached images are admitted into DSH's attachment store, `/` commands and user-invocable skills come from DSH's registry, and steering, plan mode, question cards and permission prompts render as normal Paseo items. The session menu can switch the agent preset and permission mode when the profile declares them,
|
|
7
|
+
Composer features are passed to DSH rather than emulated. Attached images are admitted into DSH's attachment store, `/` commands and user-invocable skills come from DSH's registry, and steering, plan mode, question cards and permission prompts render as normal Paseo items. The session menu can switch the agent preset and permission mode when the profile declares them, the composer shows the context window and current occupancy that DSH reports, and each answer carries a small line with its first-token latency and output speed. Sessions persist by DSH session id, so a reopened agent resumes its context, and Paseo can list and import existing DSH sessions; an imported session replays its messages into the timeline.
|
|
8
8
|
|
|
9
9
|
Images flow one way. The model receives attached images, but Paseo's transcript renders an image only from an `https://` Markdown URL, so a picture produced on the daemon has to be published to a URL first. Local paths, `file://` URIs and base64 data URLs do not display.
|
|
10
10
|
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Minimal local declarations for the React Native primitives this plugin's
|
|
3
|
+
* client entry uses. Paseo supplies the real runtime modules; installing
|
|
4
|
+
* react-native here would only bloat the typecheck.
|
|
5
|
+
*/
|
|
6
|
+
declare module "react-native" {
|
|
7
|
+
export const View: any;
|
|
8
|
+
export const Text: any;
|
|
9
|
+
export const Pressable: any;
|
|
10
|
+
}
|
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
import type { PluginClientContext, PluginTimelineItemProps } from "@getpaseo/plugin/client";
|
|
2
|
+
import { useState } from "react";
|
|
3
|
+
import { Pressable, Text, View } from "react-native";
|
|
4
|
+
import { z } from "zod";
|
|
5
|
+
|
|
6
|
+
export const streamStatsSchema = z.object({
|
|
7
|
+
firstTokenMs: z.number().optional(),
|
|
8
|
+
tokensPerSecond: z.number().optional(),
|
|
9
|
+
outputTokens: z.number().optional(),
|
|
10
|
+
inputTokens: z.number().optional(),
|
|
11
|
+
cachedInputTokens: z.number().optional(),
|
|
12
|
+
contextUsed: z.number().optional(),
|
|
13
|
+
contextMax: z.number().optional(),
|
|
14
|
+
provider: z.string().optional(),
|
|
15
|
+
model: z.string().optional(),
|
|
16
|
+
thinkingOption: z.string().optional(),
|
|
17
|
+
toolCalls: z.number().optional(),
|
|
18
|
+
toolMs: z.number().optional(),
|
|
19
|
+
turns: z.number().optional(),
|
|
20
|
+
steps: z.number().optional(),
|
|
21
|
+
sessionTokens: z.number().optional(),
|
|
22
|
+
cacheHit: z.number().optional(),
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
type StreamStats = z.infer<typeof streamStatsSchema>;
|
|
26
|
+
|
|
27
|
+
function formatLatency(ms: number): string {
|
|
28
|
+
return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
function formatNumber(value: number): string {
|
|
32
|
+
return String(Math.round(value)).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
function formatCompact(value: number): string {
|
|
36
|
+
if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
|
|
37
|
+
if (value >= 10_000) return `${Math.round(value / 1000)}K`;
|
|
38
|
+
if (value >= 1000) return `${(value / 1000).toFixed(1)}K`;
|
|
39
|
+
return String(Math.round(value));
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
function contextLine(data: StreamStats): string | undefined {
|
|
43
|
+
if (data.contextUsed === undefined || data.contextMax === undefined || data.contextMax <= 0) {
|
|
44
|
+
return undefined;
|
|
45
|
+
}
|
|
46
|
+
const ratio = Math.max(0, Math.min(1, data.contextUsed / data.contextMax));
|
|
47
|
+
const filled = Math.round(ratio * 10);
|
|
48
|
+
const bar = `${"█".repeat(filled)}${"░".repeat(10 - filled)}`;
|
|
49
|
+
return `上下文 ${formatNumber(data.contextUsed)} / ${formatNumber(data.contextMax)} ${bar} ${Math.round(ratio * 100)}%`;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
function tokensLine(data: StreamStats): string | undefined {
|
|
53
|
+
const parts: string[] = [];
|
|
54
|
+
if (data.inputTokens !== undefined) parts.push(`输入 ${formatNumber(data.inputTokens)}`);
|
|
55
|
+
if (data.cachedInputTokens !== undefined) parts.push(`缓存 ${formatNumber(data.cachedInputTokens)}`);
|
|
56
|
+
if (data.outputTokens !== undefined) parts.push(`输出 ${formatNumber(data.outputTokens)}`);
|
|
57
|
+
return parts.length === 0 ? undefined : `Tokens ${parts.join(" · ")}`;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function routeLine(data: StreamStats): string | undefined {
|
|
61
|
+
if (data.provider === undefined && data.model === undefined) return undefined;
|
|
62
|
+
const route = [data.provider, data.model].filter((part) => part !== undefined).join(" / ");
|
|
63
|
+
return `路由 ${route}${data.thinkingOption === undefined ? "" : ` · 思考 ${data.thinkingOption}`}`;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
function toolsLine(data: StreamStats): string | undefined {
|
|
67
|
+
if (data.toolCalls === undefined || data.toolCalls <= 0) return undefined;
|
|
68
|
+
const duration = data.toolMs === undefined ? "" : ` · ${formatLatency(data.toolMs)}`;
|
|
69
|
+
return `工具 ${data.toolCalls} 次${duration}`;
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/** One muted line under an answer; tap to expand the full picture. */
|
|
73
|
+
function StreamStatsRow({ item, theme, layout }: PluginTimelineItemProps<StreamStats>) {
|
|
74
|
+
const [open, setOpen] = useState(false);
|
|
75
|
+
const data = item.data;
|
|
76
|
+
const summary: string[] = [];
|
|
77
|
+
if (data.turns !== undefined && data.steps !== undefined) {
|
|
78
|
+
summary.push(`${data.turns} 轮 ${data.steps} 步`);
|
|
79
|
+
}
|
|
80
|
+
if (data.firstTokenMs !== undefined) summary.push(`首字 ${formatLatency(data.firstTokenMs)}`);
|
|
81
|
+
if (data.tokensPerSecond !== undefined) summary.push(`${Math.round(data.tokensPerSecond)} tok/s`);
|
|
82
|
+
if (data.sessionTokens !== undefined) summary.push(`${formatCompact(data.sessionTokens)} tok`);
|
|
83
|
+
if (data.cacheHit !== undefined) summary.push(`缓存命中 ${Math.round(data.cacheHit * 100)}%`);
|
|
84
|
+
if (summary.length === 0 && data.firstTokenMs !== undefined) {
|
|
85
|
+
summary.push(`首字 ${formatLatency(data.firstTokenMs)}`);
|
|
86
|
+
}
|
|
87
|
+
if (summary.length === 0) return null;
|
|
88
|
+
|
|
89
|
+
const details = [contextLine(data), tokensLine(data), routeLine(data), toolsLine(data)].filter(
|
|
90
|
+
(line): line is string => line !== undefined,
|
|
91
|
+
);
|
|
92
|
+
const fontSize = layout.compact ? 10 : 11;
|
|
93
|
+
const muted = { color: theme.colors.foregroundMuted, fontSize };
|
|
94
|
+
|
|
95
|
+
return (
|
|
96
|
+
<Pressable
|
|
97
|
+
accessibilityRole="button"
|
|
98
|
+
accessibilityLabel={open ? "收起回答统计" : "展开回答统计"}
|
|
99
|
+
onPress={() => setOpen((value) => !value)}
|
|
100
|
+
style={{ alignSelf: "flex-start", marginTop: 0, marginBottom: 0, paddingLeft: 2 }}
|
|
101
|
+
>
|
|
102
|
+
<View style={{ flexDirection: "row", alignItems: "center", gap: 6 }}>
|
|
103
|
+
<Text style={muted}>{summary.join(" · ")}</Text>
|
|
104
|
+
<Text style={muted}>{open ? "▴" : "▾"}</Text>
|
|
105
|
+
</View>
|
|
106
|
+
{open ? (
|
|
107
|
+
<View style={{ marginTop: 2, gap: 1 }}>
|
|
108
|
+
{details.map((line) => (
|
|
109
|
+
<Text key={line} style={muted}>
|
|
110
|
+
{line}
|
|
111
|
+
</Text>
|
|
112
|
+
))}
|
|
113
|
+
</View>
|
|
114
|
+
) : null}
|
|
115
|
+
</Pressable>
|
|
116
|
+
);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
export function contributeStreamStats(client: PluginClientContext) {
|
|
120
|
+
client.addTimelineRenderer({
|
|
121
|
+
kind: "dsh-stream-stats",
|
|
122
|
+
version: 1,
|
|
123
|
+
schema: streamStatsSchema,
|
|
124
|
+
Component: StreamStatsRow,
|
|
125
|
+
});
|
|
126
|
+
return () => {};
|
|
127
|
+
}
|
package/index.client.tsx
ADDED
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "paseo-dsh",
|
|
3
|
-
"version": "0.2.
|
|
3
|
+
"version": "0.2.13",
|
|
4
4
|
"description": "DeepSeek Harness (dsh) as a native Paseo provider: question cards, plan mode, thinking levels, steering, images and a real slash menu. 把 DeepSeek Harness 接成 Paseo 原生 provider。",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"paseo",
|
|
@@ -31,7 +31,9 @@
|
|
|
31
31
|
"icon.svg",
|
|
32
32
|
"README.md",
|
|
33
33
|
"OVERVIEW.md",
|
|
34
|
-
"LICENSE"
|
|
34
|
+
"LICENSE",
|
|
35
|
+
"index.client.tsx",
|
|
36
|
+
"client/"
|
|
35
37
|
],
|
|
36
38
|
"scripts": {
|
|
37
39
|
"generate": "node scripts/generate-bridge-assets.mjs",
|
|
@@ -49,6 +51,7 @@
|
|
|
49
51
|
"devDependencies": {
|
|
50
52
|
"@getpaseo/plugin": "0.9.2",
|
|
51
53
|
"@types/node": "^22.10.2",
|
|
54
|
+
"@types/react": "^19.3.0",
|
|
52
55
|
"typescript": "^5.9.3",
|
|
53
56
|
"zod": "^4.4.3"
|
|
54
57
|
}
|
package/server/bridge-assets.ts
CHANGED
|
@@ -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": "IyBUaGUgUGFzZW8gYnJpZGdlIGJ1bmRsZSBwYXRjaDogYW4gYXV0b21hdGlvbi1vbmx5IHN0ZGlvIHN1cmZhY2Ugb3ZlciBkc2gtYmFzZS4KIwojIFN0ZG91dCBjYXJyaWVzIHByb3RvY29sIGZyYW1lcyBvbmx5LiBUaGlzIHBhdGNoIG11c3QgbmV2ZXIgZW5hYmxlIGEgc3Rkb3V0CiMgbG9nZ2VyLiBJdCBtaXJyb3JzIHRoZSBzaGlwcGVkIHNkay1hcHAvYWNwLWFwcCBidW5kbGVzIHNvIHRoZSBzYW1lIGJhc2UKIyBhZGFwdGVycywgdG9vbHMsIHBlcnNpc3RlbmNlIGFuZCBwb2xpY3kgYXBwbHkuCgotIGlkOiBzeXN0ZW0tcHJvbXB0CiAgY29uZmlnOgogICAgIyBEU0ggMC4yLjEgcmVnaXN0ZXJzIG9ubHkgYHByb3ZpZGVyYCBhbmQgYG1vZGVsYCBhcyBwcm9tcHQgdmFyaWFibGVzOwogICAgIyBge3tjd2R9fWAgaXMgbm8gbG9uZ2VyIG9uZSwgYW5kIHJlZmVyZW5jaW5nIGl0IGZhaWxzIGV2ZXJ5IHR1cm4gd2l0aAogICAgIyBgdW5rbm93biBwcm9tcHQgdmFyaWFibGUgInt7Y3dkfX0iYC4gVGhlIG1vZGVsIGxlYXJucyBpdHMgY3dkIGZyb20gdGhlCiAgICAjIHJ1bnRpbWUgY29udGV4dCAvIHNoZWxsIGluc3RlYWQuCiAgICBwZXJzb25hUHJlZml4OiA+LQogICAgICBZb3UgYXJlIGEgY29kaW5nIGFnZW50IHBvd2VyZWQgYnkgdGhlIHt7bW9kZWx9fSBtb2RlbC4KCi0gaWQ6IHNlc3Npb24tdGl0bGUtbGxtCiAgZGlzYWJsZWQ6IHRydWUKCi0gaW5zZXJ0OgogICAgLSBpZDogcGFzZW8tYnJpZGdlCiAgICAgIG5hbWU6ICdkc2gtcGFzZW8tYnJpZGdlJwogICAgICBpbmplY3Q6IFtjbWRsaW5lQXJncywgYWdlbnRzXQoKLSBpZDogaG1yCiAgZGlzYWJsZWQ6IHRydWUKCiMgVGhlIHF1ZXN0aW9uIHN1cmZhY2UgaXMgb3B0LWluIHBlciBwcmVzZXQgaW4gdGhlIHNoaXBwZWQgYnVuZGxlczsgdGhlIGJyaWRnZQojIG5lZWRzIHRoZSBtb2RlbC1mYWNpbmcgdG9vbCBtb3VudGVkIHNvIHRoZSBtb2RlbCBjYW4gYWN0dWFsbHkgYXNrLgotIGluc2VydDoKICAgIC0gaWQ6IHRvb2wtYXNrLXVzZXIKICAgICAgbmFtZTogJ0BkZWVwc2Vlay1haS9kc2gtdG9vbC1hc2stdXNlcicK",
|
|
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);
}

/** Await a promise, rejecting if it has not settled within `ms`. */
function withTimeout(promise, ms, label) {
  let timer;
  return Promise.race([
    promise,
    new Promise((_, reject) => {
      timer = setTimeout(() => reject(new Error(`timed out ${label}`)), ms);
    }),
  ]).finally(() => clearTimeout(timer));
}

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 -> preset id chosen before its agent existed. A preset is a
     * creation-time choice (DSH locks it once the session's first turn starts),
     * so a pick made while the composer is still being configured is remembered
     * here and applied when the agent is created.
     */
    this.pendingPresets = new Map();

    /** 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) {
    if (typeof params.preset === 'string' && params.preset !== '') {
      await this.setPreset(params.sessionId, params.preset);
    }
    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,
        preset: this.currentPreset(params.sessionId),
      };
    }
    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,
      preset: this.currentPreset(params.sessionId),
    };
  }

  /** The preset a session runs (chosen, else the stored projection, else default). */
  currentPreset(sessionId) {
    const service = this.ctx.get('agentPresets');
    if (service === undefined) return null;
    // A preset chosen or applied in this process is authoritative: the session
    // projection folds the selection event asynchronously, so reading it right
    // after a switch would still show the previous value.
    const chosen = this.pendingPresets.get(sessionId);
    if (chosen !== undefined) return chosen;
    const rec = this.sessions.get(sessionId);
    if (rec !== undefined) {
      try {
        const stored = this.ctx.get('sessionProjections')?.stateOf(rec.handle.agent.session, 'agentPreset');
        if (stored !== undefined) return stored;
      } catch {
        /* projection unavailable; fall through to the default value */
      }
    }
    return service.defaultId ?? null;
  }

  /**
   * Choose a session's agent preset. Before the agent exists the choice is
   * queued; once it does, DSH's `select` applies it — and refuses once the
   * session's first turn has started, which is the lock the composer must honor.
   */
  async setPreset(sessionId, id) {
    const service = this.ctx.get('agentPresets');
    if (service === undefined) throw new Error('agent presets are not mounted in this profile');
    const rec = this.sessions.get(sessionId);
    if (rec === undefined) {
      this.pendingPresets.set(sessionId, id);
      return;
    }
    this.assertLiveAgent(rec, sessionId);
    const applied = await service.select(rec.handle.agent, id);
    this.pendingPresets.set(sessionId, applied ?? id);
  }

  /** Report the configured agent presets and the one this session runs. */
  async presets(params) {
    const service = this.ctx.get('agentPresets');
    if (service === undefined) return { available: false, presets: [], current: null, default: null };
    const list = await service.list();
    return {
      available: true,
      default: service.defaultId ?? null,
      current: this.currentPreset(params.sessionId),
      presets: list.map((preset) => ({
        id: preset.id,
        ...(preset.name === undefined ? {} : { name: preset.name }),
        ...(preset.description === undefined ? {} : { description: preset.description }),
        ...(preset.broken === undefined ? {} : { broken: preset.broken }),
      })),
    };
  }

  /**
   * List the DSH sessions a user can import into Paseo. Reads the persistence
   * backend directly: the session-query corpus is not mounted for listing here
   * (`openAt: never`), and it hangs rather than answering. Titles are
   * best-effort; a missing title never hides an importable session.
   */
  async listSessions(params = {}) {
    const persistence = this.ctx.get('sessionPersistence');
    if (persistence === undefined) return { available: false, sessions: [] };
    let snapshots = [];
    try {
      snapshots = await persistence.list();
    } catch {
      snapshots = [];
    }
    const query = typeof params.query === 'string' && params.query !== '' ? params.query.toLowerCase() : undefined;
    const cwdFilter = typeof params.cwd === 'string' && params.cwd !== '' ? params.cwd : undefined;
    const candidates = [];
    for (const snapshot of snapshots) {
      const id = snapshot?.header?.id === undefined ? undefined : String(snapshot.header.id);
      if (id === undefined || id === '') continue;
      if (cwdFilter !== undefined && snapshot.header.cwd !== cwdFilter) continue;
      if (query !== undefined && !id.toLowerCase().includes(query)) continue;
      candidates.push(snapshot);
    }
    candidates.sort((a, b) => (b.header.createdAt ?? 0) - (a.header.createdAt ?? 0));
    const limit = typeof params.limit === 'number' && params.limit > 0 ? params.limit : 40;
    const picked = candidates.slice(0, limit);
    // A title and a first-message preview make sessions distinguishable; both
    // come from the log prefix, read concurrently so a long list stays quick.
    const summaries = await Promise.all(picked.map((snapshot) => this.#sessionSummary(persistence, snapshot)));
    return { available: true, sessions: summaries };
  }

  /** Read one session's log prefix for its title and first user message. */
  async #sessionSummary(persistence, snapshot) {
    const id = String(snapshot.header.id);
    const row = {
      sessionId: id,
      ...(snapshot.header.cwd === undefined ? {} : { cwd: snapshot.header.cwd }),
      ...(snapshot.header.createdAt === undefined
        ? {}
        : { updatedAt: new Date(snapshot.header.createdAt).toISOString() }),
    };
    let handle;
    try {
      handle = await withTimeout(persistence.open(id, 'read'), 10000, 'opening session summary');
      const result = await withTimeout(handle.read(0, 200), 10000, 'reading session summary');
      let title;
      let preview;
      for (const event of result.events ?? []) {
        if (event.type === 'session/title' && typeof event.data?.title === 'string' && event.data.title !== '') {
          title = event.data.title;
        }
        if (preview === undefined && event.type === 'user/message' && event.data?.source?.kind === 'user') {
          const text = (event.data.content ?? [])
            .filter((block) => block?.type === 'text' && typeof block.text === 'string')
            .map((block) => block.text)
            .join(' ')
            .replace(/\s+/g, ' ')
            .trim();
          if (text !== '') preview = text.slice(0, 120);
        }
      }
      if (typeof title === 'string' && title !== '') row.title = title;
      if (typeof preview === 'string' && preview !== '') row.preview = preview;
    } catch {
      /* A session that will not read is still listed, just without a summary. */
    } finally {
      try {
        await handle?.close();
      } catch {
        /* idempotent close */
      }
    }
    return row;
  }

  /**
   * Read one stored session's raw event log, for replay into a Paseo timeline.
   * Read-only, so it works while a live agent still owns the session.
   */
  async history(params) {
    const persistence = this.ctx.get('sessionPersistence');
    if (persistence === undefined) return { available: false, events: [] };
    let handle;
    try {
      // A session mid-write can stall a read; bound it so a stuck read never
      // stalls the session open that asked for the replay.
      handle = await withTimeout(persistence.open(params.sessionId, 'read'), 15000, 'opening session history');
    } catch {
      // Unknown/unmaterialized session (or a stalled read): an empty history is
      // the honest answer.
      return { available: true, events: [] };
    }
    try {
      const result = await withTimeout(handle.read(), 15000, 'reading session history');
      return {
        available: true,
        events: (result.events ?? []).map((event) => ({
          type: event.type,
          ...(event.seq === undefined ? {} : { seq: event.seq }),
          ...(event.time === undefined ? {} : { time: event.time }),
          data: event.data,
        })),
      };
    } catch {
      return { available: true, events: [] };
    } finally {
      try {
        await handle.close();
      } catch {
        /* handle close is idempotent; a failure here must not mask the read */
      }
    }
  }

  /**
   * 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 session's current context occupancy for the composer's usage
   * readout.
   *
   * The figure is DSH's own replay-aware token meter, never a sum of the log:
   * `contextPressure` pairs the newest provider-reported prompt pressure with
   * the newest known route capacity, which is what DSH's own meter shows.
   * Summing `tokenUsage` would report cumulative billing: it overstates a
   * compacted session and counts cache reads twice. Capacity is resolved for
   * the session's *current* route, so a model switch cannot pair the previous
   * model's window with the new model's pressure. Unknown fields are omitted
   * rather than defaulted; a fabricated occupancy is worse than none.
   */
  async usage(params) {
    // Measuring a resumed session needs its agent, and an agent otherwise only
    // exists after the first prompt. Create it here so a reopened composer shows
    // its stored occupancy before the next turn, like `commands` and
    // `permission` already do.
    const rec = await this.getOrCreateSession(params.sessionId);
    this.assertLiveAgent(rec, params.sessionId);
    const session = rec.handle.agent.session;
    const loggedRoute = session.requestContext?.();
    const selection = this.controls.get(params.sessionId)?.selection?.current;
    const route = selection ?? loggedRoute;
    const sameRoute = route?.provider === loggedRoute?.provider && route?.model === loggedRoute?.model;
    const pressure = this.#contextPressure(session);
    // A prior model's pressure/limit must not be presented as a measurement of
    // the newly selected model. Reprice via DSH when the route changed.
    const usedTokens = sameRoute
      ? pressure?.projectedTokens ?? pressure?.pressureTokens ?? this.#measuredTokens(session)
      : this.#measuredTokens(session, route);
    const contextWindow = await this.#routeContextWindow(route);
    return {
      available: true,
      ...(Number.isSafeInteger(usedTokens) && usedTokens >= 0 ? { usedTokens } : {}),
      ...(Number.isSafeInteger(contextWindow) && contextWindow > 0 ? { contextWindow } : {}),
    };
  }

  /** DSH's `contextPressure` projection: newest pressure sample and route capacity. */
  #contextPressure(session) {
    try {
      return this.ctx.get('sessionProjections')?.snapshot(session, ['contextPressure'])?.values
        ?.contextPressure;
    } catch {
      return undefined;
    }
  }

  /** Current request pressure straight from the token meter, before any sample exists. */
  #measuredTokens(session, route) {
    try {
      const header = session.requestHeader?.();
      const requestHeader = route?.provider !== undefined && route?.model !== undefined
        ? {
          ...(header?.tools === undefined ? {} : { tools: header.tools }),
          config: {
            ...(header?.config ?? {}),
            provider: route.provider,
            model: route.model,
          },
        }
        : undefined;
      const measured = this.ctx.get('tokenMeter')?.measure(session, requestHeader);
      return typeof measured?.totalTokens === 'number' ? measured.totalTokens : undefined;
    } catch {
      return undefined;
    }
  }

  /** The live route's resolved context capacity, preferring the current selection. */
  async #routeContextWindow(route) {
    if (route?.provider === undefined || route?.model === undefined) return undefined;
    try {
      const info = await this.ctx.get('llm')?.resolveModelInfo(route.provider, route.model);
      const contextWindow = info?.context?.contextWindow;
      return typeof contextWindow === 'number' && contextWindow > 0 ? contextWindow : undefined;
    } catch {
      return undefined;
    }
  }

  /** 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 };
    }
    // DSH 0.2.1 materializes a provider's model catalog asynchronously after a
    // route resolves. The Paseo catalog probe deliberately skips `initialize`
    // (it must not pin a route), so warm the profile's default and then poll
    // briefly while the adapters finish registering their models.
    const warm = this.profileDefault();
    if (warm !== undefined) {
      try {
        await llm.resolveCallConfig({ provider: warm.provider, model: warm.model });
      } catch {
        /* best-effort: an unresolvable default may still leave other routes */
      }
    }

    const collect = async () => {
      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 yet */
        }
      }
      return { providers, models };
    };

    let { providers, models } = await collect();
    const deadline = Date.now() + 3000;
    while (models.length === 0 && Date.now() < deadline) {
      await new Promise((resolve) => setTimeout(resolve, 200));
      ({ providers, models } = await collect());
    }

    // 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/usage':
        return this.usage(params);
      case 'paseo/presets':
        return this.presets(params);
      case 'paseo/sessions':
        return this.listSessions(params);
      case 'paseo/history':
        return this.history(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 installSelection = (agentCtx) => {
      control.dispose = installModelSelection(agentCtx, control.selection);
    };

    // A session that runs under an agent preset mounts it during setup, exactly
    // like api-session-controller's composeAgent. Without a preset registry in
    // the profile this is skipped and the session composes at the host plane as
    // before, so preset support stays opt-in.
    const presets = this.ctx.get('agentPresets');
    let agentPreset;
    let setup = installSelection;
    if (presets !== undefined) {
      const resolvedId = (await presets.resolve(this.pendingPresets.get(sessionId))).id;
      agentPreset = resolvedId;
      setup = async (agentCtx, agent) => {
        installSelection(agentCtx);
        await presets.mount(agentCtx, resolvedId);
      };
    }

    const agentOptions = {
      ...initial,
      ...(this.maxTokens === undefined ? {} : { maxTokens: this.maxTokens }),
    };
    const meta = { cwd: this.cwd, ...(agentPreset === undefined ? {} : { agentPreset }) };
    let handle;
    try {
      handle = await this.ctx.agents.create({
        sessionId: brandString(sessionId),
        meta,
        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;
      // A resumed session keeps the preset it was created with; re-mount the same
      // one so its projected composition stays consistent.
      let resumeSetup = installSelection;
      if (presets !== undefined) {
        const session = this.ctx.get('sessions')?.get(brandString(sessionId));
        let storedPreset;
        try {
          storedPreset = session === undefined ? undefined : this.ctx.get('sessionProjections')?.stateOf(session, 'agentPreset');
        } catch {
          storedPreset = undefined;
        }
        const resolvedId = (await presets.resolve(storedPreset ?? this.pendingPresets.get(sessionId))).id;
        resumeSetup = async (agentCtx) => {
          installSelection(agentCtx);
          await presets.mount(agentCtx, resolvedId);
        };
      }
      handle = await this.ctx.agents.resume({
        resumeSessionId: brandString(sessionId),
        agentOptions,
        setup: resumeSetup,
      });
    }
    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);
}

/** Await a promise, rejecting if it has not settled within `ms`. */
function withTimeout(promise, ms, label) {
  let timer;
  return Promise.race([
    promise,
    new Promise((_, reject) => {
      timer = setTimeout(() => reject(new Error(`timed out ${label}`)), ms);
    }),
  ]).finally(() => clearTimeout(timer));
}

/**
 * Reduce one DSH live assistant-stream frame to the part Paseo can render.
 *
 * Only visible text deltas are forwarded. Reasoning and tool-call deltas keep
 * their existing end-of-step presentation, so forwarding them would duplicate
 * work the durable timeline already does. Start and end frames still travel so
 * the plugin can reset its accumulator on a retry or abandonment.
 */
function liveAssistantFrame(frame) {
  if (frame.type === 'chunk') {
    // Text and reasoning both become live rows. A forwarded chunk names which
    // row it belongs to; tool-call deltas keep their end-of-step presentation.
    const kind = frame.chunk?.type === 'text-delta'
      ? 'text'
      : frame.chunk?.type === 'reasoning-delta'
        ? 'reasoning'
        : undefined;
    if (kind === undefined) return undefined;
    return {
      type: 'chunk',
      attemptId: String(frame.attemptId),
      revision: frame.revision,
      index: frame.index,
      time: frame.time,
      kind,
      text: frame.chunk.text,
    };
  }
  if (frame.type === 'start') {
    return {
      type: 'start',
      attemptId: String(frame.attemptId),
      revision: frame.revision,
      turn: frame.turn,
      step: frame.step,
    };
  }
  if (frame.type === 'end') {
    return {
      type: 'end',
      attemptId: String(frame.attemptId),
      revision: frame.revision,
      outcome: frame.outcome,
    };
  }
  return undefined;
}

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 -> preset id chosen before its agent existed. A preset is a
     * creation-time choice (DSH locks it once the session's first turn starts),
     * so a pick made while the composer is still being configured is remembered
     * here and applied when the agent is created.
     */
    this.pendingPresets = new Map();

    /** 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 });
      }),
    );
    // Live token deltas. The durable log only carries one complete message per
    // step, so without this the answer can only be replayed after the model has
    // finished writing it. Only sessions this bridge drives are forwarded.
    this.disposers.push(
      ctx.on('agent/assistant-stream', ({ agent, frame }) => {
        const sessionId = String(agent.session.id);
        if (!this.sessions.has(sessionId)) return;
        const live = liveAssistantFrame(frame);
        if (live !== undefined) this.transport.notify('assistant.stream', { sessionId, frame: live });
      }),
    );
  }

  /** 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) {
    if (typeof params.preset === 'string' && params.preset !== '') {
      await this.setPreset(params.sessionId, params.preset);
    }
    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,
        preset: this.currentPreset(params.sessionId),
      };
    }
    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,
      preset: this.currentPreset(params.sessionId),
    };
  }

  /** The preset a session runs (chosen, else the stored projection, else default). */
  currentPreset(sessionId) {
    const service = this.ctx.get('agentPresets');
    if (service === undefined) return null;
    // A preset chosen or applied in this process is authoritative: the session
    // projection folds the selection event asynchronously, so reading it right
    // after a switch would still show the previous value.
    const chosen = this.pendingPresets.get(sessionId);
    if (chosen !== undefined) return chosen;
    const rec = this.sessions.get(sessionId);
    if (rec !== undefined) {
      try {
        const stored = this.ctx.get('sessionProjections')?.stateOf(rec.handle.agent.session, 'agentPreset');
        if (stored !== undefined) return stored;
      } catch {
        /* projection unavailable; fall through to the default value */
      }
    }
    return service.defaultId ?? null;
  }

  /**
   * Choose a session's agent preset. Before the agent exists the choice is
   * queued; once it does, DSH's `select` applies it — and refuses once the
   * session's first turn has started, which is the lock the composer must honor.
   */
  async setPreset(sessionId, id) {
    const service = this.ctx.get('agentPresets');
    if (service === undefined) throw new Error('agent presets are not mounted in this profile');
    const rec = this.sessions.get(sessionId);
    if (rec === undefined) {
      this.pendingPresets.set(sessionId, id);
      return;
    }
    this.assertLiveAgent(rec, sessionId);
    const applied = await service.select(rec.handle.agent, id);
    this.pendingPresets.set(sessionId, applied ?? id);
  }

  /** Report the configured agent presets and the one this session runs. */
  async presets(params) {
    const service = this.ctx.get('agentPresets');
    if (service === undefined) return { available: false, presets: [], current: null, default: null };
    const list = await service.list();
    return {
      available: true,
      default: service.defaultId ?? null,
      current: this.currentPreset(params.sessionId),
      presets: list.map((preset) => ({
        id: preset.id,
        ...(preset.name === undefined ? {} : { name: preset.name }),
        ...(preset.description === undefined ? {} : { description: preset.description }),
        ...(preset.broken === undefined ? {} : { broken: preset.broken }),
      })),
    };
  }

  /**
   * List the DSH sessions a user can import into Paseo. Reads the persistence
   * backend directly: the session-query corpus is not mounted for listing here
   * (`openAt: never`), and it hangs rather than answering. Titles are
   * best-effort; a missing title never hides an importable session.
   */
  async listSessions(params = {}) {
    const persistence = this.ctx.get('sessionPersistence');
    if (persistence === undefined) return { available: false, sessions: [] };
    let snapshots = [];
    try {
      snapshots = await persistence.list();
    } catch {
      snapshots = [];
    }
    const query = typeof params.query === 'string' && params.query !== '' ? params.query.toLowerCase() : undefined;
    const cwdFilter = typeof params.cwd === 'string' && params.cwd !== '' ? params.cwd : undefined;
    const candidates = [];
    for (const snapshot of snapshots) {
      const id = snapshot?.header?.id === undefined ? undefined : String(snapshot.header.id);
      if (id === undefined || id === '') continue;
      if (cwdFilter !== undefined && snapshot.header.cwd !== cwdFilter) continue;
      if (query !== undefined && !id.toLowerCase().includes(query)) continue;
      candidates.push(snapshot);
    }
    candidates.sort((a, b) => (b.header.createdAt ?? 0) - (a.header.createdAt ?? 0));
    const limit = typeof params.limit === 'number' && params.limit > 0 ? params.limit : 40;
    const picked = candidates.slice(0, limit);
    // A title and a first-message preview make sessions distinguishable; both
    // come from the log prefix, read concurrently so a long list stays quick.
    const summaries = await Promise.all(picked.map((snapshot) => this.#sessionSummary(persistence, snapshot)));
    return { available: true, sessions: summaries };
  }

  /** Read one session's log prefix for its title and first user message. */
  async #sessionSummary(persistence, snapshot) {
    const id = String(snapshot.header.id);
    const row = {
      sessionId: id,
      ...(snapshot.header.cwd === undefined ? {} : { cwd: snapshot.header.cwd }),
      ...(snapshot.header.createdAt === undefined
        ? {}
        : { updatedAt: new Date(snapshot.header.createdAt).toISOString() }),
    };
    let handle;
    try {
      handle = await withTimeout(persistence.open(id, 'read'), 10000, 'opening session summary');
      const result = await withTimeout(handle.read(0, 200), 10000, 'reading session summary');
      let title;
      let preview;
      for (const event of result.events ?? []) {
        if (event.type === 'session/title' && typeof event.data?.title === 'string' && event.data.title !== '') {
          title = event.data.title;
        }
        if (preview === undefined && event.type === 'user/message' && event.data?.source?.kind === 'user') {
          const text = (event.data.content ?? [])
            .filter((block) => block?.type === 'text' && typeof block.text === 'string')
            .map((block) => block.text)
            .join(' ')
            .replace(/\s+/g, ' ')
            .trim();
          if (text !== '') preview = text.slice(0, 120);
        }
      }
      if (typeof title === 'string' && title !== '') row.title = title;
      if (typeof preview === 'string' && preview !== '') row.preview = preview;
    } catch {
      /* A session that will not read is still listed, just without a summary. */
    } finally {
      try {
        await handle?.close();
      } catch {
        /* idempotent close */
      }
    }
    return row;
  }

  /**
   * Read one stored session's raw event log, for replay into a Paseo timeline.
   * Read-only, so it works while a live agent still owns the session.
   */
  async history(params) {
    const persistence = this.ctx.get('sessionPersistence');
    if (persistence === undefined) return { available: false, events: [] };
    let handle;
    try {
      // A session mid-write can stall a read; bound it so a stuck read never
      // stalls the session open that asked for the replay.
      handle = await withTimeout(persistence.open(params.sessionId, 'read'), 15000, 'opening session history');
    } catch {
      // Unknown/unmaterialized session (or a stalled read): an empty history is
      // the honest answer.
      return { available: true, events: [] };
    }
    try {
      const result = await withTimeout(handle.read(), 15000, 'reading session history');
      return {
        available: true,
        events: (result.events ?? []).map((event) => ({
          type: event.type,
          ...(event.seq === undefined ? {} : { seq: event.seq }),
          ...(event.time === undefined ? {} : { time: event.time }),
          data: event.data,
        })),
      };
    } catch {
      return { available: true, events: [] };
    } finally {
      try {
        await handle.close();
      } catch {
        /* handle close is idempotent; a failure here must not mask the read */
      }
    }
  }

  /**
   * 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 session's current context occupancy for the composer's usage
   * readout.
   *
   * The figure is DSH's own replay-aware token meter, never a sum of the log:
   * `contextPressure` pairs the newest provider-reported prompt pressure with
   * the newest known route capacity, which is what DSH's own meter shows.
   * Summing `tokenUsage` would report cumulative billing: it overstates a
   * compacted session and counts cache reads twice. Capacity is resolved for
   * the session's *current* route, so a model switch cannot pair the previous
   * model's window with the new model's pressure. Unknown fields are omitted
   * rather than defaulted; a fabricated occupancy is worse than none.
   */
  async usage(params) {
    // Measuring a resumed session needs its agent, and an agent otherwise only
    // exists after the first prompt. Create it here so a reopened composer shows
    // its stored occupancy before the next turn, like `commands` and
    // `permission` already do.
    const rec = await this.getOrCreateSession(params.sessionId);
    this.assertLiveAgent(rec, params.sessionId);
    const session = rec.handle.agent.session;
    const loggedRoute = session.requestContext?.();
    const selection = this.controls.get(params.sessionId)?.selection?.current;
    const route = selection ?? loggedRoute;
    const sameRoute = route?.provider === loggedRoute?.provider && route?.model === loggedRoute?.model;
    const pressure = this.#contextPressure(session);
    // A prior model's pressure/limit must not be presented as a measurement of
    // the newly selected model. Reprice via DSH when the route changed.
    const usedTokens = sameRoute
      ? pressure?.projectedTokens ?? pressure?.pressureTokens ?? this.#measuredTokens(session)
      : this.#measuredTokens(session, route);
    const contextWindow = await this.#routeContextWindow(route);
    return {
      available: true,
      ...(Number.isSafeInteger(usedTokens) && usedTokens >= 0 ? { usedTokens } : {}),
      ...(Number.isSafeInteger(contextWindow) && contextWindow > 0 ? { contextWindow } : {}),
    };
  }

  /** DSH's `contextPressure` projection: newest pressure sample and route capacity. */
  #contextPressure(session) {
    try {
      return this.ctx.get('sessionProjections')?.snapshot(session, ['contextPressure'])?.values
        ?.contextPressure;
    } catch {
      return undefined;
    }
  }

  /** Current request pressure straight from the token meter, before any sample exists. */
  #measuredTokens(session, route) {
    try {
      const header = session.requestHeader?.();
      const requestHeader = route?.provider !== undefined && route?.model !== undefined
        ? {
          ...(header?.tools === undefined ? {} : { tools: header.tools }),
          config: {
            ...(header?.config ?? {}),
            provider: route.provider,
            model: route.model,
          },
        }
        : undefined;
      const measured = this.ctx.get('tokenMeter')?.measure(session, requestHeader);
      return typeof measured?.totalTokens === 'number' ? measured.totalTokens : undefined;
    } catch {
      return undefined;
    }
  }

  /** The live route's resolved context capacity, preferring the current selection. */
  async #routeContextWindow(route) {
    if (route?.provider === undefined || route?.model === undefined) return undefined;
    try {
      const info = await this.ctx.get('llm')?.resolveModelInfo(route.provider, route.model);
      const contextWindow = info?.context?.contextWindow;
      return typeof contextWindow === 'number' && contextWindow > 0 ? contextWindow : undefined;
    } catch {
      return undefined;
    }
  }

  /** 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 };
    }
    // DSH 0.2.1 materializes a provider's model catalog asynchronously after a
    // route resolves. The Paseo catalog probe deliberately skips `initialize`
    // (it must not pin a route), so warm the profile's default and then poll
    // briefly while the adapters finish registering their models.
    const warm = this.profileDefault();
    if (warm !== undefined) {
      try {
        await llm.resolveCallConfig({ provider: warm.provider, model: warm.model });
      } catch {
        /* best-effort: an unresolvable default may still leave other routes */
      }
    }

    const collect = async () => {
      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 yet */
        }
      }
      return { providers, models };
    };

    let { providers, models } = await collect();
    const deadline = Date.now() + 3000;
    while (models.length === 0 && Date.now() < deadline) {
      await new Promise((resolve) => setTimeout(resolve, 200));
      ({ providers, models } = await collect());
    }

    // 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/usage':
        return this.usage(params);
      case 'paseo/presets':
        return this.presets(params);
      case 'paseo/sessions':
        return this.listSessions(params);
      case 'paseo/history':
        return this.history(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 installSelection = (agentCtx) => {
      control.dispose = installModelSelection(agentCtx, control.selection);
    };

    // A session that runs under an agent preset mounts it during setup, exactly
    // like api-session-controller's composeAgent. Without a preset registry in
    // the profile this is skipped and the session composes at the host plane as
    // before, so preset support stays opt-in.
    const presets = this.ctx.get('agentPresets');
    let agentPreset;
    let setup = installSelection;
    if (presets !== undefined) {
      const resolvedId = (await presets.resolve(this.pendingPresets.get(sessionId))).id;
      agentPreset = resolvedId;
      setup = async (agentCtx, agent) => {
        installSelection(agentCtx);
        await presets.mount(agentCtx, resolvedId);
      };
    }

    const agentOptions = {
      ...initial,
      ...(this.maxTokens === undefined ? {} : { maxTokens: this.maxTokens }),
    };
    const meta = { cwd: this.cwd, ...(agentPreset === undefined ? {} : { agentPreset }) };
    let handle;
    try {
      handle = await this.ctx.agents.create({
        sessionId: brandString(sessionId),
        meta,
        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;
      // A resumed session keeps the preset it was created with; re-mount the same
      // one so its projected composition stays consistent.
      let resumeSetup = installSelection;
      if (presets !== undefined) {
        const session = this.ctx.get('sessions')?.get(brandString(sessionId));
        let storedPreset;
        try {
          storedPreset = session === undefined ? undefined : this.ctx.get('sessionProjections')?.stateOf(session, 'agentPreset');
        } catch {
          storedPreset = undefined;
        }
        const resolvedId = (await presets.resolve(storedPreset ?? this.pendingPresets.get(sessionId))).id;
        resumeSetup = async (agentCtx) => {
          installSelection(agentCtx);
          await presets.mount(agentCtx, resolvedId);
        };
      }
      handle = await this.ctx.agents.resume({
        resumeSessionId: brandString(sessionId),
        agentOptions,
        setup: resumeSetup,
      });
    }
    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
|
};
|
package/server/dsh-process.ts
CHANGED
|
@@ -93,8 +93,27 @@ export interface DshCommand {
|
|
|
93
93
|
kind: "command" | "skill";
|
|
94
94
|
}
|
|
95
95
|
|
|
96
|
+
/** One live assistant-stream frame, already reduced by the bridge. */
|
|
97
|
+
export interface DshAssistantFrame {
|
|
98
|
+
type: "start" | "chunk" | "end";
|
|
99
|
+
attemptId: string;
|
|
100
|
+
revision: number;
|
|
101
|
+
/** Present on `start`. */
|
|
102
|
+
turn?: number;
|
|
103
|
+
step?: number;
|
|
104
|
+
/** Present on a `chunk`: DSH's epoch-ms publication time. */
|
|
105
|
+
time?: number;
|
|
106
|
+
/** Present on a `chunk`: which row the delta belongs to. */
|
|
107
|
+
kind?: "text" | "reasoning";
|
|
108
|
+
/** Present on a `chunk`. */
|
|
109
|
+
text?: string;
|
|
110
|
+
/** Present on `end`. */
|
|
111
|
+
outcome?: { kind: "committed" | "abandoned" };
|
|
112
|
+
}
|
|
113
|
+
|
|
96
114
|
export interface DshProcessHandlers {
|
|
97
115
|
onEvent(payload: DshSessionEvent): void;
|
|
116
|
+
onAssistantStream?(frame: DshAssistantFrame): void;
|
|
98
117
|
onStatus(status: string): void;
|
|
99
118
|
onQuestion(request: DshQuestionRequest): Promise<DshAnswer>;
|
|
100
119
|
onLog(line: string): void;
|
|
@@ -435,6 +454,11 @@ export class DshProcess {
|
|
|
435
454
|
this.#options.onStatus(params?.status ?? "unknown");
|
|
436
455
|
return;
|
|
437
456
|
}
|
|
457
|
+
if (method === "assistant.stream") {
|
|
458
|
+
const params = frame.params as { frame?: DshAssistantFrame } | undefined;
|
|
459
|
+
if (params?.frame !== undefined) this.#options.onAssistantStream?.(params.frame);
|
|
460
|
+
return;
|
|
461
|
+
}
|
|
438
462
|
if (method !== undefined) {
|
|
439
463
|
if (id !== undefined) {
|
|
440
464
|
this.#send({ jsonrpc: "2.0", id, error: { code: -32601, message: `unsupported ${method}` } });
|
package/server/session.ts
CHANGED
|
@@ -28,15 +28,12 @@ import {
|
|
|
28
28
|
type DshAnswer,
|
|
29
29
|
type DshQuestion,
|
|
30
30
|
type DshQuestionRequest,
|
|
31
|
+
type DshAssistantFrame,
|
|
31
32
|
type DshRoute,
|
|
32
33
|
type DshUsage,
|
|
33
34
|
} from "./dsh-process";
|
|
34
|
-
import { buildStreamFrames, type StreamFrame } from "./stream-replay";
|
|
35
35
|
import { TimelineBuilder } from "./timeline";
|
|
36
36
|
|
|
37
|
-
/** The timeline row a replayed model message updates in place. */
|
|
38
|
-
type AssistantItem = Extract<ProviderTimelineItem, { type: "assistant_message" }>;
|
|
39
|
-
|
|
40
37
|
/** Modes Paseo offers in the composer. `plan` drives DSH's plan-mode service. */
|
|
41
38
|
export const MODES: ProviderMode[] = [
|
|
42
39
|
{ id: "build", label: "Build", description: "Investigate and implement changes directly." },
|
|
@@ -105,19 +102,43 @@ export class DshSession {
|
|
|
105
102
|
#thinkingOption: string | undefined;
|
|
106
103
|
#turnId: string | null = null;
|
|
107
104
|
#replaySeq = 0;
|
|
108
|
-
/**
|
|
109
|
-
|
|
105
|
+
/**
|
|
106
|
+
* Live text accumulated from DSH's transient assistant-stream frames. The
|
|
107
|
+
* durable log only carries one complete message per step, so this is what
|
|
108
|
+
* makes the answer appear while the model is still writing it.
|
|
109
|
+
*/
|
|
110
|
+
/** Session totals shown in the collapsed stats line. */
|
|
111
|
+
#totals = { input: 0, cache: 0, cacheWrite: 0, output: 0 };
|
|
112
|
+
#seenTurns = new Set<number>();
|
|
113
|
+
#seenSteps = new Set<string>();
|
|
114
|
+
/** Tool call start times and the current turn's tool total. */
|
|
115
|
+
#toolStarts = new Map<string, number>();
|
|
116
|
+
#turnTool = { count: 0, ms: 0 };
|
|
117
|
+
/** Most recent stats row, so context and tool totals can update it in place. */
|
|
118
|
+
#lastStats: { id: string; data: Record<string, unknown> } | undefined;
|
|
119
|
+
/** Per-step timing for the streamed-stats row. */
|
|
120
|
+
#streamStats:
|
|
110
121
|
| {
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
122
|
+
turn: number;
|
|
123
|
+
step: number;
|
|
124
|
+
startedAt: number;
|
|
125
|
+
firstTokenAt?: number;
|
|
126
|
+
lastTokenAt?: number;
|
|
127
|
+
endedAt?: number;
|
|
128
|
+
}
|
|
129
|
+
| undefined;
|
|
130
|
+
#live:
|
|
131
|
+
| {
|
|
132
|
+
attemptId: string;
|
|
133
|
+
turn: number;
|
|
134
|
+
step: number;
|
|
135
|
+
text: string;
|
|
136
|
+
emitted: string;
|
|
137
|
+
reasoning: string;
|
|
138
|
+
emittedReasoning: string;
|
|
139
|
+
timer: ReturnType<typeof setTimeout> | undefined;
|
|
116
140
|
}
|
|
117
141
|
| undefined;
|
|
118
|
-
#replayTimer: ReturnType<typeof setTimeout> | undefined;
|
|
119
|
-
/** A completed turn that must wait for the text reveal before Paseo sees it. */
|
|
120
|
-
#pendingIdle = false;
|
|
121
142
|
#pendingPermissions = new Map<string, (response: ProviderPermissionResponse) => void>();
|
|
122
143
|
/** Slash-menu entries by name, tagging why each exists. */
|
|
123
144
|
#commandKinds = new Map<string, "command" | "skill">();
|
|
@@ -155,6 +176,7 @@ export class DshSession {
|
|
|
155
176
|
sessionId: this.#dshSessionId,
|
|
156
177
|
env: this.#options.env,
|
|
157
178
|
onEvent: (payload) => this.#onSessionEvent(payload),
|
|
179
|
+
onAssistantStream: (frame) => this.#onAssistantStream(frame),
|
|
158
180
|
onStatus: (status) => this.#onStatus(status),
|
|
159
181
|
onQuestion: (request) => this.#onQuestion(request),
|
|
160
182
|
onLog: (line) => this.#options.log(line),
|
|
@@ -162,9 +184,9 @@ export class DshSession {
|
|
|
162
184
|
if (this.#closed) return;
|
|
163
185
|
this.#closed = true;
|
|
164
186
|
clearTimeout(this.#usageRefreshTimer);
|
|
165
|
-
// A dead runtime must not keep
|
|
166
|
-
//
|
|
167
|
-
this.#
|
|
187
|
+
// A dead runtime must not keep writing more of the answer; the failure
|
|
188
|
+
// below is the last word on this session.
|
|
189
|
+
this.#clearLive();
|
|
168
190
|
this.#options.emit({
|
|
169
191
|
type: "session.runtime_failed",
|
|
170
192
|
sessionId: this.id,
|
|
@@ -330,6 +352,11 @@ export class DshSession {
|
|
|
330
352
|
// A complete context snapshot: absence clears a formerly known value instead
|
|
331
353
|
// of keeping another model's capacity or a stale numerator.
|
|
332
354
|
this.#emitUsage(patch, true);
|
|
355
|
+
const row = this.#lastStats;
|
|
356
|
+
if (row !== undefined) {
|
|
357
|
+
row.data = { ...row.data, ...this.#contextFields() };
|
|
358
|
+
this.#emitStatsRow();
|
|
359
|
+
}
|
|
333
360
|
}
|
|
334
361
|
|
|
335
362
|
/** Coalesce step/tool updates so occupancy is not measured per streamed token. */
|
|
@@ -360,6 +387,8 @@ export class DshSession {
|
|
|
360
387
|
for (const event of events) {
|
|
361
388
|
const data = isRecord(event.data) ? event.data : {};
|
|
362
389
|
const seq = typeof event.seq === "number" ? event.seq : this.#replaySeq++;
|
|
390
|
+
// Seed the session totals so a resumed agent keeps its 轮/步/token line.
|
|
391
|
+
if (event.type === "assistant/message") this.#accumulateTotals(data);
|
|
363
392
|
if (event.type === "user/message") {
|
|
364
393
|
const source = isRecord(data.source) ? data.source : {};
|
|
365
394
|
if (source.kind !== "user") continue;
|
|
@@ -380,9 +409,10 @@ export class DshSession {
|
|
|
380
409
|
|
|
381
410
|
/** Accept one prompt and start its turn. */
|
|
382
411
|
async prompt(prompt: ProviderPrompt): Promise<void> {
|
|
383
|
-
// A user turn must not start
|
|
384
|
-
//
|
|
385
|
-
this.#
|
|
412
|
+
// A user turn must not start with the previous answer's live buffer still
|
|
413
|
+
// attached; flush it so the two turns cannot interleave.
|
|
414
|
+
this.#flushLive();
|
|
415
|
+
this.#clearLive();
|
|
386
416
|
const process = this.#require();
|
|
387
417
|
|
|
388
418
|
// A slash-menu pick arrives as a command, not a message. DSH commands and
|
|
@@ -579,12 +609,8 @@ export class DshSession {
|
|
|
579
609
|
* conversation stays continuable — killing the process stranded it instead.
|
|
580
610
|
*/
|
|
581
611
|
async interrupt(): Promise<void> {
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
// cancelling there would either error or startle the runtime for nothing.
|
|
585
|
-
const finished = this.#streamReplay !== undefined && this.#pendingIdle;
|
|
586
|
-
this.#finishStreamReplay();
|
|
587
|
-
if (finished) return;
|
|
612
|
+
this.#flushLive();
|
|
613
|
+
this.#clearLive();
|
|
588
614
|
await this.#require().cancel();
|
|
589
615
|
}
|
|
590
616
|
|
|
@@ -593,7 +619,8 @@ export class DshSession {
|
|
|
593
619
|
if (this.#closed) return;
|
|
594
620
|
this.#closed = true;
|
|
595
621
|
clearTimeout(this.#usageRefreshTimer);
|
|
596
|
-
this.#
|
|
622
|
+
this.#flushLive();
|
|
623
|
+
this.#clearLive();
|
|
597
624
|
await this.#process?.shutdown();
|
|
598
625
|
}
|
|
599
626
|
|
|
@@ -606,20 +633,17 @@ export class DshSession {
|
|
|
606
633
|
|
|
607
634
|
#onStatus(status: string): void {
|
|
608
635
|
if (status === "running") {
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
636
|
+
if (this.#turnId === null) {
|
|
637
|
+
this.#toolStarts.clear();
|
|
638
|
+
this.#turnTool = { count: 0, ms: 0 };
|
|
639
|
+
// A later usage refresh must not rewrite the previous turn's row.
|
|
640
|
+
this.#lastStats = undefined;
|
|
641
|
+
}
|
|
612
642
|
const turnId = this.#turnId ?? `turn:${Date.now()}`;
|
|
613
643
|
this.#turnId = turnId;
|
|
614
644
|
this.#options.emit({ type: "session.turn", sessionId: this.id, turnId, state: "started" });
|
|
615
645
|
return;
|
|
616
646
|
}
|
|
617
|
-
if (this.#streamReplay !== undefined) {
|
|
618
|
-
// Hold the completed state until the reveal lands. Paseo closes the row
|
|
619
|
-
// on turn completion, which would freeze the text mid-sentence.
|
|
620
|
-
this.#pendingIdle = true;
|
|
621
|
-
return;
|
|
622
|
-
}
|
|
623
647
|
this.#completeTurn();
|
|
624
648
|
}
|
|
625
649
|
|
|
@@ -671,102 +695,246 @@ export class DshSession {
|
|
|
671
695
|
// Refresh here so the readout drops without waiting for a turn.
|
|
672
696
|
if (event.type === "compaction/end") void this.refreshUsage();
|
|
673
697
|
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
// closing items for after the replay so they cannot close the row early.
|
|
680
|
-
this.#streamReplay.deferred.push(...items);
|
|
681
|
-
return;
|
|
682
|
-
}
|
|
683
|
-
// Only an event that follows the text in the transcript may cut the
|
|
684
|
-
// reveal short. Bookkeeping events such as `step/end` arrive right after
|
|
685
|
-
// the message and must not end it.
|
|
686
|
-
if (event.type === "assistant/message" || event.type === "tool/call" || event.type === "tool/result") {
|
|
687
|
-
this.#finishStreamReplay();
|
|
688
|
-
}
|
|
689
|
-
}
|
|
690
|
-
|
|
691
|
-
// DSH sends one complete message per step and carries the pacing of every
|
|
692
|
-
// text chunk with it. Reveal it progressively so Paseo behaves like the DSH
|
|
693
|
-
// client instead of dropping the whole answer in at once.
|
|
698
|
+
if (event.type === "tool/call" || event.type === "tool/result") this.#trackToolEvent(event);
|
|
699
|
+
// The live text already reached the same row; the durable message is the
|
|
700
|
+
// authoritative final snapshot and simply replaces it.
|
|
701
|
+
if (event.type === "assistant/message") this.#flushLive();
|
|
702
|
+
for (const item of this.#timeline.consume(event)) this.#emitItem(item);
|
|
694
703
|
if (event.type === "assistant/message") {
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
if (assistant !== undefined && frames !== undefined) {
|
|
698
|
-
for (const item of items) {
|
|
699
|
-
if (item !== assistant) this.#emitItem(item);
|
|
700
|
-
}
|
|
701
|
-
this.#startStreamReplay(assistant, frames);
|
|
702
|
-
return;
|
|
703
|
-
}
|
|
704
|
+
this.#accumulateTotals(isRecord(event.data) ? event.data : {});
|
|
705
|
+
this.#emitStreamStats(isRecord(event.data) ? event.data : {});
|
|
704
706
|
}
|
|
707
|
+
if (event.type === "turn/end" && this.#lastStats !== undefined) {
|
|
708
|
+
this.#lastStats.data = {
|
|
709
|
+
...this.#lastStats.data,
|
|
710
|
+
toolCalls: this.#turnTool.count,
|
|
711
|
+
...(this.#turnTool.ms > 0 ? { toolMs: this.#turnTool.ms } : {}),
|
|
712
|
+
};
|
|
713
|
+
this.#emitStatsRow();
|
|
714
|
+
}
|
|
715
|
+
}
|
|
705
716
|
|
|
706
|
-
|
|
717
|
+
/**
|
|
718
|
+
* Publish the per-step latency and throughput row beneath the answer.
|
|
719
|
+
*
|
|
720
|
+
* The numbers are measured from DSH's live frames, so a route that does not
|
|
721
|
+
* stream (no frames) simply gets no row instead of a fabricated duration.
|
|
722
|
+
* Output tokens come from the step's own usage record.
|
|
723
|
+
*/
|
|
724
|
+
#emitStreamStats(data: Record<string, unknown>): void {
|
|
725
|
+
const stats = this.#streamStats;
|
|
726
|
+
this.#streamStats = undefined;
|
|
727
|
+
if (stats === undefined || stats.firstTokenAt === undefined) return;
|
|
728
|
+
const usage = isRecord(data.usage) ? data.usage : undefined;
|
|
729
|
+
const outputTokens = typeof usage?.outputTokens === "number" ? usage.outputTokens : undefined;
|
|
730
|
+
const firstTokenMs = stats.firstTokenAt - stats.startedAt;
|
|
731
|
+
// Throughput needs a measured window between the first and the last text
|
|
732
|
+
// delta. A route that delivers the whole answer in one burst (or one chunk)
|
|
733
|
+
// has no observable window, so it reports latency only instead of a
|
|
734
|
+
// meaningless thousands-of-tokens-per-second figure.
|
|
735
|
+
const span =
|
|
736
|
+
stats.lastTokenAt === undefined ? 0 : stats.lastTokenAt - stats.firstTokenAt;
|
|
737
|
+
const measured = outputTokens !== undefined && span >= 50 ? outputTokens / (span / 1000) : undefined;
|
|
738
|
+
// A burst delivery has no real generation window; a value this high is a
|
|
739
|
+
// measurement artifact, not a speed anyone can use.
|
|
740
|
+
const tokensPerSecond = measured !== undefined && measured <= 3000 ? measured : undefined;
|
|
741
|
+
const turn = typeof data.turn === "number" ? data.turn : stats.turn;
|
|
742
|
+
const step = typeof data.step === "number" ? data.step : stats.step;
|
|
743
|
+
const statsData: Record<string, unknown> = {
|
|
744
|
+
firstTokenMs,
|
|
745
|
+
...(tokensPerSecond === undefined ? {} : { tokensPerSecond }),
|
|
746
|
+
...(outputTokens === undefined ? {} : { outputTokens }),
|
|
747
|
+
...(typeof usage?.inputTokens === "number" ? { inputTokens: usage.inputTokens } : {}),
|
|
748
|
+
...(typeof usage?.cacheReadTokens === "number" ? { cachedInputTokens: usage.cacheReadTokens } : {}),
|
|
749
|
+
...this.#contextFields(),
|
|
750
|
+
provider: this.#route.provider,
|
|
751
|
+
model: this.#route.model,
|
|
752
|
+
...(this.#thinkingOption === undefined ? {} : { thinkingOption: this.#thinkingOption }),
|
|
753
|
+
toolCalls: this.#turnTool.count,
|
|
754
|
+
...(this.#turnTool.ms > 0 ? { toolMs: this.#turnTool.ms } : {}),
|
|
755
|
+
...this.#sessionFields(),
|
|
756
|
+
};
|
|
757
|
+
this.#lastStats = { id: `stream-stats:${turn}:${step}`, data: statsData };
|
|
758
|
+
this.#emitStatsRow();
|
|
707
759
|
}
|
|
708
760
|
|
|
709
|
-
|
|
710
|
-
|
|
761
|
+
/** Fold one assistant message's turn, step and usage into the session totals. */
|
|
762
|
+
#accumulateTotals(data: Record<string, unknown>): void {
|
|
763
|
+
const turn = typeof data.turn === "number" ? data.turn : undefined;
|
|
764
|
+
const step = typeof data.step === "number" ? data.step : undefined;
|
|
765
|
+
if (turn !== undefined) this.#seenTurns.add(turn);
|
|
766
|
+
if (turn !== undefined && step !== undefined) this.#seenSteps.add(`${turn}:${step}`);
|
|
767
|
+
const usage = isRecord(data.usage) ? data.usage : undefined;
|
|
768
|
+
if (usage === undefined) return;
|
|
769
|
+
if (typeof usage.inputTokens === "number") this.#totals.input += usage.inputTokens;
|
|
770
|
+
if (typeof usage.cacheReadTokens === "number") this.#totals.cache += usage.cacheReadTokens;
|
|
771
|
+
if (typeof usage.cacheWriteTokens === "number") this.#totals.cacheWrite += usage.cacheWriteTokens;
|
|
772
|
+
if (typeof usage.outputTokens === "number") this.#totals.output += usage.outputTokens;
|
|
711
773
|
}
|
|
712
774
|
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
775
|
+
/**
|
|
776
|
+
* Turns, steps, total tokens and cache-hit rate for the collapsed line.
|
|
777
|
+
*
|
|
778
|
+
* Mirrors DSH's own UsagePill: the total is the three prompt-side billing
|
|
779
|
+
* buckets plus output, and the cache rate divides cache reads by that same
|
|
780
|
+
* prompt-side total.
|
|
781
|
+
*/
|
|
782
|
+
#sessionFields(): Record<string, number> {
|
|
783
|
+
const promptTokens = this.#totals.input + this.#totals.cache + this.#totals.cacheWrite;
|
|
784
|
+
const tokens = promptTokens + this.#totals.output;
|
|
785
|
+
return {
|
|
786
|
+
turns: this.#seenTurns.size,
|
|
787
|
+
steps: this.#seenSteps.size,
|
|
788
|
+
...(tokens > 0 ? { sessionTokens: tokens } : {}),
|
|
789
|
+
...(promptTokens > 0 ? { cacheHit: this.#totals.cache / promptTokens } : {}),
|
|
790
|
+
};
|
|
718
791
|
}
|
|
719
792
|
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
793
|
+
/** Context occupancy from the last usage snapshot, when known. */
|
|
794
|
+
#contextFields(): Record<string, number> {
|
|
795
|
+
const usage = this.#lastUsage;
|
|
796
|
+
return {
|
|
797
|
+
...(typeof usage?.contextWindowUsedTokens === "number"
|
|
798
|
+
? { contextUsed: usage.contextWindowUsedTokens }
|
|
799
|
+
: {}),
|
|
800
|
+
...(typeof usage?.contextWindowMaxTokens === "number"
|
|
801
|
+
? { contextMax: usage.contextWindowMaxTokens }
|
|
802
|
+
: {}),
|
|
803
|
+
};
|
|
804
|
+
}
|
|
805
|
+
|
|
806
|
+
/** Publish (or re-publish) the current stats row under the answer. */
|
|
807
|
+
#emitStatsRow(): void {
|
|
808
|
+
const row = this.#lastStats;
|
|
809
|
+
if (row === undefined) return;
|
|
810
|
+
this.#emitItem({
|
|
811
|
+
type: "plugin",
|
|
812
|
+
id: row.id,
|
|
813
|
+
pluginId: "dsh-paseo",
|
|
814
|
+
kind: "dsh-stream-stats",
|
|
815
|
+
version: 1,
|
|
816
|
+
data: row.data as JsonValue,
|
|
817
|
+
});
|
|
818
|
+
}
|
|
819
|
+
|
|
820
|
+
#trackToolEvent(event: { type: string; data?: unknown }): void {
|
|
821
|
+
const data = isRecord(event.data) ? event.data : {};
|
|
822
|
+
if (event.type === "tool/call") {
|
|
823
|
+
const callId = typeof data.callId === "string" ? data.callId : undefined;
|
|
824
|
+
if (callId !== undefined) this.#toolStarts.set(callId, Date.now());
|
|
726
825
|
return;
|
|
727
826
|
}
|
|
728
|
-
const
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
827
|
+
const message = isRecord(data.message) ? data.message : undefined;
|
|
828
|
+
const callId =
|
|
829
|
+
typeof data.toolCallId === "string"
|
|
830
|
+
? data.toolCallId
|
|
831
|
+
: typeof message?.toolCallId === "string"
|
|
832
|
+
? message.toolCallId
|
|
833
|
+
: undefined;
|
|
834
|
+
if (callId === undefined) return;
|
|
835
|
+
const startedAt = this.#toolStarts.get(callId);
|
|
836
|
+
if (startedAt === undefined) return;
|
|
837
|
+
this.#toolStarts.delete(callId);
|
|
838
|
+
this.#turnTool.count += 1;
|
|
839
|
+
this.#turnTool.ms += Math.max(0, Date.now() - startedAt);
|
|
840
|
+
}
|
|
841
|
+
|
|
842
|
+
#emitItem(item: ProviderTimelineItem): void {
|
|
843
|
+
this.#options.emit({ type: "timeline.item", sessionId: this.id, item });
|
|
844
|
+
}
|
|
845
|
+
|
|
846
|
+
/**
|
|
847
|
+
* Fold one live assistant-stream frame into the answer row.
|
|
848
|
+
*
|
|
849
|
+
* DSH publishes token-level deltas while the model writes. Emitting a text
|
|
850
|
+
* snapshot under the same timeline id the durable message will use lets
|
|
851
|
+
* Paseo append the delta live; the step's `assistant/message` then arrives as
|
|
852
|
+
* the authoritative final snapshot and replaces the row in place.
|
|
853
|
+
*/
|
|
854
|
+
#onAssistantStream(frame: DshAssistantFrame): void {
|
|
855
|
+
if (this.#closed) return;
|
|
856
|
+
if (frame.type === "start") {
|
|
857
|
+
this.#clearLive();
|
|
858
|
+
this.#streamStats = {
|
|
859
|
+
turn: frame.turn ?? 0,
|
|
860
|
+
step: frame.step ?? 0,
|
|
861
|
+
startedAt: Date.now(),
|
|
862
|
+
};
|
|
863
|
+
this.#live = {
|
|
864
|
+
attemptId: frame.attemptId,
|
|
865
|
+
turn: frame.turn ?? 0,
|
|
866
|
+
step: frame.step ?? 0,
|
|
867
|
+
text: "",
|
|
868
|
+
emitted: "",
|
|
869
|
+
reasoning: "",
|
|
870
|
+
emittedReasoning: "",
|
|
871
|
+
timer: undefined,
|
|
872
|
+
};
|
|
873
|
+
return;
|
|
753
874
|
}
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
if (
|
|
757
|
-
this.#
|
|
758
|
-
this.#
|
|
875
|
+
const live = this.#live;
|
|
876
|
+
if (live === undefined || live.attemptId !== frame.attemptId) return;
|
|
877
|
+
if (frame.type === "end") {
|
|
878
|
+
this.#flushLive();
|
|
879
|
+
this.#clearLive();
|
|
880
|
+
if (this.#streamStats !== undefined) this.#streamStats.endedAt = Date.now();
|
|
881
|
+
return;
|
|
882
|
+
}
|
|
883
|
+
if (typeof frame.text !== "string") return;
|
|
884
|
+
const stats = this.#streamStats;
|
|
885
|
+
if (frame.kind === "text" && stats !== undefined) {
|
|
886
|
+
// Prefer DSH's own chunk timestamp (epoch ms, same clock) so IPC latency
|
|
887
|
+
// never stretches or compresses the measured generation window.
|
|
888
|
+
const at = typeof frame.time === "number" ? frame.time : Date.now();
|
|
889
|
+
if (stats.firstTokenAt === undefined) stats.firstTokenAt = at;
|
|
890
|
+
stats.lastTokenAt = at;
|
|
759
891
|
}
|
|
892
|
+
if (frame.kind === "reasoning") live.reasoning += frame.text;
|
|
893
|
+
else live.text += frame.text;
|
|
894
|
+
if (live.timer !== undefined) return;
|
|
895
|
+
// Coalesce token deltas so a long answer does not republish the whole row
|
|
896
|
+
// hundreds of times; 40ms still reads as continuous typing.
|
|
897
|
+
live.timer = setTimeout(() => {
|
|
898
|
+
const current = this.#live;
|
|
899
|
+
if (current === undefined) return;
|
|
900
|
+
current.timer = undefined;
|
|
901
|
+
this.#flushLive();
|
|
902
|
+
}, 40);
|
|
903
|
+
live.timer.unref?.();
|
|
760
904
|
}
|
|
761
905
|
|
|
762
|
-
/**
|
|
763
|
-
#
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
906
|
+
/** Publish the accumulated live text as the message row's current snapshot. */
|
|
907
|
+
#flushLive(): void {
|
|
908
|
+
const live = this.#live;
|
|
909
|
+
if (live === undefined) return;
|
|
910
|
+
if (live.timer !== undefined) {
|
|
911
|
+
clearTimeout(live.timer);
|
|
912
|
+
live.timer = undefined;
|
|
913
|
+
}
|
|
914
|
+
// The thinking row must exist before the answer row, matching the durable
|
|
915
|
+
// order; otherwise the late reasoning item would land below the answer.
|
|
916
|
+
if (live.reasoning !== "" && live.reasoning !== live.emittedReasoning) {
|
|
917
|
+
live.emittedReasoning = live.reasoning;
|
|
918
|
+
this.#emitItem({
|
|
919
|
+
type: "reasoning",
|
|
920
|
+
id: `reasoning:${live.turn}:${live.step}`,
|
|
921
|
+
text: live.reasoning,
|
|
922
|
+
});
|
|
767
923
|
}
|
|
768
|
-
|
|
769
|
-
|
|
924
|
+
if (live.text === "" || live.text === live.emitted) return;
|
|
925
|
+
live.emitted = live.text;
|
|
926
|
+
this.#emitItem({
|
|
927
|
+
type: "assistant_message",
|
|
928
|
+
id: `assistant:${live.turn}:${live.step}`,
|
|
929
|
+
text: live.text,
|
|
930
|
+
});
|
|
931
|
+
}
|
|
932
|
+
|
|
933
|
+
/** Forget the live buffer without flushing it (interrupt, exit, close). */
|
|
934
|
+
#clearLive(): void {
|
|
935
|
+
const live = this.#live;
|
|
936
|
+
if (live?.timer !== undefined) clearTimeout(live.timer);
|
|
937
|
+
this.#live = undefined;
|
|
770
938
|
}
|
|
771
939
|
|
|
772
940
|
/**
|
package/server/stream-replay.ts
DELETED
|
@@ -1,127 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* Turn DSH's per-message stream metadata into incremental timeline snapshots.
|
|
3
|
-
*
|
|
4
|
-
* DSH publishes a model step as one `assistant/message` event, but carries the
|
|
5
|
-
* pacing of the text it produced in `data.stream`:
|
|
6
|
-
*
|
|
7
|
-
* { type: "text-chunks", texts: string[], dt: number[] }
|
|
8
|
-
*
|
|
9
|
-
* The DSH client replays those chunks, so text appears as it is generated.
|
|
10
|
-
* Paseo renders timeline snapshots, so without a replay the whole answer pops
|
|
11
|
-
* in at once. This module derives the cumulative frames; the session decides
|
|
12
|
-
* when to emit them.
|
|
13
|
-
*
|
|
14
|
-
* @module dsh-paseo/server/stream-replay
|
|
15
|
-
*/
|
|
16
|
-
|
|
17
|
-
export interface StreamFrame {
|
|
18
|
-
/** Milliseconds after the first frame at which this frame becomes visible. */
|
|
19
|
-
at: number;
|
|
20
|
-
/** Cumulative text visible from this frame on. */
|
|
21
|
-
text: string;
|
|
22
|
-
}
|
|
23
|
-
|
|
24
|
-
/** Frames closer together than this are merged; avoids timer storms. */
|
|
25
|
-
const MIN_FRAME_GAP_MS = 40;
|
|
26
|
-
/** Never stretch a finished step longer than this. */
|
|
27
|
-
const MAX_TOTAL_MS = 2500;
|
|
28
|
-
/** Below this the reveal would be imperceptible; show the text at once instead. */
|
|
29
|
-
const MIN_TOTAL_MS = 120;
|
|
30
|
-
/** The smallest message is not worth animating. */
|
|
31
|
-
const MIN_REPLAY_CHARS = 16;
|
|
32
|
-
/** Hard cap on scheduled frames. */
|
|
33
|
-
const MAX_FRAMES = 120;
|
|
34
|
-
/** Long answers re-render more markdown per frame, so they get fewer frames. */
|
|
35
|
-
function frameBudget(characters: number): number {
|
|
36
|
-
if (characters > 12000) return 16;
|
|
37
|
-
if (characters > 4000) return 40;
|
|
38
|
-
return MAX_FRAMES;
|
|
39
|
-
}
|
|
40
|
-
|
|
41
|
-
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
42
|
-
return typeof value === "object" && value !== null;
|
|
43
|
-
}
|
|
44
|
-
|
|
45
|
-
function textOf(content: unknown[]): string {
|
|
46
|
-
return content
|
|
47
|
-
.filter((block): block is Record<string, unknown> => isRecord(block) && block.type === "text")
|
|
48
|
-
.map((block) => (typeof block.text === "string" ? block.text : ""))
|
|
49
|
-
.join("");
|
|
50
|
-
}
|
|
51
|
-
|
|
52
|
-
/**
|
|
53
|
-
* Build the replay frames for one `assistant/message` payload.
|
|
54
|
-
*
|
|
55
|
-
* Returns undefined when the payload cannot be replayed faithfully — no stream
|
|
56
|
-
* metadata, a single chunk, an empty message, or a message that also carries a
|
|
57
|
-
* tool call (those are followed by tool events, and stretching the text would
|
|
58
|
-
* show the tool card before the text that introduced it).
|
|
59
|
-
*/
|
|
60
|
-
export function buildStreamFrames(data: unknown): StreamFrame[] | undefined {
|
|
61
|
-
if (!isRecord(data)) return undefined;
|
|
62
|
-
const message = isRecord(data.message) ? data.message : undefined;
|
|
63
|
-
const content = message?.content;
|
|
64
|
-
if (!Array.isArray(content)) return undefined;
|
|
65
|
-
if (content.some((block) => isRecord(block) && block.type === "tool-call")) return undefined;
|
|
66
|
-
|
|
67
|
-
const fullText = textOf(content);
|
|
68
|
-
if (fullText.length < MIN_REPLAY_CHARS) return undefined;
|
|
69
|
-
|
|
70
|
-
const stream = data.stream;
|
|
71
|
-
if (!Array.isArray(stream)) return undefined;
|
|
72
|
-
|
|
73
|
-
const texts: string[] = [];
|
|
74
|
-
const delays: number[] = [];
|
|
75
|
-
for (const part of stream) {
|
|
76
|
-
if (!isRecord(part) || part.type !== "text-chunks") continue;
|
|
77
|
-
if (!Array.isArray(part.texts)) continue;
|
|
78
|
-
const dt = Array.isArray(part.dt) ? part.dt : [];
|
|
79
|
-
for (let index = 0; index < part.texts.length; index += 1) {
|
|
80
|
-
texts.push(typeof part.texts[index] === "string" ? (part.texts[index] as string) : "");
|
|
81
|
-
const gap = dt[index];
|
|
82
|
-
delays.push(typeof gap === "number" && Number.isFinite(gap) && gap > 0 ? gap : 0);
|
|
83
|
-
}
|
|
84
|
-
}
|
|
85
|
-
if (texts.length < 2) return undefined;
|
|
86
|
-
|
|
87
|
-
const frames: StreamFrame[] = [];
|
|
88
|
-
let at = 0;
|
|
89
|
-
let text = "";
|
|
90
|
-
let lastEmittedAt = -MIN_FRAME_GAP_MS;
|
|
91
|
-
for (let index = 0; index < texts.length; index += 1) {
|
|
92
|
-
at += delays[index] ?? 0;
|
|
93
|
-
text += texts[index] ?? "";
|
|
94
|
-
const isLast = index === texts.length - 1;
|
|
95
|
-
if (!isLast && at - lastEmittedAt < MIN_FRAME_GAP_MS) continue;
|
|
96
|
-
// An empty or repeated chunk changes nothing on screen.
|
|
97
|
-
if (text === (frames[frames.length - 1]?.text ?? "")) continue;
|
|
98
|
-
frames.push({ at, text });
|
|
99
|
-
lastEmittedAt = at;
|
|
100
|
-
}
|
|
101
|
-
|
|
102
|
-
// Metadata and the folded message can disagree (truncated stream, dropped
|
|
103
|
-
// chunk): the message content is authoritative, so the last frame is it.
|
|
104
|
-
const last = frames[frames.length - 1];
|
|
105
|
-
if (last === undefined) return undefined;
|
|
106
|
-
last.text = fullText;
|
|
107
|
-
// The final chunk can be empty, leaving a duplicate of the previous frame.
|
|
108
|
-
if (frames.length >= 2 && frames[frames.length - 2]?.text === fullText) frames.pop();
|
|
109
|
-
if (frames.length < 2) return undefined;
|
|
110
|
-
|
|
111
|
-
const total = last.at;
|
|
112
|
-
if (total < MIN_TOTAL_MS) return undefined;
|
|
113
|
-
if (total > MAX_TOTAL_MS) {
|
|
114
|
-
for (const frame of frames) frame.at = Math.round((frame.at * MAX_TOTAL_MS) / total);
|
|
115
|
-
}
|
|
116
|
-
|
|
117
|
-
const budget = frameBudget(fullText.length);
|
|
118
|
-
if (frames.length > budget) {
|
|
119
|
-
const stride = Math.ceil(frames.length / budget);
|
|
120
|
-
const reduced: StreamFrame[] = [];
|
|
121
|
-
for (let index = 0; index < frames.length; index += stride) reduced.push(frames[index] as StreamFrame);
|
|
122
|
-
const lastFrame = frames[frames.length - 1] as StreamFrame;
|
|
123
|
-
if (reduced[reduced.length - 1] !== lastFrame) reduced.push(lastFrame);
|
|
124
|
-
return reduced;
|
|
125
|
-
}
|
|
126
|
-
return frames;
|
|
127
|
-
}
|