@dcrays/mbh-memory 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @dcrays/mbh-memory
+
+书灵墨宝的 DSH 云端记忆接入插件。加载后注册 `get_memory` 与 `set_memory`，把模型工具映射到配置的 HTTP API；插件本身不持久化记忆。
+
+本包对应 `mbh-memory` 环境。API 地址由 Cordis 插件配置下发，不读取 `.env`。

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+- insert:
+    - id: mbh-memory
+      name: '@dcrays/mbh-memory'
+      config:
+        enabled: true
+        baseUrl: ""

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@dcrays/mbh-memory",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness memory plugin for Mobook (production)",
+  "type": "module",
+  "main": "plugin/index.js",
+  "types": "plugin/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./plugin/index.d.ts",
+      "default": "./plugin/index.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "plugin/**",
+    "src/**",
+    "cordis.patch.yml",
+    "README.md",
+    "!**/*.map"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-tools": "^0.1.2-rc.1",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/plugin/index.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type MemoryApiValue } from '../src/index.js';
+export { DEFAULT_BUILD_ENV } from '../src/config/env-config.js';
+export declare const name = "mbh-memory";
+export declare const inject: string[];
+export interface Config {
+    enabled: boolean;
+    baseUrl: string;
+    authorizationToken: string;
+    timeoutMs: number;
+    maxMemoryChars: number;
+    maxResponseBytes: number;
+}
+export declare const Config: z<Config>;
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        mbhMemory: MbhMemoryService;
+    }
+}
+export declare class MbhMemoryService extends Service {
+    private readonly config;
+    private readonly operations;
+    constructor(ctx: Context, config: Config);
+    isEnabled(): boolean;
+    isConfigured(): boolean;
+    getMemory(signal?: AbortSignal): Promise<MemoryApiValue>;
+    setMemory(memory: string, signal?: AbortSignal): Promise<MemoryApiValue>;
+}
+export declare function apply(ctx: Context, config: Config): void;

package/plugin/index.js

