mcp-3d-printer-server 1.2.25 → 1.2.26

package/dist/counterpart/camera-stream.js

@@ -0,0 +1,246 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _CameraStream_instances, _CameraStream_source, _CameraStream_timer, _CameraStream_generation, _CameraStream_processing, _CameraStream_lastAccepted, _CameraStream_latest, _CameraStream_references, _CameraStream_waiters, _CameraStream_stopped, _CameraStream_reconnected, _CameraStream_reason, _CameraStream_seq, _CameraStream_wake, _CameraStream_connect, _CameraStream_lost, _CameraStream_accept, _CameraStream_encoded, _CameraStream_result, _CameraStreams_streams, _CameraStreams_sequence;
+let native;
+async function nativeSharp() {
+    const [major, minor] = process.versions.node.split(".").map(Number);
+    if (major < 20 || (major === 20 && minor < 9))
+        throw new Error("Native camera processing requires Node 20.9+");
+    const optionalPackage = "sharp";
+    native ?? (native = import(optionalPackage).then(module => {
+        const processor = module.default;
+        processor.cache({ memory: 8, files: 0, items: 32 });
+        return processor;
+    }));
+    return native;
+}
+export async function cameraNativeAvailable() {
+    try {
+        await nativeSharp();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function thumbnailChange(a, b) {
+    let total = 0;
+    for (let i = 0; i < a.length; i++)
+        total += Math.abs(a[i] - b[i]);
+    return total / (a.length * 255);
+}
+export class CameraStream {
+    constructor(options, nextSeq, now = Date.now) {
+        _CameraStream_instances.add(this);
+        this.options = options;
+        this.nextSeq = nextSeq;
+        this.now = now;
+        this.startedAt = new Date().toISOString();
+        _CameraStream_source.set(this, void 0);
+        _CameraStream_timer.set(this, void 0);
+        _CameraStream_generation.set(this, 0);
+        _CameraStream_processing.set(this, false);
+        _CameraStream_lastAccepted.set(this, -Infinity);
+        _CameraStream_latest.set(this, void 0);
+        // Keep thumbnails of frames actually delivered, not every camera frame. A quiet view may keep
+        // comparing with its first frame for hours; a rolling JPEG history would repeatedly resend it.
+        _CameraStream_references.set(this, new Map());
+        _CameraStream_waiters.set(this, new Set());
+        _CameraStream_stopped.set(this, false);
+        _CameraStream_reconnected.set(this, false);
+        _CameraStream_reason.set(this, void 0);
+        _CameraStream_seq.set(this, 0);
+        this.transport = options.transport;
+        this.fps = options.fps;
+    }
+    get stopped() { return __classPrivateFieldGet(this, _CameraStream_stopped, "f"); }
+    start() { this.touch(); __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_connect).call(this); }
+    touch(idleTimeoutMs) {
+        if (__classPrivateFieldGet(this, _CameraStream_stopped, "f"))
+            return;
+        if (idleTimeoutMs !== undefined)
+            this.options.idleTimeoutMs = idleTimeoutMs;
+        clearTimeout(__classPrivateFieldGet(this, _CameraStream_timer, "f"));
+        __classPrivateFieldSet(this, _CameraStream_timer, setTimeout(() => this.stop(), this.options.idleTimeoutMs), "f");
+        __classPrivateFieldGet(this, _CameraStream_timer, "f").unref();
+    }
+    stop() {
+        var _a;
+        if (__classPrivateFieldGet(this, _CameraStream_stopped, "f"))
+            return;
+        __classPrivateFieldSet(this, _CameraStream_stopped, true, "f");
+        __classPrivateFieldSet(this, _CameraStream_generation, (_a = __classPrivateFieldGet(this, _CameraStream_generation, "f"), _a++, _a), "f");
+        clearTimeout(__classPrivateFieldGet(this, _CameraStream_timer, "f"));
+        __classPrivateFieldGet(this, _CameraStream_source, "f")?.close();
+        __classPrivateFieldSet(this, _CameraStream_source, undefined, "f");
+        __classPrivateFieldSet(this, _CameraStream_latest, undefined, "f");
+        __classPrivateFieldGet(this, _CameraStream_references, "f").clear();
+        __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_wake).call(this);
+    }
+    async frame(options = {}) {
+        const since = options.sinceSeq ?? 0, deadline = Date.now() + (options.waitMs ?? 0);
+        this.touch();
+        for (;;) {
+            options.signal?.throwIfAborted();
+            if (__classPrivateFieldGet(this, _CameraStream_reason, "f"))
+                return { status: "unavailable", seq: __classPrivateFieldGet(this, _CameraStream_seq, "f"), reason: __classPrivateFieldGet(this, _CameraStream_reason, "f") };
+            if (__classPrivateFieldGet(this, _CameraStream_stopped, "f"))
+                return { status: "stopped", seq: __classPrivateFieldGet(this, _CameraStream_seq, "f") };
+            const latest = __classPrivateFieldGet(this, _CameraStream_latest, "f");
+            if (latest && latest.seq > since) {
+                const reference = __classPrivateFieldGet(this, _CameraStream_references, "f").get(since);
+                const change = reference ? thumbnailChange(latest.thumb, reference) : 1;
+                if (options.changedOnly === false || change >= (options.minChange ?? 0.02))
+                    return __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_result).call(this, latest, change, options.maxWidth, options.maxBytes);
+            }
+            const left = deadline - Date.now();
+            if (left <= 0)
+                return { status: "unchanged", seq: since, ...(latest ? { capturedAt: new Date(latest.at).toISOString() } : {}) };
+            await new Promise(resolve => {
+                const done = () => { clearTimeout(timer); __classPrivateFieldGet(this, _CameraStream_waiters, "f").delete(done); options.signal?.removeEventListener("abort", done); resolve(); };
+                const timer = setTimeout(done, left);
+                __classPrivateFieldGet(this, _CameraStream_waiters, "f").add(done);
+                options.signal?.addEventListener("abort", done, { once: true });
+            });
+        }
+    }
+    async latest(waitMs) {
+        const result = await this.frame({ waitMs, changedOnly: false });
+        return result.status === "frame" ? Buffer.from(result.base64, "base64") : undefined;
+    }
+}
+_CameraStream_source = new WeakMap(), _CameraStream_timer = new WeakMap(), _CameraStream_generation = new WeakMap(), _CameraStream_processing = new WeakMap(), _CameraStream_lastAccepted = new WeakMap(), _CameraStream_latest = new WeakMap(), _CameraStream_references = new WeakMap(), _CameraStream_waiters = new WeakMap(), _CameraStream_stopped = new WeakMap(), _CameraStream_reconnected = new WeakMap(), _CameraStream_reason = new WeakMap(), _CameraStream_seq = new WeakMap(), _CameraStream_instances = new WeakSet(), _CameraStream_wake = function _CameraStream_wake() { for (const wake of [...__classPrivateFieldGet(this, _CameraStream_waiters, "f")])
+    wake(); }, _CameraStream_connect = function _CameraStream_connect() {
+    var _a;
+    const generation = __classPrivateFieldSet(this, _CameraStream_generation, (_a = __classPrivateFieldGet(this, _CameraStream_generation, "f"), ++_a), "f");
+    let buffered, live = !this.options.skipFirstFrame;
+    const current = () => !__classPrivateFieldGet(this, _CameraStream_stopped, "f") && generation === __classPrivateFieldGet(this, _CameraStream_generation, "f");
+    try {
+        const source = this.options.open({
+            onFrame: bytes => {
+                if (!current())
+                    return;
+                // P1/A1 replay their stale buffered frame, sometimes more than once.
+                if (!live) {
+                    if (!buffered) {
+                        buffered = bytes;
+                        return;
+                    }
+                    if (bytes.equals(buffered))
+                        return;
+                    buffered = undefined;
+                    live = true;
+                }
+                if (__classPrivateFieldGet(this, _CameraStream_processing, "f") || this.now() - __classPrivateFieldGet(this, _CameraStream_lastAccepted, "f") < 1000 / this.fps)
+                    return;
+                __classPrivateFieldSet(this, _CameraStream_lastAccepted, this.now(), "f");
+                __classPrivateFieldSet(this, _CameraStream_processing, true, "f");
+                void __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_accept).call(this, bytes, generation).catch(() => { if (current())
+                    __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_lost).call(this, "unreachable"); })
+                    .finally(() => { __classPrivateFieldSet(this, _CameraStream_processing, false, "f"); });
+            },
+            onError: error => { if (current())
+                __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_lost).call(this, /auth|payload size|401|403/i.test(error.message) ? "auth" : "unreachable"); },
+            onEnd: () => { if (current())
+                __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_lost).call(this, "unreachable"); },
+        });
+        // A transport may fail synchronously. Never keep its abandoned source after reconnect/stop.
+        if (current())
+            __classPrivateFieldSet(this, _CameraStream_source, source, "f");
+        else
+            source.close();
+    }
+    catch {
+        if (current())
+            __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_lost).call(this, "unreachable");
+    }
+}, _CameraStream_lost = function _CameraStream_lost(reason) {
+    var _a;
+    __classPrivateFieldSet(this, _CameraStream_generation, (_a = __classPrivateFieldGet(this, _CameraStream_generation, "f"), _a++, _a), "f");
+    __classPrivateFieldGet(this, _CameraStream_source, "f")?.close();
+    __classPrivateFieldSet(this, _CameraStream_source, undefined, "f");
+    if (!__classPrivateFieldGet(this, _CameraStream_reconnected, "f") && reason !== "auth") {
+        __classPrivateFieldSet(this, _CameraStream_reconnected, true, "f");
+        __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_connect).call(this);
+        return;
+    }
+    __classPrivateFieldSet(this, _CameraStream_reason, reason, "f");
+    this.stop();
+}, _CameraStream_accept = async function _CameraStream_accept(bytes, generation) {
+    if (bytes.length > 5000000)
+        throw Error("Camera JPEG too large");
+    const decoder = (await nativeSharp())(bytes, { limitInputPixels: 8000000 });
+    const metadata = await decoder.metadata();
+    const thumb = await decoder.resize(32, 18, { fit: "fill" }).greyscale().raw().toBuffer();
+    if (__classPrivateFieldGet(this, _CameraStream_stopped, "f") || generation !== __classPrivateFieldGet(this, _CameraStream_generation, "f"))
+        return;
+    __classPrivateFieldSet(this, _CameraStream_latest, { seq: __classPrivateFieldSet(this, _CameraStream_seq, this.nextSeq(), "f"), bytes, thumb, at: this.now(), width: metadata.width, height: metadata.height, scaled: new Map() }, "f");
+    __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_wake).call(this);
+}, _CameraStream_encoded = async function _CameraStream_encoded(frame, width, maxBytes) {
+    // Start near the byte target instead of always encoding a full-size frame that will be
+    // discarded. Source JPEG density is a cheap conservative estimate, not a size guarantee.
+    if (maxBytes && frame.bytes.length > maxBytes)
+        width = Math.min(width, Math.max(1, Math.floor(frame.width * Math.sqrt(maxBytes / frame.bytes.length) * 0.8)));
+    // At most four native encodes. The final 1-pixel fallback guarantees a bounded result
+    // even for pathological entropy; quality stays 70 and aspect ratio is preserved.
+    for (let attempt = 0; attempt < 4; attempt++) {
+        const encoded = await (await nativeSharp())(frame.bytes, { limitInputPixels: 8000000 }).resize({ width, withoutEnlargement: true }).jpeg({ quality: 70 }).toBuffer({ resolveWithObject: true });
+        if (!maxBytes || encoded.data.length <= maxBytes)
+            return encoded;
+        width = attempt === 2 ? 1 : Math.max(1, Math.floor(width * Math.min(0.8, Math.sqrt(maxBytes / encoded.data.length) * 0.9)));
+    }
+    throw new Error("Camera frame could not fit max_bytes");
+}, _CameraStream_result = async function _CameraStream_result(frame, change, maxWidth, maxBytes) {
+    let bytes = frame.bytes, width = frame.width, height = frame.height;
+    if ((maxWidth && width > maxWidth) || (maxBytes && bytes.length > maxBytes)) {
+        const key = `${maxWidth ?? width}:${maxBytes ?? 0}`;
+        let scaled = frame.scaled.get(key);
+        if (!scaled) {
+            scaled = __classPrivateFieldGet(this, _CameraStream_instances, "m", _CameraStream_encoded).call(this, frame, Math.min(width, maxWidth ?? width), maxBytes);
+            if (frame.scaled.size < 4)
+                frame.scaled.set(key, scaled);
+        }
+        const resized = await scaled;
+        bytes = resized.data;
+        width = resized.info.width;
+        height = resized.info.height;
+    }
+    if (__classPrivateFieldGet(this, _CameraStream_stopped, "f"))
+        return __classPrivateFieldGet(this, _CameraStream_reason, "f") ? { status: "unavailable", seq: __classPrivateFieldGet(this, _CameraStream_seq, "f"), reason: __classPrivateFieldGet(this, _CameraStream_reason, "f") } : { status: "stopped", seq: __classPrivateFieldGet(this, _CameraStream_seq, "f") };
+    __classPrivateFieldGet(this, _CameraStream_references, "f").set(frame.seq, frame.thumb);
+    if (__classPrivateFieldGet(this, _CameraStream_references, "f").size > 256)
+        __classPrivateFieldGet(this, _CameraStream_references, "f").delete(__classPrivateFieldGet(this, _CameraStream_references, "f").keys().next().value);
+    return { status: "frame", seq: frame.seq, capturedAt: new Date(frame.at).toISOString(), width, height, format: "image/jpeg", base64: bytes.toString("base64"), change };
+};
+export class CameraStreams {
+    constructor(now = Date.now) {
+        this.now = now;
+        _CameraStreams_streams.set(this, new Map());
+        _CameraStreams_sequence.set(this, 0);
+    }
+    get(key) { return __classPrivateFieldGet(this, _CameraStreams_streams, "f").get(key); }
+    start(key, options) {
+        const existing = this.get(key);
+        if (existing && !existing.stopped) {
+            existing.touch(options.idleTimeoutMs);
+            return { stream: existing, status: "running" };
+        }
+        const stream = new CameraStream(options, () => { var _a; return __classPrivateFieldSet(this, _CameraStreams_sequence, (_a = __classPrivateFieldGet(this, _CameraStreams_sequence, "f"), ++_a), "f"); }, this.now);
+        __classPrivateFieldGet(this, _CameraStreams_streams, "f").set(key, stream);
+        stream.start();
+        return { stream, status: "started" };
+    }
+    stop(key) { this.get(key)?.stop(); }
+    stopAll() { for (const stream of __classPrivateFieldGet(this, _CameraStreams_streams, "f").values())
+        stream.stop(); __classPrivateFieldGet(this, _CameraStreams_streams, "f").clear(); }
+}
+_CameraStreams_streams = new WeakMap(), _CameraStreams_sequence = new WeakMap();

