@mnemoverse/mcp-memory-server 0.11.0 → 0.12.1

package/dist/shared.js

@@ -23,8 +23,28 @@
  * `apiFetch` is the server's own way to reach the API (credential, base URL,
  * transport). Its contract is on the `ApiFetch` type: reject with `ApiError`,
  * `NetworkError` or `UnreadableBodyError`, because the tools branch on which.
+ *
+ * `MAX_RESULT_CHARS` and `capResult` are the tool-result size cap and the
+ * helper that applies it: 96,000 characters (24,000 tokens), the one bound
+ * both servers use for a tool result's text (`structuredContent` is not
+ * capped, OD-11). ADR-025 makes this the single source of truth for the
+ * number; the hosted connector still keeps its own 25,000-character literal
+ * (`src/constants.ts`) and adopts this export in its place at a later step,
+ * not yet done as of this release. `capResult` truncates on a code-point
+ * boundary (never inside a UTF-16 surrogate pair) and appends the truncation notice, so a consumer does
+ * not have to re-implement a `slice` that can cut a surrogate pair.
+ *
+ * `MemoryToolDeps.wording` and `.writeAuthor` (STEP4-2/3/5, owner
+ * 2026-09-24) are how a SECOND server registering these tools (the hosted
+ * connector is the first consumer) speaks in its own voice: `wording`
+ * swaps "this server" for "this connector" in the three descriptions that
+ * name it and, under `auth: "oauth"`, rewords every 401/403 explanation for
+ * a user who never sees an API key; `writeAuthor` lets a supplier vouch for
+ * the end user behind a write (core: `_get_provenance`, honoured only for a
+ * SERVICE/supplier caller). Both are optional, and absent, reproduce this
+ * package's existing behaviour exactly. Full contract: docs/shared.md.
  */
-export { registerMemoryTools } from "./tools.js";
+export { registerMemoryTools, MAX_RESULT_CHARS, capResult, } from "./tools.js";
 export { registerMemoryPrompts } from "./prompts.js";
 export { registerMemoryResources } from "./resources.js";
 export { SERVER_INSTRUCTIONS } from "./teaching.js";

package/dist/shared.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared.js","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,mBAAmB,EAAsC,MAAM,YAAY,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,mBAAmB,GAIpB,MAAM,aAAa,CAAC"}
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,SAAS,GAGV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,mBAAmB,GAKpB,MAAM,aAAa,CAAC"}

package/dist/tools.d.ts

@@ -12,6 +12,8 @@
  * or the environment.
  */
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type WriteAuthor } from "./requests.js";
+import { type Wording } from "./errors.js";
 /**
  * How the tools reach the Mnemoverse API: send `path` (relative to the API base,
  * e.g. "/memory/read") and resolve to the parsed JSON body.
@@ -24,10 +26,71 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
  * src/errors.ts. `options.signal` must be honoured.
  */
 export type ApiFetch = <T = unknown>(path: string, options?: RequestInit) => Promise<T>;
-/** What a server supplies when it registers the memory tools. */
+/**
+ * `deps.apiFetch` with `deps.wording` applied to what it throws (STEP4-2):
+ * every rejection passes through {@link rewordFailure}, so an `ApiError`,
+ * `NetworkError` or `UnreadableBodyError` the consumer built with no
+ * `wording` (or with a different one) reaches the model explained under the
+ * wording this registration was given. Results and every other rejection
+ * pass through untouched. Installed only when `wording` is supplied at all:
+ * the stdio server supplies none, and its `apiFetch` is used exactly as
+ * before.
+ */
+export declare function wordedApiFetch(inner: ApiFetch, wording: Wording): ApiFetch;
+/**
+ * What a server supplies when it registers the memory tools.
+ *
+ * `wording` and `writeAuthor` (STEP4-2/3/5, owner decisions 2026-09-24) are
+ * both optional, and both default to exactly this server's own behaviour: a
+ * consumer that supplies neither gets byte-identical descriptions, error
+ * text and write bodies to every release before this one. They exist for a
+ * SECOND server registering these same tools (the hosted connector,
+ * ADR-025) that needs to say "this connector" instead of "this server",
+ * speak to an OAuth user who never sees an API key, and vouch for the
+ * end user it is writing on behalf of.
+ */
 export interface MemoryToolDeps {
     apiFetch: ApiFetch;
+    /** How this registration wants its own tool descriptions and error
+     *  explanations worded. See {@link Wording} for each field. Read at
+     *  registration time for the three descriptions that name the server,
+     *  and applied to every `ApiError`/`NetworkError`/`UnreadableBodyError`
+     *  the consumer's `apiFetch` rejects with (see {@link wordedApiFetch}),
+     *  so the consumer states it once, here. Passing the same value to the
+     *  error constructors inside `apiFetch` is allowed and changes nothing. */
+    wording?: Wording;
+    /**
+     * Supplier-vouched authorship for `memory_write` (STEP4-5). Called once
+     * per write, with no arguments; a returned value is sent as the request
+     * body's `author` field EXACTLY as returned (this package applies no
+     * normalisation beyond a `typeof` guard; core re-normalises server-side,
+     * see {@link WriteAuthor}). Returning `undefined`, or omitting this
+     * dependency entirely, sends the body this package has always sent: the
+     * stdio server's own requests are exactly this case, and do not change.
+     *
+     * Core honours `author` ONLY for a SERVICE/supplier caller and IGNORES it
+     * for an OIDC end-user (mnemoverse-core src/mnemo/api/routes.py:211-276,
+     * `_get_provenance`, verified 2026-09-24), so this dependency is useful
+     * only to a server that authenticates to core as a supplier vouching for
+     * someone else, not to an end-user's own key.
+     */
+    writeAuthor?: () => WriteAuthor | undefined;
 }
+export declare const MAX_RESULT_CHARS: number;
+/**
+ * Truncate a result string to MAX_RESULT_CHARS, appending a notice if truncated.
+ * Required by Claude Connectors Directory submission policy.
+ *
+ * Defensive against splitting UTF-16 surrogate pairs: if the character right
+ * before the cut point is a high surrogate (U+D800–U+DBFF), drop it so the
+ * result stays well-formed. Otherwise an emoji or non-BMP character at the
+ * boundary can produce a lone surrogate and corrupt downstream JSON encoding.
+ *
+ * Exported (re-exported from ./shared) so a consumer applying MAX_RESULT_CHARS
+ * to its own tool results does not have to re-implement this code-point-safe
+ * truncation as a plain `slice`, which can cut a surrogate pair.
+ */
+export declare function capResult(text: string, moreHint?: string): string;
 /**
  * The sentence behind {@link unreadableAnswerReply}, exported so the memory
  * resource (src/resources.ts) says the same thing about an unreadable answer