paseo-dsh-direct 0.2.10 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-dsh-direct",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "DeepSeek Harness Direct Provider Plugin for Paseo",
   "repository": {
     "type": "git",

package/server/bridge-client.ts

@@ -17,6 +17,15 @@ import type {
 type Method = keyof BridgeMethods;
 type Notification = keyof BridgeNotifications;
 
+/**
+ * Default deadline for one bridge request. `session.list` title folds decode a
+ * whole session log per row, so callers list large histories with a wider
+ * deadline instead of raising this for every method.
+ */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/** Deadline for listing sessions: a cold title fold costs seconds per hundred sessions. */
+export const LIST_SESSIONS_TIMEOUT_MS = 120_000;
+
 export interface DshBridge {
   readonly initialized: BridgeInitializeResult;
   /** The resolved `dsh` executable this bridge was launched with (see `resolveDshLaunch`). */
@@ -26,6 +35,7 @@ export interface DshBridge {
   request<Name extends Method>(
     method: Name,
     params: BridgeMethods[Name]["params"],
+    timeoutMs?: number,
   ): Promise<BridgeMethods[Name]["result"]>;
   on<Name extends Notification>(
     method: Name,
@@ -471,6 +481,7 @@ class JsonlBridgeClient implements DshBridge {
   request<Name extends Method>(
     method: Name,
     params: BridgeMethods[Name]["params"],
+    timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
   ): Promise<BridgeMethods[Name]["result"]> {
     if (this.terminalError) return Promise.reject(this.terminalError);
     if (this.closing && method !== "bridge.shutdown") {
@@ -481,7 +492,7 @@ class JsonlBridgeClient implements DshBridge {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`DSH bridge request timed out: ${method}`));
-      }, 30_000);
+      }, timeoutMs);
       this.pending.set(id, { resolve, reject, timeout });
       const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
       this.child.stdin.write(payload, (error) => {

package/server/dsh/service.ts

@@ -140,6 +140,8 @@ export class BridgeService {
   private readonly subscriptions: Array<() => void> = [];
   /** Last usage payload sent per session, so an unchanged fold is not re-sent. */
   private readonly lastUsage = new Map<string, string>();
+  /** Folded titles per session id, so repeated import listings stay cheap. */
+  private readonly titles = new Map<string, string>();
   private stopping = false;
   private stopTask?: Promise<{}>;
 
@@ -262,7 +264,11 @@ export class BridgeService {
         }
       | undefined;
     const pressure = values.contextPressure as
-      | { contextWindow?: number; pressureTokens?: number }
+      | {
+          contextWindow?: number;
+          pressureTokens?: number;
+          projectedTokens?: number;
+        }
       | undefined;
     const usage: BridgeUsage = {};
     if (typeof tokens?.uncachedInputTokens === "number")
@@ -271,8 +277,16 @@ export class BridgeService {
       usage.cachedInputTokens = tokens.cacheReadTokens;
     if (typeof tokens?.outputTokens === "number")
       usage.outputTokens = tokens.outputTokens;
-    if (typeof pressure?.pressureTokens === "number")
-      usage.contextWindowUsedTokens = pressure.pressureTokens;
+    // `projectedTokens` folds the shadow price of an adjacent compaction into
+    // the last request's prompt size, so the meter drops as soon as a
+    // compaction lands instead of waiting for the next request. dsh before
+    // 0.2.1 writes no shadow price and the field is absent: fall back to the
+    // raw prompt size.
+    const used =
+      typeof pressure?.projectedTokens === "number"
+        ? pressure.projectedTokens
+        : pressure?.pressureTokens;
+    if (typeof used === "number") usage.contextWindowUsedTokens = used;
     if (typeof pressure?.contextWindow === "number")
       usage.contextWindowMaxTokens = pressure.contextWindow;
     // The units materialize at zero before any provider usage lands, so a
@@ -453,29 +467,9 @@ export class BridgeService {
         } satisfies BridgeInitializeResult;
         break;
       }
-      case "session.list": {
-        const query = this.ctx.get("sessionQuery");
-        const records = await query.listSessions();
-        const sessions: SessionSummary[] = records.map((record) => ({
-          ...record.header,
-        }));
-        // The official bulk title read owns live/cold source and validation.
-        if (typeof query.readTitleSnapshots === "function") {
-          const titles = await query.readTitleSnapshots(
-            sessions.map((session) => session.id),
-          );
-          for (let i = 0; i < sessions.length; i++) {
-            const result = titles[i];
-            const title =
-              result?.status === "fulfilled"
-                ? result.value.title?.title
-                : undefined;
-            if (typeof title === "string") sessions[i]!.title = title;
-          }
-        }
-        result = { sessions };
+      case "session.list":
+        result = { sessions: await this.listSessions(listParams(params)) };
         break;
-      }
       case "session.read":
         result = await this.ctx
           .get("sessionQuery")
@@ -622,6 +616,72 @@ export class BridgeService {
     );
   }
 
+  /**
+   * List native sessions for Paseo's import picker.
+   *
+   * `readTitleSnapshots` decodes each requested session's log to fold its
+   * title, which costs seconds per hundred sessions on a large history, so
+   * titles are folded only for the rows this call returns: cwd and query
+   * filter first, then newest first, then the limit. Folded titles are cached
+   * for this bridge's lifetime; a title renamed outside Paseo keeps its cached
+   * value until the bridge is replaced, while live sessions carry their header
+   * title regardless.
+   */
+  private async listSessions(
+    params: { cwd?: string; query?: string; limit?: number },
+  ): Promise<SessionSummary[]> {
+    const query = this.ctx.get("sessionQuery");
+    const records = await query.listSessions();
+    let sessions = records
+      .map((record) => ({ ...record.header }))
+      .filter((session) => !params.cwd || session.cwd === params.cwd);
+    if (params.query) {
+      // A title query needs every title, so this path folds the whole history.
+      await this.foldTitles(query, sessions);
+      const needle = params.query.toLowerCase();
+      sessions = sessions.filter(
+        (session) =>
+          session.title?.toLowerCase().includes(needle) ||
+          session.id.toLowerCase().includes(needle),
+      );
+    }
+    sessions.sort((left, right) => right.createdAt - left.createdAt);
+    if (params.limit !== undefined && sessions.length > params.limit)
+      sessions = sessions.slice(0, params.limit);
+    await this.foldTitles(query, sessions);
+    return sessions;
+  }
+
+  /** Fill in cached titles, reading only the sessions this bridge has not folded yet. */
+  private async foldTitles(
+    query: HostServices["sessionQuery"],
+    sessions: SessionSummary[],
+  ): Promise<void> {
+    if (typeof query.readTitleSnapshots !== "function") return;
+    // The official bulk title read owns live/cold source and validation. A
+    // header that already carries a title is live and needs no fold at all.
+    const missing = sessions.filter(
+      (session) => !session.title && !this.titles.has(session.id),
+    );
+    if (missing.length > 0) {
+      const titles = await query.readTitleSnapshots(
+        missing.map((session) => session.id),
+      );
+      for (let i = 0; i < missing.length; i++) {
+        const result = titles[i];
+        const title =
+          result?.status === "fulfilled"
+            ? result.value.title?.title
+            : undefined;
+        if (typeof title === "string") this.titles.set(missing[i]!.id, title);
+      }
+    }
+    for (const session of sessions) {
+      const title = this.titles.get(session.id);
+      if (title !== undefined) session.title = title;
+    }
+  }
+
   /** Registered commands first; a skill never shadows a command of the same name. */
   private async slashCommands(agent: HostAgent): Promise<SlashCommand[]> {
     const commands: SlashCommand[] = (this.ctx.get("commands")?.list(agent) ?? []).map(
@@ -971,6 +1031,31 @@ function validateContent(value: unknown): PromptPart[] {
   return parts;
 }
 
+function listParams(params: Record<string, unknown>): {
+  cwd?: string;
+  query?: string;
+  limit?: number;
+} {
+  const result: { cwd?: string; query?: string; limit?: number } = {};
+  if (params.cwd !== undefined) result.cwd = nonempty(params.cwd, "cwd");
+  if (params.query !== undefined) {
+    if (typeof params.query !== "string")
+      throw new Error("query must be a string");
+    const query = params.query.trim();
+    if (query) result.query = query;
+  }
+  if (params.limit !== undefined) {
+    if (
+      typeof params.limit !== "number" ||
+      !Number.isSafeInteger(params.limit) ||
+      params.limit < 1
+    )
+      throw new Error("limit must be a positive integer");
+    result.limit = params.limit;
+  }
+  return result;
+}
+
 function validateOpen(params: Record<string, unknown>): SessionOpenParams {
   const result: SessionOpenParams = { cwd: nonempty(params.cwd, "cwd") };
   if (params.sessionId !== undefined)

package/server/provider.ts

@@ -27,6 +27,7 @@ import { slashLine } from "../shared/bridge-protocol.js";
 import {
   DEFAULT_PROFILE,
   describeDshLaunch,
+  LIST_SESSIONS_TIMEOUT_MS,
   resolveDshLaunch,
   type BridgeMcpServer,
   type DshBridge,
@@ -404,8 +405,18 @@ async function listSessions(
   input: Extract<ProviderInput, { type: "sessions" }>,
   state: DispatchState,
 ): Promise<void> {
-  const result = await state.discoveryBridge.request("session.list", {});
   const query = input.query?.trim().toLowerCase();
+  // Filtering and truncation run in the bridge so title folds only cover the
+  // rows Paseo will actually show; the local filters stay as a second net.
+  const result = await state.discoveryBridge.request(
+    "session.list",
+    {
+      ...(input.cwd ? { cwd: input.cwd } : {}),
+      ...(query ? { query } : {}),
+      ...(input.limit !== undefined ? { limit: input.limit } : {}),
+    },
+    LIST_SESSIONS_TIMEOUT_MS,
+  );
   const rows = result.sessions
     .filter((session): session is typeof session & { cwd: string } => Boolean(session.cwd))
     .filter((session) => !input.cwd || session.cwd === input.cwd)

package/shared/bridge-protocol.ts

@@ -160,7 +160,10 @@ export interface CommandResult {
 }
 export interface BridgeMethods {
   "bridge.initialize": { params: {}; result: BridgeInitializeResult };
-  "session.list": { params: {}; result: { sessions: SessionSummary[] } };
+  "session.list": {
+    params: { cwd?: string; query?: string; limit?: number };
+    result: { sessions: SessionSummary[] };
+  };
   "session.read": { params: { sessionId: string }; result: SessionSnapshot };
   "session.open": { params: SessionOpenParams; result: SessionOpenResult };
   "session.prompt": {