bantamkit-mcp 0.26.0

package/dist/mcp/pyargs.js

@@ -0,0 +1,362 @@
+/**
+ * Argument validation, in the reference runtime's own words.
+ *
+ * WHY THIS IS REPRODUCED RATHER THAN RULED. The text below is not a diagnostic in a log —
+ * it is the `content[0].text` of a tool result, which means the MODEL reads it and decides
+ * what to do next. `zod`'s wording is entirely different, so a port that let zod speak would
+ * ship a server whose recovery behaviour differs from the reference's on every mistyped
+ * argument, and that is a product difference, not a cosmetic one.
+ *
+ * WHAT THE URL IS. `https://errors.pydantic.dev/2.13/v/<type>` names an entry in pydantic's
+ * public error catalogue. This runtime has no pydantic; the URL is part of the sentence the
+ * reference emits, reproduced because the sentence is the contract. `2.13` is therefore a
+ * PIN on the reference, not a claim about this process — and it is compared against the
+ * live server by `tools/conformance/suites/wire.mjs`, so the day the Python side bumps to
+ * 2.14 the suite goes red here instead of the two runtimes drifting apart quietly.
+ *
+ * EVERY RULE BELOW WAS MEASURED, not read off pydantic's documentation. The probes are in
+ * `scratchpad/job38-n7/probe{4,7,8,9}.py` and each drove the real stdio server:
+ *
+ *   * errors come in MODEL FIELD order, not in the order the arguments arrived (probe7 id 80
+ *     sends `body, name, description, type` and gets `type` before `name`);
+ *   * `int` is LAX — `True`, `'2'`, `'  3  '`, `'2_0'`, `'+2'` and `3.0` all validate, while
+ *     `'2.5'`, `'1e3'`, `'0x10'` and `''` are `int_parsing` and `2.5` is `int_from_float`;
+ *   * a float too large for an i64 is `int_parsing_size`, with a DIFFERENT message shape
+ *     (no "Input should be a valid integer," prefix);
+ *   * `input_value` is truncated on the UTF-8 BYTE length of `repr(value)`: over 50 bytes it
+ *     becomes head-25-bytes + `...` + tail-24-bytes, each end floored to a character
+ *     boundary. Thirty Thai characters are 34 repr CHARACTERS and are still truncated.
+ */
+import { reprValue } from '../pyjson.js';
+const req = (name, kind) => ({ name, kind, optional: false });
+const opt = (name, kind, bound = {}) => ({
+    name,
+    kind,
+    optional: true,
+    ...bound,
+});
+/**
+ * `assets/tools/bantamkit_read.json` `offset.maximum` — `Number.MAX_SAFE_INTEGER`, the
+ * largest integer `JSON.parse` reads back unchanged (F1). The reference binds it as
+ * `Annotated[int, Field(le=OFFSET_MAXIMUM)]`, so above it the refusal is pydantic's
+ * `less_than_equal` frame and the handler never runs; this side reads the JSON with its
+ * own decoder, so `9007199254740993` arrives exact and is refused with the same text.
+ */
+const OFFSET_MAXIMUM = 9007199254740991n;
+/**
+ * One model per handler, mirroring `build_server`'s closures signature for signature.
+ *
+ * `build_identity`'s model is `build_identity_toolArguments` and not `build_identityArguments`
+ * — pydantic names it after the PYTHON FUNCTION, and the function is the closure
+ * `build_identity_tool`. The same leak is already in the shipped manifest
+ * (`output_schema.title` is `build_identity_toolDictOutput`), so the name is not an accident
+ * this port gets to tidy: it is on the wire today, and a client that pinned it would break.
+ *
+ * MEASURED SURVIVOR, AND IT STAYS. A mutation changing this one string to
+ * `build_identityArguments` survives both gates, because `build_identity` has no parameters
+ * and a model with no fields can never fail — the name is unreachable from the wire. It is
+ * still spelled correctly: the day the tool grows an argument, the sweep's kill comes for
+ * free, and a name that was wrong until then would be a defect nobody planted. The leak that
+ * IS observable is the manifest's `output_schema.title`, and that one is compared byte for
+ * byte by the conformance suite's `advertisement: id 2` case.
+ */
+export const ARG_MODELS = {
+    memory_save: {
+        model: 'memory_saveArguments',
+        fields: [req('type', 'str'), req('name', 'str'), req('description', 'str'), req('body', 'str'), opt('links', 'listStr')],
+    },
+    memory_recall: { model: 'memory_recallArguments', fields: [req('query', 'str'), opt('k', 'int')] },
+    validate_json: { model: 'validate_jsonArguments', fields: [req('output', 'str'), req('schema', 'dict')] },
+    shiftwork_clock_in: { model: 'shiftwork_clock_inArguments', fields: [req('checkpoint', 'str')] },
+    shiftwork_clock_out: {
+        model: 'shiftwork_clock_outArguments',
+        fields: [
+            req('checkpoint', 'str'),
+            req('unit_id', 'str'),
+            req('status', 'str'),
+            req('handoff_patch', 'dict'),
+            req('history_entry', 'dict'),
+            opt('accounting', 'dict'),
+        ],
+    },
+    shiftwork_status: { model: 'shiftwork_statusArguments', fields: [req('checkpoint', 'str')] },
+    build_identity: { model: 'build_identity_toolArguments', fields: [] },
+    // `bantamkit_statusArguments`, not `bantamkit_status_toolArguments`: the model name is
+    // pydantic's, derived from the reference's CLOSURE name, and the status handler is called
+    // `bantamkit_status` there where the identity one is called `build_identity_tool`. It is
+    // the title `assets/tools/bantamkit_status.json` already advertises.
+    bantamkit_status: { model: 'bantamkit_statusArguments', fields: [] },
+    // `reserve: int | None = None` on the reference, so it is the same lax `int` as `k`:
+    // `'2'`, `True` and `3.0` validate, `'2.5'` is `int_parsing`, `2.5` is `int_from_float`,
+    // and an explicit `null` is the default. The manifest's `minimum: 0` is advisory to the
+    // client; nothing here floors it — a negative value reaches `MemoryStore.compact`, whose
+    // `max(0, min(reserve, budget // 2))` is the only clamp on either side (6b966e5).
+    memory_compact: { model: 'memory_compactArguments', fields: [opt('reserve', 'int')] },
+    // `bantamkit_read(path: str, part: str | None = None, offset: int | None = None,
+    // limit: int | None = None)` on the reference (job43). `path` and `part` are the strict
+    // `str` every other string field is — `123` is `string_type`, measured for `memory_save`
+    // and the same validator. `offset` and `limit` are the lax `int` that `k` and `reserve`
+    // are: `'2'`, `True` and `3.0` validate, `'2.5'` is `int_parsing`, `2.5` is
+    // `int_from_float`, and an explicit `null` is the default. The manifest's `minimum` and
+    // `maximum` are advisory to the client for `limit` and for `offset`'s floor; the handler
+    // clamps `limit` to `[1, 200]` and `offset` to `>= 0` itself, the way `memory_recall`
+    // clamps `k`. `offset`'s CEILING is bound in the model, as it is on the reference (F2).
+    bantamkit_read: {
+        model: 'bantamkit_readArguments',
+        fields: [req('path', 'str'), opt('part', 'str'), opt('offset', 'int', { le: OFFSET_MAXIMUM }), opt('limit', 'int')],
+    },
+    // `skill_audit(root: str, enabled: list[str] | None = None, usage: dict[str, int] | None =
+    // None, check: str | None = None, budget: int | None = None)` on the reference (job44).
+    // `usage` is the only `dict[str, int]` on the surface and the reason `dictInt` exists:
+    // pydantic validates a typed dict's VALUES, so `{'a': 'x'}` is `usage.a` / `int_parsing`
+    // where `handoff_patch`'s `dict[str, Any]` takes anything. `budget` carries no `le`,
+    // because the reference binds none — the manifest's `maximum` is advisory to the client,
+    // and the handler's own refusal is the negative one. `versions` is the only
+    // `dict[str, str]`, and the reason `dictStr` exists beside it: a `str` field is STRICT even
+    // in lax mode, so `{'a': 1}` is `versions.a` / `string_type` where the same value under
+    // `usage` would validate.
+    skill_audit: {
+        model: 'skill_auditArguments',
+        fields: [
+            req('root', 'str'),
+            opt('enabled', 'listStr'),
+            opt('usage', 'dictInt'),
+            opt('check', 'str'),
+            opt('budget', 'int'),
+            opt('versions', 'dictStr'),
+        ],
+    },
+};
+/** `type(value).__name__`, for the `input_type=` half of the sentence. */
+function pyTypeName(value) {
+    switch (value.t) {
+        case 'null':
+            return 'NoneType';
+        case 'bool':
+            return 'bool';
+        case 'int':
+            return 'int';
+        case 'float':
+            return 'float';
+        case 'str':
+            return 'str';
+        case 'list':
+            return 'list';
+        case 'dict':
+            return 'dict';
+    }
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8');
+/**
+ * pydantic-core's `truncate_input_value`: 50 UTF-8 bytes, then `head[..25] + "..." + tail[24..]`
+ * with both cuts moved off a multi-byte character rather than splitting one.
+ *
+ * The floor at each end is what makes 30 Thai characters render as 7 + `...` + 7 instead of
+ * 8 + `...` + 8 — measured, probe8 case 104.
+ */
+function truncateRepr(text) {
+    const bytes = encoder.encode(text);
+    if (bytes.length <= 50)
+        return text;
+    let head = 25;
+    while (head > 0 && (bytes[head] & 0xc0) === 0x80)
+        head -= 1;
+    let tail = bytes.length - 24;
+    while (tail < bytes.length && (bytes[tail] & 0xc0) === 0x80)
+        tail += 1;
+    return `${decoder.decode(bytes.slice(0, head))}...${decoder.decode(bytes.slice(tail))}`;
+}
+/** i64, which is the width pydantic parses an int into before it complains about size. */
+const I64_MAX = 9223372036854775807n;
+const I64_MIN = -9223372036854775808n;
+/** `int(text)` as Python accepts it: optional sign, underscores between digits. */
+const PY_INT_TEXT = /^[+-]?\d+(?:_\d+)*$/;
+/** …and pydantic additionally accepts a trailing `.0`-style fraction that is all zeros. */
+const PY_INT_DECIMAL_TEXT = /^([+-]?\d+(?:_\d+)*)\.0+$/;
+/**
+ * Validate one field, returning either the coerced value or the error pydantic reports.
+ *
+ * Lax mode, which is pydantic's default and therefore the reference's: `bool` IS an `int`
+ * here, and a string that spells an integer IS one. Only `str` is strict, because pydantic
+ * refuses every non-`str` for a `str` field even in lax mode (measured: `123` -> string_type).
+ */
+function checkField(spec, value) {
+    if (spec.optional && value.t === 'null')
+        return { value };
+    switch (spec.kind) {
+        case 'str':
+            if (value.t === 'str')
+                return { value };
+            return [{ loc: spec.name, type: 'string_type', msg: 'Input should be a valid string', input: value }];
+        case 'dict':
+            if (value.t === 'dict')
+                return { value };
+            return [{ loc: spec.name, type: 'dict_type', msg: 'Input should be a valid dictionary', input: value }];
+        case 'dictStr': {
+            // `dict[str, str]`. The same shape as `dictInt` next door, with the STRICT `str`
+            // validator on the values: one error per bad entry, in the dict's own order, with the
+            // KEY in the location — `versions.a`, never `versions.0`.
+            if (value.t !== 'dict') {
+                return [{ loc: spec.name, type: 'dict_type', msg: 'Input should be a valid dictionary', input: value }];
+            }
+            const bad = [];
+            for (const [key, item] of value.v) {
+                if (item.t !== 'str') {
+                    bad.push({
+                        loc: `${spec.name}.${key}`,
+                        type: 'string_type',
+                        msg: 'Input should be a valid string',
+                        input: item,
+                    });
+                }
+            }
+            return bad.length > 0 ? bad : { value };
+        }
+        case 'dictInt': {
+            // `dict[str, int]`. pydantic validates the VALUES too, one error per bad entry and in
+            // the dict's own order, with the KEY in the location — `usage.a`, never `usage.0`. The
+            // coerced value is what the handler gets, so `{'a': '0'}` reaches `skillaudit` as `0`
+            // and is a `never-invoked` finding exactly as `{'a': 0}` is.
+            if (value.t !== 'dict') {
+                return [{ loc: spec.name, type: 'dict_type', msg: 'Input should be a valid dictionary', input: value }];
+            }
+            const bad = [];
+            const coerced = new Map();
+            for (const [key, item] of value.v) {
+                const checked = checkInt(`${spec.name}.${key}`, item);
+                if ('value' in checked)
+                    coerced.set(key, checked.value);
+                else
+                    bad.push(checked);
+            }
+            return bad.length > 0 ? bad : { value: { t: 'dict', v: coerced } };
+        }
+        case 'listStr': {
+            if (value.t !== 'list') {
+                return [{ loc: spec.name, type: 'list_type', msg: 'Input should be a valid list', input: value }];
+            }
+            // EVERY bad item, not the first: pydantic validates the whole list and reports one
+            // error per element, so `links: [1, 'ok', None]` is TWO errors, `links.0` and `links.2`.
+            const bad = [];
+            for (let i = 0; i < value.v.length; i += 1) {
+                const item = value.v[i];
+                if (item.t !== 'str') {
+                    bad.push({ loc: `${spec.name}.${i}`, type: 'string_type', msg: 'Input should be a valid string', input: item });
+                }
+            }
+            return bad.length > 0 ? bad : { value };
+        }
+        case 'int': {
+            const checked = checkInt(spec.name, value);
+            if (!('value' in checked))
+                return [checked];
+            // `less_than_equal` names the ORIGINAL input, as every constraint error does.
+            if (spec.le !== undefined && checked.value.t === 'int' && checked.value.v > spec.le) {
+                return [
+                    {
+                        loc: spec.name,
+                        type: 'less_than_equal',
+                        msg: `Input should be less than or equal to ${spec.le}`,
+                        input: value,
+                    },
+                ];
+            }
+            return checked;
+        }
+    }
+}
+function checkInt(loc, value) {
+    const tooBig = () => ({
+        loc,
+        type: 'int_parsing_size',
+        msg: 'Unable to parse input string as an integer, exceeded maximum size',
+        input: value,
+    });
+    if (value.t === 'int') {
+        return value.v > I64_MAX || value.v < I64_MIN ? tooBig() : { value };
+    }
+    if (value.t === 'bool')
+        return { value: { t: 'int', v: value.v ? 1n : 0n } };
+    if (value.t === 'float') {
+        if (!Number.isInteger(value.v)) {
+            return {
+                loc,
+                type: 'int_from_float',
+                msg: 'Input should be a valid integer, got a number with a fractional part',
+                input: value,
+            };
+        }
+        if (!(Math.abs(value.v) <= 9223372036854775807))
+            return tooBig();
+        return { value: { t: 'int', v: BigInt(value.v) } };
+    }
+    if (value.t === 'str') {
+        const text = value.v.trim();
+        const decimal = PY_INT_DECIMAL_TEXT.exec(text);
+        const digits = PY_INT_TEXT.test(text) ? text : decimal?.[1];
+        if (digits === undefined) {
+            return {
+                loc,
+                type: 'int_parsing',
+                msg: 'Input should be a valid integer, unable to parse string as an integer',
+                input: value,
+            };
+        }
+        const parsed = BigInt(digits.replace(/_/g, ''));
+        return parsed > I64_MAX || parsed < I64_MIN ? tooBig() : { value: { t: 'int', v: parsed } };
+    }
+    return { loc, type: 'int_type', msg: 'Input should be a valid integer', input: value };
+}
+/**
+ * The pydantic `ValidationError` text, WITHOUT the `Error executing tool <name>: ` prefix.
+ *
+ * The prefix is the SDK's, added by `Tool.run`'s `except Exception` for every failure a tool
+ * can have — not just an argument one — so it belongs at the one place that catches them all.
+ */
+export class PyValidationFailure extends Error {
+    detail;
+    constructor(detail) {
+        super(detail);
+        this.detail = detail;
+        this.name = 'PyValidationFailure';
+    }
+}
+/**
+ * `model.model_validate(arguments)` for one tool, or the exact `ValidationError` text.
+ *
+ * Unknown keys are IGNORED, because pydantic's default `model_config` ignores them and the
+ * measured server accepts `{"query": "a", "extra": 1}` without complaint. The absent-key case
+ * and the explicit-`null` case are different: `{}` is `missing`, `{"handoff_patch": null}` is
+ * `dict_type`, and only an OPTIONAL field treats `null` as its default.
+ */
+export function validateArguments(model, args) {
+    const supplied = args.t === 'dict' ? args.v : new Map();
+    const errors = [];
+    const bound = new Map();
+    for (const spec of model.fields) {
+        if (!supplied.has(spec.name)) {
+            if (spec.optional) {
+                bound.set(spec.name, { t: 'null' });
+                continue;
+            }
+            errors.push({ loc: spec.name, type: 'missing', msg: 'Field required', input: args });
+            continue;
+        }
+        const checked = checkField(spec, supplied.get(spec.name));
+        if (Array.isArray(checked))
+            errors.push(...checked);
+        else
+            bound.set(spec.name, checked.value);
+    }
+    if (errors.length === 0)
+        return bound;
+    const count = errors.length;
+    const head = `${count} validation error${count === 1 ? '' : 's'} for ${model.model}`;
+    const body = errors
+        .map((e) => `${e.loc}\n  ${e.msg} [type=${e.type}, input_value=${truncateRepr(reprValue(e.input))}, ` +
+        `input_type=${pyTypeName(e.input)}]\n    For further information visit ` +
+        `https://errors.pydantic.dev/2.13/v/${e.type}`)
+        .join('\n');
+    throw new PyValidationFailure(`${head}\n${body}`);
+}

package/dist/mcp/sdkjson.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The SDK's serializer — which is NOT `json.dumps`, and that is the whole reason this file
+ * exists next to `pyjson.ts`.
+ *
+ * Two different writers reach the wire from the Python server and only one of them is
+ * CPython's:
+ *
+ *   * every FILE bantamkit writes (`checkpoint.json`, `.log.jsonl`) goes through
+ *     `json.dumps` — `ensure_ascii=True`, `", "`/`": "` separators, codepoint `sort_keys`.
+ *     That is `pyjson.dumpJson`, N6's, and nothing here replaces it.
+ *   * every JSON-RPC FRAME, and the `content[0].text` inside a tool result, goes through
+ *     `pydantic_core.to_json` — Rust `serde_json`, which escapes nothing outside the JSON
+ *     minimum, emits raw UTF-8, and formats floats with ryu.
+ *
+ * Measured, `mcp` 2.0.0 / pydantic-core 2.x (`scratchpad/job38-n7/tj.py`):
+ *
+ *     to_json({'x': 'em — dash'})            -> {"x":"em — dash"}      (NOT —)
+ *     to_json({'k': '\x7f\x01'})             -> {"k":"?"}  -> DEL RAW, 
 escaped
+ *     to_json(1e-6)  -> 1e-6     while repr(1e-6)  is '1e-06'
+ *     to_json(1e-5)  -> 0.00001  while repr(1e-5)  is '1e-05'
+ *     to_json(1.0)   -> 1.0      while String(1.0) is '1'
+ *
+ * The first two are what `JSON.stringify` already does, so strings ride on it. The last two
+ * are not, and are why numbers are formatted by hand: a `5.0` that arrived on the wire and
+ * left as `5` is exactly the defect N6 measured on the file side, relocated to the frame.
+ */
+import type { PyValue } from '../pyjson.js';
+/**
+ * ryu's presentation rule, as `serde_json` uses it, derived by sweeping 99 values against
+ * the running `pydantic_core` (`scratchpad/job38-n7/tf2.py`).
+ *
+ * It agrees with CPython's `repr` everywhere except the exponent, in two ways:
+ *   1. the exponent is NOT zero-padded — `1e-6`, not `1e-06`;
+ *   2. the decimal/scientific boundary on the small side is one decade lower — `1e-5`
+ *      prints as `0.00001` where `repr` gives `1e-05`.
+ * The large side agrees: both switch to scientific at 1e16.
+ *
+ * `-0.0` keeps its sign in both. NaN and the infinities cannot occur: they are not JSON,
+ * every value here arrived by parsing a JSON document, and `pyjson.parseJson` rejects
+ * Python's `NaN`/`Infinity` extension the way a strict reader must.
+ */
+export declare function serdeFloat(x: number): string;
+/**
+ * `pydantic_core.to_json(value, indent=<indent>)`.
+ *
+ * `indent = null` is the compact form the JSON-RPC frame uses — `,` and `:` with NO spaces,
+ * which is serde's default and NOT `json.dumps`' default. `indent = 2` is the form
+ * `_convert_to_content` uses for the text block of every dict-returning tool.
+ *
+ * Strings go through `JSON.stringify`, which was checked against serde over the escape
+ * boundary: both emit the short escapes for `\b \t \n \f \r " \\`, `\u00XX` for the other
+ * C0 controls, and raw bytes for everything else including DEL and `/`. They part company
+ * only on a LONE SURROGATE, which JS escapes and pydantic-core refuses to encode at all —
+ * unreachable here, because a lone surrogate cannot survive UTF-8 decoding of the wire.
+ */
+export declare function sdkJson(value: PyValue, indent?: number | null): string;

package/dist/mcp/sdkjson.js

@@ -0,0 +1,91 @@
+/**
+ * ryu's presentation rule, as `serde_json` uses it, derived by sweeping 99 values against
+ * the running `pydantic_core` (`scratchpad/job38-n7/tf2.py`).
+ *
+ * It agrees with CPython's `repr` everywhere except the exponent, in two ways:
+ *   1. the exponent is NOT zero-padded — `1e-6`, not `1e-06`;
+ *   2. the decimal/scientific boundary on the small side is one decade lower — `1e-5`
+ *      prints as `0.00001` where `repr` gives `1e-05`.
+ * The large side agrees: both switch to scientific at 1e16.
+ *
+ * `-0.0` keeps its sign in both. NaN and the infinities cannot occur: they are not JSON,
+ * every value here arrived by parsing a JSON document, and `pyjson.parseJson` rejects
+ * Python's `NaN`/`Infinity` extension the way a strict reader must.
+ */
+export function serdeFloat(x) {
+    if (!Number.isFinite(x)) {
+        // `to_json` writes `null` for a non-finite float; unreachable from parsed JSON, kept so
+        // the function is total rather than silently emitting invalid JSON.
+        return 'null';
+    }
+    const sign = Object.is(x, -0) || x < 0 ? '-' : '';
+    const abs = Math.abs(x);
+    if (abs === 0)
+        return `${sign}0.0`;
+    // `toExponential()` with no argument gives the SHORTEST round-tripping digits, which is
+    // the same digit string ryu produces; only the presentation is ours.
+    const [mantissa, exponentText] = abs.toExponential().split('e');
+    const exponent = Number(exponentText);
+    const digits = mantissa.replace('.', '');
+    if (exponent >= -5 && exponent < 16) {
+        if (exponent >= 0) {
+            const whole = digits.padEnd(exponent + 1, '0').slice(0, exponent + 1);
+            const fraction = digits.slice(exponent + 1);
+            return `${sign}${whole}.${fraction === '' ? '0' : fraction}`;
+        }
+        return `${sign}0.${'0'.repeat(-exponent - 1)}${digits}`;
+    }
+    const head = digits.length === 1 ? digits : `${digits[0]}.${digits.slice(1)}`;
+    return `${sign}${head}e${exponent < 0 ? '-' : '+'}${Math.abs(exponent)}`;
+}
+/**
+ * `pydantic_core.to_json(value, indent=<indent>)`.
+ *
+ * `indent = null` is the compact form the JSON-RPC frame uses — `,` and `:` with NO spaces,
+ * which is serde's default and NOT `json.dumps`' default. `indent = 2` is the form
+ * `_convert_to_content` uses for the text block of every dict-returning tool.
+ *
+ * Strings go through `JSON.stringify`, which was checked against serde over the escape
+ * boundary: both emit the short escapes for `\b \t \n \f \r " \\`, `\u00XX` for the other
+ * C0 controls, and raw bytes for everything else including DEL and `/`. They part company
+ * only on a LONE SURROGATE, which JS escapes and pydantic-core refuses to encode at all —
+ * unreachable here, because a lone surrogate cannot survive UTF-8 decoding of the wire.
+ */
+export function sdkJson(value, indent = null) {
+    const pad = indent === null ? '' : ' '.repeat(indent);
+    const itemSep = indent === null ? ',' : ',';
+    const keySep = indent === null ? ':' : ': ';
+    const encode = (v, level) => {
+        switch (v.t) {
+            case 'null':
+                return 'null';
+            case 'bool':
+                return v.v ? 'true' : 'false';
+            case 'int':
+                return v.v.toString();
+            case 'float':
+                return serdeFloat(v.v);
+            case 'str':
+                return JSON.stringify(v.v);
+            case 'list': {
+                if (v.v.length === 0)
+                    return '[]';
+                const parts = v.v.map((item) => encode(item, level + 1));
+                if (indent === null)
+                    return `[${parts.join(itemSep)}]`;
+                const nl = `\n${pad.repeat(level + 1)}`;
+                return `[${nl}${parts.join(itemSep + nl)}\n${pad.repeat(level)}]`;
+            }
+            case 'dict': {
+                if (v.v.size === 0)
+                    return '{}';
+                const parts = [...v.v].map(([k, item]) => `${JSON.stringify(k)}${keySep}${encode(item, level + 1)}`);
+                if (indent === null)
+                    return `{${parts.join(itemSep)}}`;
+                const nl = `\n${pad.repeat(level + 1)}`;
+                return `{${nl}${parts.join(itemSep + nl)}\n${pad.repeat(level)}}`;
+            }
+        }
+    };
+    return encode(value, 0);
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,45 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { EventLog } from '../eventlog.js';
+import type { Memory } from '../memory/component.js';
+import type { RawStdioTransport } from './transport.js';
+/**
+ * The eleven, in the order `build_server` lists them — which is the order `tools/list` emits.
+ *
+ * `bantamkit_status` went LAST rather than first, `memory_compact` after it rather than
+ * beside `memory_save` where a reader would look for it, `bantamkit_read` after that and
+ * `skill_audit` after that, for the same reason the reference appends all four: registration
+ * order IS the served order, and appending is the only edit that leaves the other ten where
+ * every existing declaration says they are.
+ */
+export declare const MCP_TOOLS: readonly ["memory_save", "memory_recall", "validate_json", "shiftwork_clock_in", "shiftwork_clock_out", "shiftwork_status", "build_identity", "bantamkit_status", "memory_compact", "bantamkit_read", "skill_audit"];
+/**
+ * The advertisement for one tool, out of its manifest, with the surface checked.
+ *
+ * Key order is `description, inputSchema, name, outputSchema` because that is the order the
+ * reference's pydantic `Tool` model dumps in, and the nested schemas keep the manifest's own
+ * key order because both runtimes preserve insertion order in a JSON object.
+ *
+ * `output_schema` is advertised VERBATIM and is not derived from anything this file knows.
+ * That includes `build_identity.json`'s `"title": "build_identity_toolDictOutput"`, which
+ * leaks the Python closure name `build_identity_tool` into a Node server's advertisement.
+ * IT IS REPRODUCED, NOT FIXED. The manifest is an asset, `build_identity` hashes every asset
+ * byte, and changing it would move `assets_digest` — the one field that is supposed to be
+ * comparable across the two runtimes. A cosmetic title is not worth breaking the instrument
+ * that detects drift. Registered here, not fixed here; `runtime-py` is the reference.
+ */
+export declare function fromManifest(name: string): Record<string, unknown>;
+/**
+ * Assemble the MCP server around one Memory instance (the per-person state).
+ *
+ * `wire` is the transport, and it is a parameter rather than something this function creates
+ * because the handlers need it twice: to read the RAW request line (so `5.0` is still a float
+ * when it reaches `shiftwork.clockOut`) and to register the EXACT result text (so it is still
+ * a float on the way back out).
+ *
+ * `log` is the event-log sink (`docs/eventlog.md`), resolved from `BANTAMKIT_EVENT_LOG` when
+ * the caller does not supply one and DISABLED unless that variable asks for it. It is a
+ * parameter and not only an environment read so that a test can inject a fixed clock and a
+ * scratch path without setting a process-wide variable — the same seam `runtime-py`'s
+ * `build_server(memory, log=None)` offers.
+ */
+export declare function buildServer(memory: Memory, wire: RawStdioTransport, version: string, log?: EventLog): Server;