dsh-bridge 0.1.0-rc.5

package/README.md

@@ -0,0 +1,41 @@
+# dsh-bridge
+
+> The local event and session-messaging bridge for DeepSeek Harness.
+
+`dsh-bridge` provides same-process messaging between live DeepSeek Harness sessions. It is the local contract beneath `dsh-weave`: bridge normalizes local session events; weave carries approved work across machines.
+
+The plugin registers `session_list`, `session_send`, and `session_messages`.
+Delivery uses the public `ctx.agents` registry and `Agent.followup()`, so an
+idle target is woken and a busy target receives ordinary queued work. A bounded
+in-memory recent log (the latest 1,000 delivered messages) is kept only for
+`session_messages` replay and diagnostics; it is not a second delivery queue.
+Messages carry sender, target, UUID, and timestamp metadata.
+
+This package intentionally does not implement cross-host transport. `dsh-weave`
+will provide the authenticated network backend while preserving this tool contract.
+
+## Install
+
+```bash
+dsh plugin --profile web add dsh-bridge@next
+```
+
+## Known Limitations and Deferred Work
+
+- **Process boundary** — sessions in another process or host are not visible;
+  add an authenticated relay/backend before advertising cross-host delivery.
+- **In-memory retention** — messages are lost when the plugin process exits and
+  older than the latest 1,000 are evicted; durable inbox/outbox persistence is
+  still deferred until a cross-process relay needs it.
+- **Delivery acknowledgement** — the current result means the target was live
+  and accepted the follow-up call, not that the target model processed it.
+
+## Model Experience
+
+None, as `session_list`, `session_send`, and `session_messages` expose their
+schemas directly through the tool registry.
+
+### KV Cache effect
+
+Independent tool schemas; sending a message changes only the target session's
+queued input and does not alter the sender's cached prompt prefix.

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-bridge
+      name: dsh-bridge

package/lib/index.js