package/dist/counterpart/camera-tools.d.ts

@@ -0,0 +1,247 @@
+export declare const CAMERA_STREAM_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            fps: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+                description: string;
+            };
+            idle_timeout_ms: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+                description: string;
+            };
+            port: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+            api_key: {
+                type: string;
+                description: string;
+            };
+            host: {
+                type: string;
+                description: string;
+            };
+            bambu_serial: {
+                type: string;
+                description: string;
+            };
+            bambu_token: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: "object";
+        properties: {
+            status: {
+                type: string;
+                enum: string[];
+                const?: undefined;
+            };
+            reason: {
+                type: string;
+                enum: string[];
+            };
+            transport: {
+                type: string;
+                enum: string[];
+            };
+            fps: {
+                type: string;
+            };
+            startedAt: {
+                type: string;
+            };
+        };
+        required: string[];
+        oneOf: ({
+            properties: {
+                status: {
+                    enum: string[];
+                    const?: undefined;
+                };
+            };
+            required: string[];
+        } | {
+            properties: {
+                status: {
+                    const: string;
+                    enum?: undefined;
+                };
+            };
+            required: string[];
+        })[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            since_seq: {
+                type: string;
+                minimum: number;
+                default: number;
+                description: string;
+            };
+            wait_ms: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+                description: string;
+            };
+            max_width: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            max_bytes: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            changed_only: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            min_change: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+                description: string;
+            };
+            port: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+            api_key: {
+                type: string;
+                description: string;
+            };
+            host: {
+                type: string;
+                description: string;
+            };
+            bambu_serial: {
+                type: string;
+                description: string;
+            };
+            bambu_token: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: "object";
+        properties: {
+            status: {
+                type: string;
+                enum: string[];
+            };
+            seq: {
+                type: string;
+                minimum: number;
+            };
+            capturedAt: {
+                type: string;
+            };
+            width: {
+                type: string;
+            };
+            height: {
+                type: string;
+            };
+            format: {
+                type: string;
+                const: string;
+            };
+            base64: {
+                type: string;
+            };
+            change: {
+                type: string;
+            };
+            reason: {
+                type: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            port: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+            api_key: {
+                type: string;
+                description: string;
+            };
+            host: {
+                type: string;
+                description: string;
+            };
+            bambu_serial: {
+                type: string;
+                description: string;
+            };
+            bambu_token: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: "object";
+        properties: {
+            status: {
+                type: string;
+                const: string;
+                enum?: undefined;
+            };
+            reason?: undefined;
+            transport?: undefined;
+            fps?: undefined;
+            startedAt?: undefined;
+        };
+        required: string[];
+        oneOf?: undefined;
+    };
+})[];
+export declare function cameraNumber(value: unknown, fallback: number, min: number, max: number, name: string, integer?: boolean): number;

