@alwith-ai/dsh-agent 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alwith-ai/dsh-agent",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "ACP v2 agent built on DeepSeek Harness: fixed plugin compositions (standard / minimal / anchored / code / cordis), streaming turns with direct state reporting, permissions, resume with replay, multi-provider credentials and subscription login",
   "license": "MIT",
   "repository": {

package/src/bridge.ts

@@ -22,6 +22,7 @@
  */
 
 import type { Context } from "@deepseek-ai/cordis"
+import packageJson from "../package.json" with { type: "json" }
 import { randomUUID } from "node:crypto"
 import { isAbsolute } from "node:path"
 import { Readable, Writable } from "node:stream"
@@ -36,6 +37,8 @@ import {
   type CancelSessionNotification,
   type CloseSessionRequest,
   type CloseSessionResponse,
+  type ListSessionsRequest,
+  type ListSessionsResponse,
   type CompactionId,
   type InitializeResponse,
   type NewSessionRequest,
@@ -612,9 +615,15 @@ export function apply(ctx: Context, config: AcpConfig): void {
     .onRequest("initialize", (): InitializeResponse => {
       return {
         protocolVersion: ACP_PROTOCOL_VERSION,
-        info: { name: "dsh-agent", title: "ALwith dsh bridge", version: "0.1.0" },
+        info: { name: "dsh-agent", title: "ALwith dsh bridge", version: packageJson.version },
         authMethods: [],
-        capabilities: { session: { prompt: {} } },
+        capabilities: {
+          session: { prompt: {} },
+          // seedHistory: a host that keeps its own transcript can continue it here —
+          // `session/new` with `_meta.dsh.seedHistory: [{role, text}]` injects it as
+          // model-facing context (agent.inject) before the first turn.
+          _meta: { dsh: { seedHistory: true } },
+        },
       }
     })
     .onRequest("session/new", async (context): Promise<NewSessionResponse> => {
@@ -643,8 +652,34 @@ export function apply(ctx: Context, config: AcpConfig): void {
       })
       const record = sessions.get(sessionId)
       if (record === undefined) throw internalError("session record vanished during session/new")
+      const seed = seedHistoryOf(params._meta)
+      if (seed.length > 0) {
+        record.agent.inject(
+          createUserMessage({ content: [{ type: "text", text: seedTranscript(seed) }], source: { kind: "user" } }),
+        )
+      }
       return { sessionId, configOptions: await modelConfigOptions(record) }
     })
+    // v2 baseline: session/list is part of the `session: {}` surface, no capability key.
+    // Headers come from dsh's own persistence (the on-disk format stays private to it);
+    // `cwd` narrows to sessions started in that workspace, like the cli.
+    .onRequest("session/list", async (context): Promise<ListSessionsResponse> => {
+      assertOpen()
+      const params: ListSessionsRequest = context.params
+      const persistence = ctx.get("sessionPersistence")
+      if (persistence === undefined) throw internalError("session persistence is not mounted")
+      const headers = await persistence.list()
+      const sessions = headers
+        .filter(header => params.cwd === undefined || params.cwd === null || header.cwd === params.cwd)
+        .sort((a, b) => b.createdAt - a.createdAt)
+        .map(header => {
+          // Every bridge session is created with meta.cwd; a header without one is a
+          // persistence anomaly, not a session the host could resume.
+          if (header.cwd === undefined) throw internalError(`persisted session ${header.id} has no cwd`)
+          return { sessionId: header.id, cwd: header.cwd, updatedAt: new Date(header.createdAt).toISOString() }
+        })
+      return { sessions, nextCursor: null }
+    })
     .onRequest("session/resume", async (context): Promise<ResumeSessionResponse> => {
       assertOpen()
       const params: ResumeSessionRequest = context.params
@@ -901,3 +936,29 @@ function validateSessionParams(params: NewSessionRequest): void {
     throw invalidParams("mcpServers is not supported")
   }
 }
+
+export interface SeedMessage {
+  role: "user" | "assistant"
+  text: string
+}
+
+/** `session/new` `_meta.dsh.seedHistory`: prior conversation the host kept, to inject as model-facing context. */
+export function seedHistoryOf(meta: NewSessionRequest["_meta"]): SeedMessage[] {
+  const raw = (meta as { dsh?: { seedHistory?: unknown } } | null | undefined)?.dsh?.seedHistory
+  if (raw === undefined || raw === null) return []
+  if (!Array.isArray(raw)) throw invalidParams("seedHistory must be an array of {role, text}")
+  return raw.map((entry, index) => {
+    const role = (entry as { role?: unknown })?.role
+    const text = (entry as { text?: unknown })?.text
+    if ((role !== "user" && role !== "assistant") || typeof text !== "string") {
+      throw invalidParams(`seedHistory[${index}] must be {role: "user" | "assistant", text: string}`)
+    }
+    return { role, text }
+  })
+}
+
+/** dsh injects one user-authored context message; the transcript is framed so the model reads it as history. */
+export function seedTranscript(seed: readonly SeedMessage[]): string {
+  const lines = seed.map(message => `${message.role === "user" ? "User" : "Assistant"}: ${message.text}`)
+  return `<prior_conversation>\n${lines.join("\n\n")}\n</prior_conversation>`
+}