@relvo/mcp 0.0.0-stage → 0.1.1

package/dist/client/local-profile.js

@@ -0,0 +1,242 @@
+import { constants } from "node:fs";
+import { link, lstat, mkdir, open, realpath, rename, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { z } from "zod";
+import { platformLocalSetupClientSchema, platformLocalSetupStartSchema, platformLocalSetupProofSchema, platformLocalSetupPollSchema } from "./local-setup.js";
+import { configFromEnvironment, hasRelvoEnvironment } from "./index.js";
+const registeredSchema = z.object({ client: z.enum(["claude", "codex"]), name: z.string().regex(/^(?:relvo|toolhub)-[a-f0-9]{24}$/), command: z.string().min(1), args: z.array(z.string()).min(1) }).strict();
+const common = { managedBy: z.enum(["relvo-cli", "toolhub-cli"]), version: z.literal(1), apiUrl: z.string().url(), consoleUrl: z.string().url(), local: z.boolean(),
+    legacyProfileSha256: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    installationId: z.string().regex(/^[a-f0-9]{24}$/), registrations: z.array(registeredSchema).max(2).default([]) };
+export const localProfileSchema = z.discriminatedUnion("state", [
+    z.object({ ...common, state: z.literal("pending"), client: platformLocalSetupClientSchema, request: platformLocalSetupStartSchema }).strict(),
+    z.object({ ...common, state: z.literal("ready"), grant: platformLocalSetupPollSchema.options[1], pendingAck: platformLocalSetupProofSchema.optional() }).strict(),
+]);
+export const localProfilePath = (home = homedir()) => join(home, ".config", "relvo", "profile.json");
+export const legacyLocalProfilePath = (home = homedir()) => join(home, ".config", "toolhub", "profile.json");
+function owned(mode, uid, privateMode) {
+    if (typeof process.getuid === "function" && uid !== process.getuid() || mode & (privateMode ? 0o077 : 0o022))
+        throw new Error("Relvo local storage has unsafe ownership or permissions.");
+}
+export async function safeDirectory(path, create = false, privateMode = false) {
+    if (!isAbsolute(path) || resolve(path) !== path)
+        throw new Error("Relvo local paths must be canonical absolute paths.");
+    try {
+        const info = await lstat(path);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error("Relvo local directories must not be symlinks.");
+        owned(info.mode, info.uid, privateMode);
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT") || !create)
+            throw error;
+        await mkdir(path, { mode: privateMode ? 0o700 : 0o755 });
+        await safeDirectory(path, false, privateMode);
+    }
+}
+export async function profileDirectory(path = localProfilePath(), create = false) {
+    if (process.platform === "win32")
+        throw new Error("Relvo private local profiles currently require POSIX file permissions.");
+    if (!isAbsolute(path) || resolve(path) !== path || !/\/\.config\/(?:relvo|toolhub)\/profile\.json$/.test(path))
+        throw new Error("Use the canonical managed Relvo profile path.");
+    const root = dirname(dirname(dirname(path)));
+    if (await realpath(root) !== root)
+        throw new Error("Relvo profile home must be a canonical directory.");
+    await safeDirectory(root);
+    await safeDirectory(join(root, ".config"), create);
+    await safeDirectory(dirname(path), create, true);
+    return dirname(path);
+}
+export async function readPrivateText(path, maximumBytes = 65536) {
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const info = await handle.stat();
+        owned(info.mode, info.uid, true);
+        if (!info.isFile() || info.size > maximumBytes || info.nlink !== 1)
+            throw new Error("Relvo private file is invalid.");
+        return await handle.readFile("utf8");
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readPrivateJson(path, maximumBytes = 65536) { return JSON.parse(await readPrivateText(path, maximumBytes)); }
+export async function writePrivateText(path, value, privateParent = true, maximumBytes = 65536) {
+    const directory = dirname(path);
+    await safeDirectory(directory, false, privateParent);
+    if (Buffer.byteLength(value, "utf8") > maximumBytes)
+        throw new Error("Relvo private file exceeds its size limit.");
+    try {
+        await readPrivateText(path, maximumBytes);
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+    }
+    const temporary = join(directory, `.relvo-${randomUUID()}.tmp`);
+    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    let closed = false;
+    try {
+        await handle.writeFile(value);
+        await handle.sync();
+        await handle.close();
+        closed = true;
+        await rename(temporary, path);
+        const parent = await open(directory, constants.O_RDONLY);
+        try {
+            await parent.sync();
+        }
+        finally {
+            await parent.close();
+        }
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => { });
+        throw error;
+    }
+    finally {
+        if (!closed)
+            await handle.close();
+    }
+}
+export async function writePrivateJson(path, value, privateParent = true, maximumBytes = 65536) { await writePrivateText(path, JSON.stringify(value) + "\n", privateParent, maximumBytes); }
+export async function readLocalProfile(path = localProfilePath()) {
+    try {
+        path = await migratedProfileTarget(path);
+        let profile = await readOwnedProfile(path);
+        if (!profile && path.endsWith("/.config/relvo/profile.json")) {
+            const legacy = path.replace(/\/relvo\/profile\.json$/, "/toolhub/profile.json");
+            const previous = await readOwnedProfile(legacy);
+            if (previous) {
+                await assertLegacySetupIdle(legacy);
+                const raw = await readPrivateText(legacy);
+                const migrated = localProfileSchema.parse({ ...localProfileSchema.parse(JSON.parse(raw)), managedBy: "relvo-cli", legacyProfileSha256: digest(raw) });
+                await profileDirectory(path, true);
+                await createProfileExclusive(path, migrated);
+                profile = await readOwnedProfile(path);
+            }
+        }
+        if (!profile && path.endsWith("/.config/toolhub/profile.json"))
+            return readLocalProfile(path.replace(/\/toolhub\/profile\.json$/, "/relvo/profile.json"));
+        if (profile?.legacyProfileSha256)
+            await unchangedLegacyProfile(path, profile.legacyProfileSha256);
+        return profile;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw new Error("Relvo local profile is unsafe or invalid. No credentials were changed.");
+    }
+}
+const digest = (raw) => createHash("sha256").update(raw).digest("hex");
+async function createProfileExclusive(path, profile) {
+    const value = JSON.stringify(profile) + "\n";
+    if (Buffer.byteLength(value, "utf8") > 65536)
+        throw new Error("The migrated profile exceeds its private file limit.");
+    const temporary = join(dirname(path), `.relvo-migrate-${randomUUID()}.tmp`);
+    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        try {
+            await handle.writeFile(value);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        try {
+            await link(temporary, path);
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+                throw error;
+        }
+    }
+    finally {
+        await unlink(temporary);
+    }
+    const parent = await open(dirname(path), constants.O_RDONLY);
+    try {
+        await parent.sync();
+    }
+    finally {
+        await parent.close();
+    }
+}
+async function readOwnedProfile(path) {
+    try {
+        await profileDirectory(path);
+        return localProfileSchema.parse(await readPrivateJson(path));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function migratedProfileTarget(path) {
+    if (!path.endsWith("/.config/toolhub/profile.json"))
+        return path;
+    const canonical = path.replace(/\/toolhub\/profile\.json$/, "/relvo/profile.json");
+    const profile = await readOwnedProfile(canonical);
+    return profile && (profile.legacyProfileSha256 || !await readOwnedProfile(path)) ? canonical : path;
+}
+async function assertLegacySetupIdle(path) {
+    let lock;
+    try {
+        lock = z.object({ managedBy: z.enum(["toolhub-cli", "relvo-cli"]), pid: z.number().int().positive() }).strict().parse(await readPrivateJson(join(dirname(path), "setup.lock")));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    try {
+        process.kill(lock.pid, 0);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ESRCH")
+            return;
+        throw error;
+    }
+    throw new Error("The existing setup is active. Wait for it to finish before migrating.");
+}
+async function unchangedLegacyProfile(path, expected) {
+    if (!path.endsWith("/.config/relvo/profile.json"))
+        throw new Error("Invalid migrated profile path");
+    const legacy = path.replace(/\/relvo\/profile\.json$/, "/toolhub/profile.json");
+    if (!await readOwnedProfile(legacy))
+        return null;
+    if (digest(await readPrivateText(legacy)) !== expected)
+        throw new Error("The existing profile changed after migration and was preserved.");
+    return legacy;
+}
+export async function writeLocalProfile(path, profile) {
+    path = await migratedProfileTarget(path);
+    await profileDirectory(path, true);
+    const previous = await readLocalProfile(path);
+    await writePrivateJson(path, localProfileSchema.parse({ ...profile, managedBy: "relvo-cli", ...(previous?.legacyProfileSha256 ? { legacyProfileSha256: previous.legacyProfileSha256 } : {}) }));
+}
+export async function removeLocalProfile(path) {
+    path = await migratedProfileTarget(path);
+    const profile = await readLocalProfile(path);
+    if (profile) {
+        const legacy = profile.legacyProfileSha256 ? await unchangedLegacyProfile(path, profile.legacyProfileSha256) : null;
+        if (legacy)
+            await unlink(legacy);
+        await unlink(path);
+    }
+}
+export async function runtimeConfig(env, source, profile, requireProfileMatch = false) {
+    const hasEnvironment = hasRelvoEnvironment(env) || ["NOIMOS_PLATFORM_API_URL", "NOIMOS_PLATFORM_API_KEY"].some((name) => env[name] !== undefined);
+    const environment = hasEnvironment || !profile ? configFromEnvironment(env, source) : null;
+    if (environment && (!profile || !requireProfileMatch))
+        return environment;
+    const saved = await readLocalProfile(profile);
+    if (!saved || saved.state !== "ready" || saved.pendingAck || Date.parse(saved.grant.expiresAt) <= Date.now())
+        throw new Error("Relvo login is missing, incomplete or expired. Run relvo setup to resume.");
+    if (environment && (environment.apiUrl.replace(/\/$/, "") !== saved.apiUrl || environment.apiKey !== saved.grant.apiKey || Boolean(environment.local) !== saved.local))
+        throw new Error("Ambient Relvo credentials conflict with the explicitly selected managed profile. No project was selected.");
+    return { apiUrl: saved.apiUrl, apiKey: saved.grant.apiKey, local: saved.local, source };
+}

package/dist/client/local-setup.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { PLATFORM_CLIENT_HEADERS } from "../schema/platformApiKey.js";
+import { platformLocalSetupStartInputSchema, platformLocalSetupStartSchema, platformLocalSetupProofSchema, platformLocalSetupPollSchema, platformLocalSetupAcknowledgedSchema } from "../schema/platformLocalSetup.js";
+export { platformLocalSetupClientSchema, platformLocalSetupStartInputSchema, platformLocalSetupStartSchema, platformLocalSetupProofSchema, platformLocalSetupPollSchema, platformLocalSetupAcknowledgedSchema } from "../schema/platformLocalSetup.js";
+export function relvoApiUrl(value, local = false) {
+    const url = new URL(value);
+    if (url.username || url.password || url.search || url.hash || (url.protocol !== "https:" && !(local && url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))))
+        throw new Error("Relvo URLs must use HTTPS; --local permits loopback HTTP only.");
+    return url.href.replace(/\/$/, "");
+}
+export const toolhubApiUrl = relvoApiUrl;
+export function verificationUrl(value, consoleUrl, authorizationRequest, local = false) {
+    const trusted = new URL(relvoApiUrl(consoleUrl, local));
+    if (trusted.pathname !== "/")
+        throw new Error("Provide the Relvo console origin without a path.");
+    const url = new URL(value);
+    if (url.origin !== trusted.origin || url.pathname !== "/local-setup" || url.username || url.password || url.hash ||
+        [...url.searchParams.keys()].length !== 1 || url.searchParams.get("request") !== authorizationRequest)
+        throw new Error("Relvo returned an unexpected verification URL. No browser was opened.");
+    return url.href;
+}
+const publicSetupErrors = {
+    platform_local_setup_unavailable: "Local setup is unavailable on this Relvo server.",
+    platform_local_setup_invalid: "The local setup proof is invalid. No credentials were replaced.",
+    platform_local_setup_expired: "The local setup request expired. Run setup again after checking its saved state.",
+    platform_local_setup_conflict: "This setup request was already used for a different approval.",
+    platform_local_setup_rate_exceeded: "The local setup request limit was reached. Wait before trying again.",
+};
+export class LocalSetupClient {
+    transport;
+    baseUrl;
+    constructor(apiUrl, local = false, transport = fetch) {
+        this.transport = transport;
+        this.baseUrl = relvoApiUrl(apiUrl, local);
+    }
+    async request(operation, body, schema) {
+        let response;
+        try {
+            response = await this.transport(`${this.baseUrl}/tools/setup/${operation}`, { method: "POST", redirect: "error", signal: AbortSignal.timeout(20000),
+                headers: { "content-type": "application/json", [PLATFORM_CLIENT_HEADERS.relvo]: "cli" }, body: JSON.stringify(body) });
+        }
+        catch {
+            throw new Error("Relvo setup could not be reached. Rerun setup to resume its saved request; do not create another key manually.");
+        }
+        let payload;
+        try {
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new Error("Missing body");
+            const chunks = [];
+            let size = 0;
+            try {
+                for (;;) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    size += value.byteLength;
+                    if (size > 32768) {
+                        await reader.cancel();
+                        throw new Error("Response too large");
+                    }
+                    chunks.push(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            const bytes = new Uint8Array(size);
+            let offset = 0;
+            for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            payload = JSON.parse(new TextDecoder().decode(bytes));
+        }
+        catch {
+            throw new Error("Relvo setup returned an invalid response. Rerun setup to resume the saved request.");
+        }
+        if (!response.ok) {
+            const error = z.object({ error: z.object({ message: z.string() }) }).safeParse(payload);
+            throw new Error(error.success && Object.hasOwn(publicSetupErrors, error.data.error.message) ? publicSetupErrors[error.data.error.message] : `Relvo setup request failed (${response.status}). No server details were printed.`);
+        }
+        const envelope = z.object({ data: z.unknown() }).safeParse(payload);
+        const result = schema.safeParse(envelope.success ? envelope.data.data : undefined);
+        if (!result.success)
+            throw new Error("Relvo setup returned an unexpected response. Rerun setup to resume the saved request.");
+        return result.data;
+    }
+    start(input) { return this.request("start", platformLocalSetupStartInputSchema.parse(input), platformLocalSetupStartSchema); }
+    poll(input) { return this.request("poll", platformLocalSetupProofSchema.parse(input), platformLocalSetupPollSchema); }
+    acknowledge(input) { return this.request("ack", platformLocalSetupProofSchema.parse(input), platformLocalSetupAcknowledgedSchema); }
+}

package/dist/client/realtime-voice.js

@@ -0,0 +1,184 @@
+import { z } from "zod";
+import { platformJsonObjectSchema } from "../schema/platformPublicExecution.js";
+const protocol = z.enum(["gemini-live", "openai-live", "openai-realtime"]);
+export const realtimeVoiceConfigSchema = z.object({
+    model: z.string().min(1).max(100), priceVersion: z.string().min(1).max(40),
+    maximumChargeMicros: z.number().int().safe().min(50000).max(10000000).optional(),
+    maxDurationSeconds: z.number().int().min(1).max(300).optional(), maxOutputTokens: z.number().int().min(1).max(2048).optional(),
+    instructions: z.string().max(8000).optional(), locale: z.string().max(40).optional(), voice: z.string().max(80).optional(),
+    tools: z.array(z.object({ name: z.string(), description: z.string().optional(), parameters: platformJsonObjectSchema }).strict()).max(16).optional(),
+    clientOrigin: z.string().max(300).optional(),
+}).strict();
+export const realtimeVoiceModelsSchema = z.object({
+    priceVersion: z.string(), executionEnabled: z.boolean(),
+    models: z.array(z.object({ id: z.string(), provider: z.string(), protocol, inputSampleRate: z.number().int().positive(),
+        outputSampleRate: z.number().int().positive(), tools: z.enum(["functions", "delegation"]), configured: z.boolean() })),
+});
+export const realtimeVoiceGrantSchema = z.object({
+    clientSecret: z.string().min(1).max(2048), expiresAt: z.number().int(), path: z.literal("/v1/realtime"), protocol: z.literal("relvo-realtime"),
+    config: realtimeVoiceConfigSchema,
+});
+const startedSchema = z.object({ type: z.literal("relvo.session.started"), executionId: z.string().uuid(), model: z.string(), protocol,
+    inputSampleRate: z.number().int().positive(), outputSampleRate: z.number().int().positive() });
+const closedSchema = z.object({ type: z.literal("relvo.session.closed"), executionId: z.string().uuid().nullable(), usageConfirmed: z.boolean(),
+    status: z.enum(["succeeded", "failed", "cancelled", "needs_review"]), providerCostMicros: z.number().int().nonnegative() });
+export class RealtimeVoiceError extends Error {
+    executionId;
+    constructor(message, executionId) {
+        super(message);
+        this.executionId = executionId;
+        this.name = "RealtimeVoiceError";
+    }
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export class RealtimeVoiceSession {
+    socket;
+    session;
+    requestClose;
+    closed;
+    constructor(socket, session, closed, requestClose) {
+        this.socket = socket;
+        this.session = session;
+        this.requestClose = requestClose;
+        this.closed = closed;
+    }
+    static connect(apiUrl, rawGrant, options = {}) {
+        const grant = realtimeVoiceGrantSchema.parse(rawGrant), url = new URL(grant.path, apiUrl), base = new URL(apiUrl);
+        if (base.username || base.password || base.search || base.hash || !["http:", "https:"].includes(base.protocol)
+            || (base.protocol === "http:" && !["127.0.0.1", "localhost", "[::1]"].includes(base.hostname)))
+            throw new Error("Use an HTTPS voice API URL or loopback HTTP.");
+        if (grant.expiresAt <= Date.now() / 1000)
+            throw new Error("Voice connection token expired. Request a new one.");
+        options.signal?.throwIfAborted();
+        url.protocol = base.protocol === "https:" ? "wss:" : "ws:";
+        const socket = (options.createWebSocket ?? ((target, protocols) => new WebSocket(target, protocols)))(url.href, [grant.protocol, `relvo-session.${grant.clientSecret}`]);
+        let complete = false, ready = false, closing = false, executionId = null, closeTimer, rejectReady = () => { };
+        let resolveClosed = () => { }, rejectClosed = () => { };
+        const closed = new Promise((resolve, reject) => { resolveClosed = resolve; rejectClosed = reject; });
+        void closed.catch(() => { });
+        const failure = (message) => { const error = new RealtimeVoiceError(message, executionId); rejectReady(error); rejectClosed(error); socket.close(); };
+        const cancelled = () => {
+            if (closing || complete)
+                return;
+            closing = true;
+            if (socket.readyState === 1)
+                socket.send(JSON.stringify({ type: "relvo.session.close" }));
+            else
+                socket.close();
+            closeTimer = setTimeout(() => failure("Voice finalization timed out. Read the execution receipt before retrying."), 25000);
+        };
+        options.signal?.addEventListener("abort", cancelled, { once: true });
+        socket.addEventListener("close", () => {
+            clearTimeout(timer);
+            clearTimeout(closeTimer);
+            options.signal?.removeEventListener("abort", cancelled);
+            if (!complete)
+                failure("Voice disconnected before final usage was confirmed. Read the execution receipt before retrying.");
+        }, { once: true });
+        socket.addEventListener("error", () => failure("The Relvo voice connection failed."), { once: true });
+        const timer = setTimeout(() => failure("Voice session setup timed out."), 25000);
+        return new Promise((resolve, reject) => {
+            rejectReady = reject;
+            socket.addEventListener("open", () => socket.send(JSON.stringify({ type: "relvo.session.configure", config: grant.config })), { once: true });
+            socket.addEventListener("message", event => {
+                let value;
+                try {
+                    if (typeof event.data !== "string" || event.data.length > 1500000)
+                        throw new Error("Invalid voice event");
+                    value = JSON.parse(event.data);
+                }
+                catch {
+                    failure("Invalid Relvo voice event.");
+                    return;
+                }
+                if (!isRecord(value)) {
+                    failure("Invalid Relvo voice event.");
+                    return;
+                }
+                if (typeof value.executionId === "string" && z.string().uuid().safeParse(value.executionId).success)
+                    executionId = value.executionId;
+                const started = startedSchema.safeParse(value), ended = closedSchema.safeParse(value);
+                if (started.success && !ready) {
+                    ready = true;
+                    clearTimeout(timer);
+                    resolve(new RealtimeVoiceSession(socket, started.data, closed, cancelled));
+                }
+                if (ended.success) {
+                    complete = true;
+                    clearTimeout(closeTimer);
+                    resolveClosed(ended.data);
+                    if (!ready)
+                        reject(new Error("Voice session ended during setup."));
+                    socket.close();
+                }
+                if (value.type === "relvo.error" && !ready)
+                    reject(new RealtimeVoiceError(`Voice session rejected: ${typeof value.code === "string" ? value.code : "unknown"}`, executionId));
+                try {
+                    if (typeof value.delta === "string" && ["session.output_audio.delta", "response.output_audio.delta", "response.audio.delta"].includes(String(value.type)))
+                        options.onAudio?.(value.delta, 24000);
+                    if (isRecord(value.serverContent) && isRecord(value.serverContent.modelTurn) && Array.isArray(value.serverContent.modelTurn.parts)) {
+                        for (const part of value.serverContent.modelTurn.parts)
+                            if (isRecord(part) && isRecord(part.inlineData)
+                                && typeof part.inlineData.data === "string" && typeof part.inlineData.mimeType === "string" && part.inlineData.mimeType.startsWith("audio/pcm"))
+                                options.onAudio?.(part.inlineData.data, 24000);
+                    }
+                    options.onEvent?.(value);
+                }
+                catch {
+                    failure("The voice event handler failed. Read the execution receipt before retrying.");
+                }
+            });
+            if (options.signal?.aborted)
+                cancelled();
+        });
+    }
+    send(event) {
+        if (this.socket.readyState !== 1 || this.socket.bufferedAmount > 1024 * 1024)
+            throw new Error("Voice is closed or its send buffer is full.");
+        const data = JSON.stringify(event);
+        if (new TextEncoder().encode(data).length > 65536)
+            throw new Error("Voice frame exceeds 64 KiB.");
+        this.socket.send(data);
+    }
+    sendAudio(audio) {
+        if (!audio || audio.length > 64000 || audio.length % 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(audio))
+            throw new Error("Provide a bounded base64 PCM16 frame.");
+        if (this.session.protocol === "gemini-live")
+            this.send({ realtimeInput: { audio: { data: audio, mimeType: `audio/pcm;rate=${this.session.inputSampleRate}` } } });
+        else
+            this.send({ type: this.session.protocol === "openai-live" ? "session.input_audio.append" : "input_audio_buffer.append", audio });
+    }
+    sendText(text) {
+        if (this.session.protocol === "gemini-live")
+            this.send({ clientContent: { turns: [{ role: "user", parts: [{ text }] }], turnComplete: true } });
+        else if (this.session.protocol === "openai-live")
+            this.sendDelegationResult(null, text);
+        else {
+            this.send({ type: "conversation.item.create", item: { type: "message", role: "user", content: [{ type: "input_text", text }] } });
+            this.send({ type: "response.create" });
+        }
+    }
+    sendToolResult(call) {
+        this.sendToolResults([call]);
+    }
+    sendToolResults(calls) {
+        if (!calls.length || calls.length > 16)
+            throw new Error("Return between one and sixteen tool results.");
+        if (this.session.protocol === "openai-live")
+            throw new Error("GPT-Live uses sendDelegationResult instead of function calls.");
+        if (this.session.protocol === "gemini-live")
+            this.send({ toolResponse: { functionResponses: calls.map(call => ({ id: call.id, name: call.name, response: call.output })) } });
+        else {
+            for (const call of calls)
+                this.send({ type: "conversation.item.create", item: { type: "function_call_output", call_id: call.id, output: JSON.stringify(call.output) } });
+            this.send({ type: "response.create" });
+        }
+    }
+    sendDelegationResult(delegationId, content) {
+        if (this.session.protocol !== "openai-live")
+            throw new Error("This model uses function calls instead of client delegation.");
+        this.send({ type: "session.commentary.append", delegation_id: delegationId, content });
+    }
+    close() { this.requestClose(); return this.closed; }
+}
+export const connectRealtimeVoice = RealtimeVoiceSession.connect;

package/dist/mcp/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { startPlatformMcp } from "./runtime.js";
+await startPlatformMcp();

package/dist/mcp/local-upload.js

@@ -0,0 +1,45 @@
+import { lstat, realpath, stat } from "node:fs/promises";
+import { basename, delimiter, isAbsolute, relative, resolve, sep } from "node:path";
+import { uploadLocalInput } from "../client/local-input.js";
+const sensitiveDirectories = new Set([
+    ".ssh", ".aws", ".gcloud", ".kube", ".config", ".git",
+    ".claude", ".agents", ".codex", ".cursor", "_sessions",
+]);
+export async function uploadAuthorizedFile(client, filePath, configuredRoots) {
+    const roots = (configuredRoots ?? "").split(delimiter).map((root) => root.trim()).filter(Boolean);
+    if (!roots.length)
+        throw new Error("Local uploads are disabled. Set RELVO_MCP_ALLOWED_UPLOAD_ROOTS to the directories this MCP server may read.");
+    const allowed = await Promise.all(roots.map(async (root) => {
+        try {
+            if (!isAbsolute(root))
+                throw new Error("Relative root");
+            const canonical = await realpath(root);
+            if (!(await stat(canonical)).isDirectory())
+                throw new Error("Not a directory");
+            return canonical;
+        }
+        catch {
+            throw new Error("RELVO_MCP_ALLOWED_UPLOAD_ROOTS must contain existing absolute directories.");
+        }
+    }));
+    let canonical;
+    try {
+        const requested = resolve(filePath);
+        if (!(await lstat(requested)).isFile())
+            throw new Error("Not a regular file");
+        canonical = await realpath(requested);
+    }
+    catch {
+        throw new Error("Input must be an existing regular file. Symlinks are not accepted.");
+    }
+    if (!allowed.some((root) => {
+        const child = relative(root, canonical);
+        return child !== "" && !isAbsolute(child) && child !== ".." && !child.startsWith(`..${sep}`);
+    }))
+        throw new Error("File is outside RELVO_MCP_ALLOWED_UPLOAD_ROOTS.");
+    const name = basename(canonical).toLowerCase();
+    if (canonical.split(sep).some((part) => sensitiveDirectories.has(part.toLowerCase())) || name.startsWith(".env")) {
+        throw new Error("Refusing to upload a credential or secret path.");
+    }
+    return uploadLocalInput(client, canonical);
+}

package/dist/mcp/runtime.js

@@ -0,0 +1,28 @@
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { configFromEnvironment, PlatformClient } from "../client/index.js";
+import { createPlatformMcp } from "./server.js";
+import { runtimeConfig } from "../client/local-profile.js";
+export async function startPlatformMcp(version = "0.1.1", profile) {
+    let handle;
+    try {
+        const client = new PlatformClient(profile ? await runtimeConfig(process.env, "mcp", profile, true) : configFromEnvironment(process.env, "mcp"));
+        handle = serveStdio(() => createPlatformMcp(client, version, true, Boolean(profile)), {
+            onerror: () => {
+                process.stderr.write(JSON.stringify({ severity: "ERROR", message: "Relvo MCP protocol error." }) + "\n");
+            },
+        });
+        const shutdown = async () => {
+            await handle?.close();
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    catch {
+        process.stderr.write(JSON.stringify({
+            severity: "ERROR",
+            message: "Relvo MCP could not start. Check RELVO_API_URL and RELVO_API_KEY.",
+        }) + "\n");
+        process.exitCode = 1;
+    }
+}