package/dist/counterpart/camera-tools.js

@@ -0,0 +1,35 @@
+/** Additive stream tools; discovery is the capability check for older clients. */
+const routing = {
+    port: { type: "string", description: "Printer API port; defaults to PRINTER_PORT." },
+    type: { type: "string", description: "Printer backend; defaults to PRINTER_TYPE." },
+    api_key: { type: "string", description: "Printer API key; defaults to API_KEY." },
+    host: { type: "string", description: "Printer host or IP; defaults to PRINTER_HOST." },
+    bambu_serial: { type: "string", description: "Printer serial number; defaults to the configured serial and identifies its shared stream." },
+    bambu_token: { type: "string", description: "Printer LAN access code; defaults to the configured access code." },
+};
+const frameSchema = {
+    type: "object", properties: {
+        status: { type: "string", enum: ["frame", "unchanged", "stopped", "unavailable"] }, seq: { type: "integer", minimum: 0 },
+        capturedAt: { type: "string" }, width: { type: "integer" }, height: { type: "integer" },
+        format: { type: "string", const: "image/jpeg" }, base64: { type: "string" }, change: { type: "number" },
+        reason: { type: "string", enum: ["no-camera", "auth", "unreachable"] },
+    }, required: ["status", "seq"],
+};
+export const CAMERA_STREAM_TOOLS = [
+    { name: "camera_stream_start", description: "Start or renew one persistent camera connection for this printer. Call only while watched; it closes automatically after idle_timeout_ms without a viewer request. camera_snapshot then reuses its latest frame. No printer motion or print commands.",
+        inputSchema: { type: "object", properties: { ...routing, fps: { type: "number", minimum: 0.2, maximum: 2, default: 1, description: "Maximum processed frames per second. The first viewer sets the rate until the stream closes." }, idle_timeout_ms: { type: "integer", minimum: 5000, maximum: 120000, default: 30000, description: "Close the shared connection after this many milliseconds without a viewer request." } }, additionalProperties: false },
+        outputSchema: { type: "object", properties: { status: { type: "string", enum: ["started", "running", "not-supported"] }, reason: { type: "string", enum: ["runtime"] }, transport: { type: "string", enum: ["http"] }, fps: { type: "number" }, startedAt: { type: "string" } }, required: ["status"], oneOf: [
+                { properties: { status: { enum: ["started", "running"] } }, required: ["transport", "fps", "startedAt"] },
+                { properties: { status: { const: "not-supported" } }, required: ["reason"] },
+            ] } },
+    { name: "camera_frame", description: "Read the shared camera stream, optionally waiting up to 10 seconds. Returns JPEG only when newer than since_seq and visibly changed (32×18 grayscale difference). Retain the last delivered frame's seq on unchanged. max_width resizes JPEG to the viewer. Does not start a stopped stream.",
+        inputSchema: { type: "object", properties: { ...routing, since_seq: { type: "integer", minimum: 0, default: 0, description: "Sequence of the last delivered JPEG; retain it when a result is unchanged." }, wait_ms: { type: "integer", minimum: 0, maximum: 10000, default: 0, description: "Maximum time to await a newer changed frame; zero returns immediately." }, max_width: { type: "integer", minimum: 1, maximum: 4096, description: "Optional maximum JPEG width in pixels, preserving aspect ratio and never enlarging." }, max_bytes: { type: "integer", minimum: 4096, maximum: 5000000, description: "Optional maximum encoded JPEG bytes. Downscales further at quality 70 when needed; base64 adds about one third plus protocol overhead. Use 42000 for a two-second 30 KB/s viewer budget." }, changed_only: { type: "boolean", default: true, description: "Return JPEG only when its thumbnail differs enough from the last delivered frame." }, min_change: { type: "number", minimum: 0, maximum: 1, default: 0.02, description: "Minimum mean absolute grayscale thumbnail difference, normalized from zero to one." } }, additionalProperties: false }, outputSchema: frameSchema },
+    { name: "camera_stream_stop", description: "Close this printer's camera connection and free its cached frames. Other printers keep their own streams. Active viewers may restart it; normally let the idle timeout close a shared stream.",
+        inputSchema: { type: "object", properties: routing, additionalProperties: false }, outputSchema: { type: "object", properties: { status: { type: "string", const: "stopped" } }, required: ["status"] } },
+];
+export function cameraNumber(value, fallback, min, max, name, integer = false) {
+    const n = value === undefined ? fallback : value;
+    if (typeof n !== "number" || !Number.isFinite(n) || n < min || n > max || (integer && !Number.isSafeInteger(n)))
+        throw new Error(`${name} must be ${integer ? "an integer" : "a number"} from ${min} to ${max}`);
+    return n;
+}