@@ -0,0 +1,264 @@
+import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
+
+// dist-npm/plugin/index.js
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+// dist-npm/src/api-client.js
+var MemoryApiError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "MemoryApiError";
+  }
+};
+function endpoint(baseUrl, name2) {
+  let base;
+  try {
+    base = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+  } catch (error) {
+    throw new MemoryApiError("INVALID_CONFIG", "mbh-memory API baseUrl is invalid", { cause: error });
+  }
+  if (base.protocol !== "http:" && base.protocol !== "https:") {
+    throw new MemoryApiError("INVALID_CONFIG", "mbh-memory API baseUrl must use http or https");
+  }
+  return new URL(name2, base);
+}
+function requestSignal(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+async function responseText(response, maxBytes) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new MemoryApiError("RESPONSE_TOO_LARGE", `mbh-memory API response exceeds ${maxBytes} bytes`);
+  }
+  if (!response.body)
+    return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let size = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const item = await reader.read();
+      if (item.done)
+        break;
+      size += item.value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new MemoryApiError("RESPONSE_TOO_LARGE", `mbh-memory API response exceeds ${maxBytes} bytes`);
+      }
+      text += decoder.decode(item.value, { stream: true });
+    }
+    return text + decoder.decode();
+  } finally {
+    reader.releaseLock();
+  }
+}
+function jsonValue(text) {
+  if (!text.trim())
+    return { ok: true };
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new MemoryApiError("INVALID_RESPONSE", "mbh-memory API returned invalid JSON", { cause: error });
+  }
+}
+var MemoryApiClient = class {
+  config;
+  fetchImpl;
+  getUrl;
+  setUrl;
+  constructor(config, fetchImpl = fetch) {
+    this.config = config;
+    this.fetchImpl = fetchImpl;
+    if (!Number.isSafeInteger(config.timeoutMs) || config.timeoutMs <= 0) {
+      throw new MemoryApiError("INVALID_CONFIG", "mbh-memory timeoutMs must be a positive integer");
+    }
+    if (!Number.isSafeInteger(config.maxMemoryChars) || config.maxMemoryChars <= 0) {
+      throw new MemoryApiError("INVALID_CONFIG", "mbh-memory maxMemoryChars must be a positive integer");
+    }
+    if (!Number.isSafeInteger(config.maxResponseBytes) || config.maxResponseBytes <= 0) {
+      throw new MemoryApiError("INVALID_CONFIG", "mbh-memory maxResponseBytes must be a positive integer");
+    }
+    this.getUrl = endpoint(config.baseUrl, "get_memory");
+    this.setUrl = endpoint(config.baseUrl, "set_memory");
+  }
+  getMemory(signal) {
+    return this.request(this.getUrl, {}, signal);
+  }
+  async setMemory(memory, signal) {
+    if (!memory.trim())
+      throw new MemoryApiError("INVALID_MEMORY", "memory must not be empty");
+    if (memory.length > this.config.maxMemoryChars) {
+      throw new MemoryApiError("INVALID_MEMORY", `memory exceeds ${this.config.maxMemoryChars} characters`);
+    }
+    return this.request(this.setUrl, { memory }, signal);
+  }
+  async request(url, body, signal) {
+    const headers = {
+      accept: "application/json",
+      "content-type": "application/json"
+    };
+    const token = this.config.authorizationToken?.trim();
+    if (token)
+      headers.authorization = `Bearer ${token}`;
+    const effectiveSignal = requestSignal(signal, this.config.timeoutMs);
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: effectiveSignal
+      });
+    } catch (error) {
+      if (signal?.aborted)
+        throw error;
+      if (effectiveSignal.aborted) {
+        throw new MemoryApiError("TIMEOUT", `mbh-memory API request timed out after ${this.config.timeoutMs}ms`, {
+          cause: error
+        });
+      }
+      throw new MemoryApiError("NETWORK_ERROR", "mbh-memory API request failed", { cause: error });
+    }
+    const text = await responseText(response, this.config.maxResponseBytes);
+    if (!response.ok) {
+      throw new MemoryApiError("HTTP_ERROR", `mbh-memory API request failed with HTTP ${response.status}`);
+    }
+    return jsonValue(text);
+  }
+};
+
+// dist-npm/src/tools.js
+import { defineTool } from "@deepseek-ai/dsh-tools";
+function render(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function createMemoryTools(memory) {
+  const getMemory = defineTool({
+    name: "get_memory",
+    description: "Read the user's long-term memory from the configured Mobook memory API. Use it only when prior preferences, facts, or experience are relevant to the current request.",
+    parameters: {},
+    output: {
+      schema: { type: "json" },
+      render: (_args, value) => [{ type: "text", text: render(value) }]
+    },
+    async execute(_args, exec) {
+      return memory.getMemory(exec.signal);
+    }
+  });
+  const setMemory = defineTool({
+    name: "set_memory",
+    description: "Write one durable memory through the configured Mobook memory API. Use this when the user explicitly asks you to remember something useful for future conversations. Never store passwords, access tokens, API keys, or other secrets.",
+    parameters: {
+      memory: {
+        type: "string",
+        required: true,
+        description: "A concise, self-contained fact, preference, rule, or reusable experience to remember."
+      }
+    },
+    output: {
+      schema: { type: "json" },
+      render: (_args, value) => [{ type: "text", text: render(value) }]
+    },
+    async execute(args, exec) {
+      return memory.setMemory(args.memory, exec.signal);
+    }
+  });
+  return [getMemory, setMemory];
+}
+
+// dist-npm/src/index.js
+var MBH_MEMORY_SERVICE_KEY = "mbhMemory";
+
+// dist-npm/src/config/env-config.js
+var ENV_CONFIG = {
+  production: {
+    packageName: "@dcrays/mbh-memory",
+    channelId: "mbh-memory"
+  },
+  test: {
+    packageName: "@dcrays/mbh-memory-test",
+    channelId: "mbh-memory-test"
+  },
+  uat: {
+    packageName: "@dcrays/mbh-memory-uat",
+    channelId: "mbh-memory-uat"
+  }
+};
+var DEFAULT_BUILD_ENV = "production";
+var CONFIG_CHANNEL_ID = ENV_CONFIG[DEFAULT_BUILD_ENV].channelId;
+var CONFIG_PLUGIN_PATH = `plugins.${CONFIG_CHANNEL_ID}`;
+
+// dist-npm/plugin/index.js
+var name = "@dcrays/mbh-memory";
+var inject = ["tools"];
+var Config = z.object({
+  enabled: z.boolean().default(true),
+  baseUrl: z.string().default(""),
+  authorizationToken: z.string().role("secret").default(""),
+  timeoutMs: z.natural().min(1).default(1e4),
+  maxMemoryChars: z.natural().min(1).default(2e4),
+  maxResponseBytes: z.natural().min(1).default(128 * 1024)
+});
+var MbhMemoryService = class extends Service {
+  config;
+  operations;
+  constructor(ctx, config) {
+    super(ctx, MBH_MEMORY_SERVICE_KEY);
+    this.config = config;
+    this.operations = config.enabled && config.baseUrl.trim() ? new MemoryApiClient({
+      baseUrl: config.baseUrl.trim(),
+      ...config.authorizationToken.trim() ? { authorizationToken: config.authorizationToken.trim() } : {},
+      timeoutMs: config.timeoutMs,
+      maxMemoryChars: config.maxMemoryChars,
+      maxResponseBytes: config.maxResponseBytes
+    }) : void 0;
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  isConfigured() {
+    return this.operations !== void 0;
+  }
+  getMemory(signal) {
+    if (!this.operations)
+      return Promise.reject(new Error("mbh-memory API is not configured"));
+    return this.operations.getMemory(signal);
+  }
+  setMemory(memory, signal) {
+    if (!this.operations)
+      return Promise.reject(new Error("mbh-memory API is not configured"));
+    return this.operations.setMemory(memory, signal);
+  }
+};
+function apply(ctx, config) {
+  const service = new MbhMemoryService(ctx, config);
+  ctx.effect(() => {
+    const logger = ctx.logger(name);
+    if (!service.isEnabled())
+      return () => void 0;
+    if (!service.isConfigured()) {
+      logger.info("%s plugin loaded without an API baseUrl; memory tools are unavailable", name);
+      return () => void 0;
+    }
+    const unregister = createMemoryTools(service).map((tool) => ctx.tools.register(tool));
+    logger.info("%s plugin loaded with get_memory and set_memory tools", name);
+    return () => {
+      for (const dispose of unregister.reverse())
+        dispose();
+    };
+  }, `${name} lifecycle`);
+}
+export {
+  Config,
+  DEFAULT_BUILD_ENV,
+  MbhMemoryService,
+  apply,
+  inject,
+  name
+};

package/src/api-client.d.ts

@@ -0,0 +1,30 @@
+export interface MemoryApiClientConfig {
+    baseUrl: string;
+    authorizationToken?: string;
+    timeoutMs: number;
+    maxMemoryChars: number;
+    maxResponseBytes: number;
+}
+export type MemoryApiValue = null | boolean | number | string | MemoryApiValue[] | {
+    [key: string]: MemoryApiValue;
+};
+export interface MemoryOperations {
+    getMemory(signal?: AbortSignal): Promise<MemoryApiValue>;
+    setMemory(memory: string, signal?: AbortSignal): Promise<MemoryApiValue>;
+}
+export declare class MemoryApiError extends Error {
+    readonly code: 'INVALID_CONFIG' | 'INVALID_MEMORY' | 'HTTP_ERROR' | 'INVALID_RESPONSE' | 'RESPONSE_TOO_LARGE' | 'NETWORK_ERROR' | 'TIMEOUT';
+    constructor(code: 'INVALID_CONFIG' | 'INVALID_MEMORY' | 'HTTP_ERROR' | 'INVALID_RESPONSE' | 'RESPONSE_TOO_LARGE' | 'NETWORK_ERROR' | 'TIMEOUT', message: string, options?: ErrorOptions);
+}
+type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare class MemoryApiClient implements MemoryOperations {
+    private readonly config;
+    private readonly fetchImpl;
+    private readonly getUrl;
+    private readonly setUrl;
+    constructor(config: MemoryApiClientConfig, fetchImpl?: Fetch);
+    getMemory(signal?: AbortSignal): Promise<MemoryApiValue>;
+    setMemory(memory: string, signal?: AbortSignal): Promise<MemoryApiValue>;
+    private request;
+}
+export {};

package/src/api-client.js

@@ -0,0 +1,131 @@
+export class MemoryApiError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'MemoryApiError';
+    }
+}
+function endpoint(baseUrl, name) {
+    let base;
+    try {
+        base = new URL(baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+    }
+    catch (error) {
+        throw new MemoryApiError('INVALID_CONFIG', 'mbh-memory API baseUrl is invalid', { cause: error });
+    }
+    if (base.protocol !== 'http:' && base.protocol !== 'https:') {
+        throw new MemoryApiError('INVALID_CONFIG', 'mbh-memory API baseUrl must use http or https');
+    }
+    return new URL(name, base);
+}
+function requestSignal(signal, timeoutMs) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+async function responseText(response, maxBytes) {
+    const declared = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new MemoryApiError('RESPONSE_TOO_LARGE', `mbh-memory API response exceeds ${maxBytes} bytes`);
+    }
+    if (!response.body)
+        return '';
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = '';
+    try {
+        for (;;) {
+            const item = await reader.read();
+            if (item.done)
+                break;
+            size += item.value.byteLength;
+            if (size > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                throw new MemoryApiError('RESPONSE_TOO_LARGE', `mbh-memory API response exceeds ${maxBytes} bytes`);
+            }
+            text += decoder.decode(item.value, { stream: true });
+        }
+        return text + decoder.decode();
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function jsonValue(text) {
+    if (!text.trim())
+        return { ok: true };
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new MemoryApiError('INVALID_RESPONSE', 'mbh-memory API returned invalid JSON', { cause: error });
+    }
+}
+export class MemoryApiClient {
+    config;
+    fetchImpl;
+    getUrl;
+    setUrl;
+    constructor(config, fetchImpl = fetch) {
+        this.config = config;
+        this.fetchImpl = fetchImpl;
+        if (!Number.isSafeInteger(config.timeoutMs) || config.timeoutMs <= 0) {
+            throw new MemoryApiError('INVALID_CONFIG', 'mbh-memory timeoutMs must be a positive integer');
+        }
+        if (!Number.isSafeInteger(config.maxMemoryChars) || config.maxMemoryChars <= 0) {
+            throw new MemoryApiError('INVALID_CONFIG', 'mbh-memory maxMemoryChars must be a positive integer');
+        }
+        if (!Number.isSafeInteger(config.maxResponseBytes) || config.maxResponseBytes <= 0) {
+            throw new MemoryApiError('INVALID_CONFIG', 'mbh-memory maxResponseBytes must be a positive integer');
+        }
+        this.getUrl = endpoint(config.baseUrl, 'get_memory');
+        this.setUrl = endpoint(config.baseUrl, 'set_memory');
+    }
+    getMemory(signal) {
+        return this.request(this.getUrl, {}, signal);
+    }
+    async setMemory(memory, signal) {
+        if (!memory.trim())
+            throw new MemoryApiError('INVALID_MEMORY', 'memory must not be empty');
+        if (memory.length > this.config.maxMemoryChars) {
+            throw new MemoryApiError('INVALID_MEMORY', `memory exceeds ${this.config.maxMemoryChars} characters`);
+        }
+        return this.request(this.setUrl, { memory }, signal);
+    }
+    async request(url, body, signal) {
+        const headers = {
+            accept: 'application/json',
+            'content-type': 'application/json'
+        };
+        const token = this.config.authorizationToken?.trim();
+        if (token)
+            headers.authorization = `Bearer ${token}`;
+        const effectiveSignal = requestSignal(signal, this.config.timeoutMs);
+        let response;
+        try {
+            response = await this.fetchImpl(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: effectiveSignal
+            });
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            if (effectiveSignal.aborted) {
+                throw new MemoryApiError('TIMEOUT', `mbh-memory API request timed out after ${this.config.timeoutMs}ms`, {
+                    cause: error
+                });
+            }
+            throw new MemoryApiError('NETWORK_ERROR', 'mbh-memory API request failed', { cause: error });
+        }
+        const text = await responseText(response, this.config.maxResponseBytes);
+        if (!response.ok) {
+            throw new MemoryApiError('HTTP_ERROR', `mbh-memory API request failed with HTTP ${response.status}`);
+        }
+        return jsonValue(text);
+    }
+}