@@ -0,0 +1,179 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region lib/types/index.js
+const name = "session-messaging";
+const inject = ["agents", "tools"];
+const MAX_RECENT_MESSAGES = 1000;
+var LocalSessionMessagingImpl = class {
+	ctx;
+	messages = [];
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	list() {
+		return [...this.ctx.agents.list()].map((agent) => agent.session.id);
+	}
+	send(from, to, text) {
+		const target = this.ctx.agents.get(to);
+		if (!target) throw new Error(`session "${to}" is not live in this process`);
+		const id = crypto.randomUUID();
+		const message = {
+			id,
+			from: from.session.id,
+			to,
+			text,
+			createdAt: Date.now(),
+			delivered: true
+		};
+		target.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text: `[session-message ${id} from ${from.session.id}]\n${text}`
+			}],
+			source: {
+				kind: "plugin",
+				plugin: name,
+				form: "relay"
+			}
+		}));
+		this.messages.push(message);
+		if (this.messages.length > MAX_RECENT_MESSAGES) {
+			this.messages.splice(0, this.messages.length - MAX_RECENT_MESSAGES);
+		}
+		return {
+			messageId: id,
+			from: String(from.session.id),
+			to: String(to),
+			delivered: true
+		};
+	}
+	receive(sessionId, limit) {
+		return this.messages.filter((message) => message.to === sessionId).slice(-limit);
+	}
+};
+function apply(ctx) {
+	const messaging = new LocalSessionMessagingImpl(ctx);
+	ctx.accessor("sessionMessaging", { get: () => messaging });
+	ctx.tools.register(defineTool({
+		name: "session_list",
+		description: "List live DeepSeek Harness sessions in this process.",
+		parameters: {},
+		output: {
+			schema: {
+				type: "array",
+				items: { type: "string" }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.join("\n") || "No live sessions."
+			}]
+		},
+		async execute() {
+			return messaging.list().map(String);
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "session_send",
+		description: "Send a message to another live DeepSeek Harness session in this process.",
+		parameters: {
+			to: {
+				type: "string",
+				required: true,
+				description: "Target session id from session_list."
+			},
+			text: {
+				type: "string",
+				required: true,
+				description: "Message text."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					messageId: {
+						type: "string",
+						required: true
+					},
+					from: {
+						type: "string",
+						required: true
+					},
+					to: {
+						type: "string",
+						required: true
+					},
+					delivered: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Delivered ${value.messageId} to ${value.to}.`
+			}]
+		},
+		async execute(args, exec) {
+			if (!exec.agent) throw new Error("session_send requires an owning agent");
+			if (args.text.trim() === "") throw new Error("text must not be empty");
+			return messaging.send(exec.agent, SessionId(args.to), args.text);
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "session_messages",
+		description: "Read messages delivered to the current session in this process.",
+		parameters: { limit: {
+			type: "number",
+			description: "Maximum number of messages, default 20."
+		} },
+		output: {
+			schema: {
+				type: "array",
+				items: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						id: {
+							type: "string",
+							required: true
+						},
+						from: {
+							type: "string",
+							required: true
+						},
+						to: {
+							type: "string",
+							required: true
+						},
+						text: {
+							type: "string",
+							required: true
+						},
+						createdAt: {
+							type: "number",
+							required: true
+						},
+						delivered: {
+							type: "boolean",
+							required: true
+						}
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.map((message) => `[${message.from}] ${message.text}`).join("\n") || "No messages."
+			}]
+		},
+		async execute(args, exec) {
+			if (!exec.agent) throw new Error("session_messages requires an owning agent");
+			const limit = args.limit === void 0 ? 20 : Math.max(1, Math.min(100, Math.floor(args.limit)));
+			return [...messaging.receive(exec.agent.session.id, limit)];
+		}
+	}));
+}
+//#endregion
+export { apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Same-process session-to-session messaging.
+ *
+ * The transport is deliberately process-local. A future relay can implement
+ * the same interface without changing the model-facing tools.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type SessionId as SessionIdValue } from '@deepseek-ai/dsh-session';
+export declare const name = "session-messaging";
+export declare const inject: string[];
+export interface LocalMessage {
+    readonly id: string;
+    readonly from: SessionIdValue;
+    readonly to: SessionIdValue;
+    readonly text: string;
+    readonly createdAt: number;
+    readonly delivered: boolean;
+}
+export interface SendMessageResult {
+    readonly messageId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly delivered: boolean;
+}
+export interface LocalSessionMessaging {
+    list(): readonly SessionIdValue[];
+    send(from: Agent, to: SessionIdValue, text: string): SendMessageResult;
+    receive(sessionId: SessionIdValue, limit: number): readonly LocalMessage[];
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        sessionMessaging: LocalSessionMessaging;
+    }
+}
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,114 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export const name = 'session-messaging';
+export const inject = ['agents', 'tools'];
+class LocalSessionMessagingImpl {
+    ctx;
+    messages = [];
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    list() {
+        return [...this.ctx.agents.list()].map(agent => agent.session.id);
+    }
+    send(from, to, text) {
+        const target = this.ctx.agents.get(to);
+        if (!target)
+            throw new Error(`session "${to}" is not live in this process`);
+        const id = crypto.randomUUID();
+        const message = {
+            id,
+            from: from.session.id,
+            to,
+            text,
+            createdAt: Date.now(),
+            delivered: true,
+        };
+        this.messages.push(message);
+        target.followup(createUserMessage({
+            content: [{ type: 'text', text: `[session-message ${id} from ${from.session.id}]\n${text}` }],
+            source: { kind: 'plugin', plugin: name, form: 'relay' },
+        }));
+        return { messageId: id, from: String(from.session.id), to: String(to), delivered: true };
+    }
+    receive(sessionId, limit) {
+        return this.messages.filter(message => message.to === sessionId).slice(-limit);
+    }
+}
+export function apply(ctx) {
+    const messaging = new LocalSessionMessagingImpl(ctx);
+    ctx.accessor('sessionMessaging', { get: () => messaging });
+    ctx.tools.register(defineTool({
+        name: 'session_list',
+        description: 'List live DeepSeek Harness sessions in this process.',
+        parameters: {},
+        output: {
+            schema: { type: 'array', items: { type: 'string' } },
+            render: (_args, value) => [{ type: 'text', text: value.join('\n') || 'No live sessions.' }],
+        },
+        async execute() {
+            return messaging.list().map(String);
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: 'session_send',
+        description: 'Send a message to another live DeepSeek Harness session in this process.',
+        parameters: {
+            to: { type: 'string', required: true, description: 'Target session id from session_list.' },
+            text: { type: 'string', required: true, description: 'Message text.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    messageId: { type: 'string', required: true },
+                    from: { type: 'string', required: true },
+                    to: { type: 'string', required: true },
+                    delivered: { type: 'boolean', required: true },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: `Delivered ${value.messageId} to ${value.to}.` }],
+        },
+        async execute(args, exec) {
+            if (!exec.agent)
+                throw new Error('session_send requires an owning agent');
+            if (args.text.trim() === '')
+                throw new Error('text must not be empty');
+            return messaging.send(exec.agent, SessionId(args.to), args.text);
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: 'session_messages',
+        description: 'Read messages delivered to the current session in this process.',
+        parameters: {
+            limit: { type: 'number', description: 'Maximum number of messages, default 20.' },
+        },
+        output: {
+            schema: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        id: { type: 'string', required: true },
+                        from: { type: 'string', required: true },
+                        to: { type: 'string', required: true },
+                        text: { type: 'string', required: true },
+                        createdAt: { type: 'number', required: true },
+                        delivered: { type: 'boolean', required: true },
+                    },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: value.map(message => `[${message.from}] ${message.text}`).join('\n') || 'No messages.' }],
+        },
+        async execute(args, exec) {
+            if (!exec.agent)
+                throw new Error('session_messages requires an owning agent');
+            const limit = args.limit === undefined ? 20 : Math.max(1, Math.min(100, Math.floor(args.limit)));
+            return [...messaging.receive(exec.agent.session.id, limit)];
+        },
+    }));
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "dsh-bridge",
+  "description": "Local session messaging and event bridge for DeepSeek Harness",
+  "version": "0.1.0-rc.5",
+  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baixianger/dsh-bridge.git"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "files": ["lib/index.js", "lib/types/**/*.js", "lib/types/**/*.d.ts", "cordis.patch.yml", "README.md"],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-agent": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-session": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.5"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-agent": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-session": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.5"
+  }
+}