package/dist/counterpart/contract.d.ts

@@ -48,6 +48,7 @@ export interface CounterpartCapabilities {
     progress: boolean;
     layers: boolean;
     camera: CameraCapability;
+    cameraStream?: boolean;
     filaments: FilamentCapability;
     pause: boolean;
     resume: boolean;
@@ -73,11 +74,12 @@ export interface CounterpartPrinterInfo {
     capabilities: CounterpartCapabilities;
 }
 export interface FilamentSlot {
-    id: "ext";
+    /** "ext" for a single-spool printer; Bambu: the absolute AMS tray ("0"-"15", "128"+) or external spool ("254", "255"). */
+    id: string;
     material?: string;
     color?: string;
     name?: string;
-    source: "spoolman" | "unknown";
+    source: "spoolman" | "printer" | "unknown";
     /** Absolute path of the slicer filament profile for this material, as slice_stl's load_filaments takes it. */
     profile?: string;
 }
@@ -148,6 +150,9 @@ export declare const PRINTER_INFO_OUTPUT_SCHEMA: {
                     readonly type: "string";
                     readonly enum: readonly ["bambu-tcp", "rtsp", "http-snapshot", "none"];
                 };
+                readonly cameraStream: {
+                    readonly type: "boolean";
+                };
                 readonly filaments: {
                     readonly type: "string";
                     readonly enum: readonly ["ams", "single", "none"];
@@ -278,7 +283,7 @@ export declare const PRINT_PROGRESS_OUTPUT_SCHEMA: {
                     };
                     severity: {
                         type: string;
-                        enum: ("error" | "fatal" | "warning" | "info")[];
+                        enum: ("error" | "info" | "fatal" | "warning")[];
                     };
                     message: {
                         type: string;
@@ -319,11 +324,22 @@ export declare const CAMERA_SNAPSHOT_OUTPUT_SCHEMA: {
         };
     };
 };
-/** outputSchema for get_printer_filaments in this server: one external slot. */
+/**
+ * outputSchema for get_printer_filaments: one external slot, or for Bambu every
+ * loaded AMS tray and external spool plus bambu-printer-mcp's inventory fields
+ * (trays, summary, recommended, load_filaments_all), which keep its nulls.
+ */
 export declare const FILAMENTS_OUTPUT_SCHEMA: {
     readonly type: "object";
     readonly required: readonly ["slots"];
     readonly properties: {
+        readonly trays: {
+            readonly type: "array";
+            readonly description: "Bambu only: bambu-printer-mcp's AMS tray list (slot = ams_id * 4 + tray_id), empty trays included.";
+            readonly items: {
+                readonly type: "object";
+            };
+        };
         readonly slots: {
             readonly type: "array";
             readonly items: {
@@ -344,7 +360,7 @@ export declare const FILAMENTS_OUTPUT_SCHEMA: {
                     };
                     readonly source: {
                         readonly type: "string";
-                        readonly enum: readonly ["spoolman", "unknown"];
+                        readonly enum: readonly ["spoolman", "printer", "unknown"];
                     };
                     readonly profile: {
                         readonly type: "string";

package/dist/counterpart/contract.js

@@ -52,6 +52,7 @@ export const PRINTER_INFO_OUTPUT_SCHEMA = {
                 progress: { type: "boolean" },
                 layers: { type: "boolean" },
                 camera: { type: "string", enum: ["bambu-tcp", "rtsp", "http-snapshot", "none"] },
+                cameraStream: { type: "boolean" },
                 filaments: { type: "string", enum: ["ams", "single", "none"] },
                 pause: { type: "boolean" },
                 resume: { type: "boolean" },
@@ -109,11 +110,16 @@ export const CAMERA_SNAPSHOT_OUTPUT_SCHEMA = {
         source: { type: "string" },
     },
 };
-/** outputSchema for get_printer_filaments in this server: one external slot. */
+/**
+ * outputSchema for get_printer_filaments: one external slot, or for Bambu every
+ * loaded AMS tray and external spool plus bambu-printer-mcp's inventory fields
+ * (trays, summary, recommended, load_filaments_all), which keep its nulls.
+ */
 export const FILAMENTS_OUTPUT_SCHEMA = {
     type: "object",
     required: ["slots"],
     properties: {
+        trays: { type: "array", description: "Bambu only: bambu-printer-mcp's AMS tray list (slot = ams_id * 4 + tray_id), empty trays included.", items: { type: "object" } },
         slots: {
             type: "array",
             items: {
@@ -124,7 +130,7 @@ export const FILAMENTS_OUTPUT_SCHEMA = {
                     material: { type: "string" },
                     color: { type: "string" },
                     name: { type: "string" },
-                    source: { type: "string", enum: ["spoolman", "unknown"] },
+                    source: { type: "string", enum: ["spoolman", "printer", "unknown"] },
                     profile: {
                         type: "string",
                         description: "Absolute path of the installed slicer filament profile for this slot's material, which slice_stl accepts as load_filaments. Omitted when none resolves.",

package/dist/counterpart/route.d.ts

@@ -0,0 +1,31 @@
+/**
+ * lan: the local network through FULU's BambuNetwork bridge (or the configured X2D native or Bambu Connect mode).
+ * cloud: Bambu Cloud through FULU's bridge.
+ * developer: the local network straight to the printer (lan_mqtt_ftps), for a printer in LAN Only + Developer Mode.
+ */
+export type PrintRoute = "lan" | "cloud" | "developer";
+export declare const PRINT_ROUTES: readonly PrintRoute[];
+export interface Connection {
+    mode: string;
+    type: string;
+}
+/** One connection a person can choose, as counterpart_print_route reports it. */
+export interface RouteOption {
+    id: PrintRoute;
+    label: string;
+    available: boolean;
+    /** Why it can't be chosen here, when it can't. */
+    reason?: string;
+    /** What Pause, Resume and Stop do on this connection. */
+    controls: string;
+}
+export declare function routeOf(connection: Connection): PrintRoute;
+/** Every connection, and whether this server can use it (bridgeConfigured: BAMBU_NETWORK_BRIDGE_COMMAND is set). */
+export declare function routeOptions(current: Connection, bridgeConfigured: boolean): RouteOption[];
+/**
+ * The configured defaults for a route. Cloud and the local network use FULU's BambuNetwork; an X2D native or
+ * Bambu Connect setup keeps its own mode for the local network. Developer Mode is the direct LAN route.
+ */
+export declare function connectionForRoute(route: PrintRoute, current: Connection, bridgeConfigured?: boolean): Connection;
+/** Set KEY=value lines in a dotenv file, keeping every other line and the file's permissions. */
+export declare function writeEnvValues(file: string, values: Record<string, string>): void;