package/src/config/env-config.d.ts

@@ -0,0 +1,9 @@
+export type BuildEnv = 'production' | 'test' | 'uat';
+export interface EnvConfig {
+    packageName: string;
+    channelId: string;
+}
+export declare const ENV_CONFIG: Record<BuildEnv, EnvConfig>;
+export declare const DEFAULT_BUILD_ENV: BuildEnv;
+export declare const CONFIG_CHANNEL_ID: string;
+export declare const CONFIG_PLUGIN_PATH: `plugins.${string}`;

package/src/config/env-config.js

@@ -0,0 +1,17 @@
+export const ENV_CONFIG = {
+    production: {
+        packageName: '@dcrays/mbh-memory',
+        channelId: 'mbh-memory'
+    },
+    test: {
+        packageName: '@dcrays/mbh-memory-test',
+        channelId: 'mbh-memory-test'
+    },
+    uat: {
+        packageName: '@dcrays/mbh-memory-uat',
+        channelId: 'mbh-memory-uat'
+    }
+};
+export const DEFAULT_BUILD_ENV = 'production';
+export const CONFIG_CHANNEL_ID = ENV_CONFIG[DEFAULT_BUILD_ENV].channelId;
+export const CONFIG_PLUGIN_PATH = `plugins.${CONFIG_CHANNEL_ID}`;

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export declare const MBH_MEMORY_PLUGIN_NAME = "mbh-memory";
+export declare const MBH_MEMORY_SERVICE_KEY = "mbhMemory";
+export * from './api-client.js';
+export * from './tools.js';

package/src/index.js

@@ -0,0 +1,4 @@
+export const MBH_MEMORY_PLUGIN_NAME = 'mbh-memory';
+export const MBH_MEMORY_SERVICE_KEY = 'mbhMemory';
+export * from './api-client.js';
+export * from './tools.js';

package/src/tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { MemoryOperations } from './api-client.js';
+export declare function createMemoryTools(memory: MemoryOperations): [ToolDefinition, ToolDefinition];

package/src/tools.js

@@ -0,0 +1,37 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+function render(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+export function createMemoryTools(memory) {
+    const getMemory = defineTool({
+        name: 'get_memory',
+        description: "Read the user's long-term memory from the configured Mobook memory API. Use it only when prior preferences, facts, or experience are relevant to the current request.",
+        parameters: {},
+        output: {
+            schema: { type: 'json' },
+            render: (_args, value) => [{ type: 'text', text: render(value) }]
+        },
+        async execute(_args, exec) {
+            return memory.getMemory(exec.signal);
+        }
+    });
+    const setMemory = defineTool({
+        name: 'set_memory',
+        description: 'Write one durable memory through the configured Mobook memory API. Use this when the user explicitly asks you to remember something useful for future conversations. Never store passwords, access tokens, API keys, or other secrets.',
+        parameters: {
+            memory: {
+                type: 'string',
+                required: true,
+                description: 'A concise, self-contained fact, preference, rule, or reusable experience to remember.'
+            }
+        },
+        output: {
+            schema: { type: 'json' },
+            render: (_args, value) => [{ type: 'text', text: render(value) }]
+        },
+        async execute(args, exec) {
+            return memory.setMemory(args.memory, exec.signal);
+        }
+    });
+    return [getMemory, setMemory];
+}