@slopus/rig 0.0.1

package/dist/client/ProtocolHttpClient.js

@@ -0,0 +1,181 @@
+import { request as httpRequest } from "node:http";
+export class ProtocolHttpClient {
+    socketPath;
+    token;
+    constructor(options) {
+        this.socketPath = options.socketPath;
+        this.token = options.token;
+    }
+    abort(sessionId) {
+        return this.#requestJson("POST", `/sessions/${encodeURIComponent(sessionId)}/abort`);
+    }
+    changeModel(sessionId, request) {
+        return this.#requestJson("PATCH", `/sessions/${encodeURIComponent(sessionId)}/model`, request);
+    }
+    changeEffort(sessionId, request) {
+        return this.#requestJson("PATCH", `/sessions/${encodeURIComponent(sessionId)}/effort`, request);
+    }
+    createSession(request) {
+        return this.#requestJson("POST", "/sessions", request);
+    }
+    health() {
+        return this.#requestJson("GET", "/health");
+    }
+    models() {
+        return this.#requestJson("GET", "/models");
+    }
+    listSessions(limit) {
+        const path = limit === undefined ? "/sessions" : `/sessions?limit=${encodeURIComponent(limit)}`;
+        return this.#requestJson("GET", path);
+    }
+    listSubagents(sessionId) {
+        return this.#requestJson("GET", `/sessions/${encodeURIComponent(sessionId)}/subagents`);
+    }
+    getSession(sessionId) {
+        return this.#requestJson("GET", `/sessions/${encodeURIComponent(sessionId)}`);
+    }
+    getEvents(sessionId, after) {
+        const path = after === undefined
+            ? `/sessions/${encodeURIComponent(sessionId)}/events`
+            : `/sessions/${encodeURIComponent(sessionId)}/events?after=${encodeURIComponent(after)}`;
+        return this.#requestJson("GET", path);
+    }
+    reset(sessionId) {
+        return this.#requestJson("POST", `/sessions/${encodeURIComponent(sessionId)}/reset`);
+    }
+    shutdown() {
+        return this.#requestJson("POST", "/shutdown");
+    }
+    submitMessage(sessionId, request) {
+        return this.#requestJson("POST", `/sessions/${encodeURIComponent(sessionId)}/messages`, request);
+    }
+    async watchSessionEvents(options) {
+        let after = options.after;
+        while (options.signal?.aborted !== true) {
+            try {
+                after = await this.#watchSessionEventsOnce(after, options);
+            }
+            catch {
+                if (options.signal?.aborted) {
+                    return;
+                }
+                await delay(50, options.signal);
+            }
+        }
+    }
+    async #requestJson(method, path, body) {
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        const headers = {
+            accept: "application/json",
+            authorization: `Bearer ${this.token}`,
+        };
+        if (payload !== undefined) {
+            headers["content-length"] = Buffer.byteLength(payload);
+            headers["content-type"] = "application/json; charset=utf-8";
+        }
+        return new Promise((resolve, reject) => {
+            const request = httpRequest({
+                headers,
+                method,
+                path,
+                socketPath: this.socketPath,
+            }, (response) => {
+                const chunks = [];
+                response.on("data", (chunk) => {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                });
+                response.on("end", () => {
+                    const text = Buffer.concat(chunks).toString("utf8");
+                    if ((response.statusCode ?? 500) >= 400) {
+                        reject(new Error(text.length > 0 ? text : `HTTP ${response.statusCode}`));
+                        return;
+                    }
+                    resolve((text.length === 0 ? {} : JSON.parse(text)));
+                });
+            });
+            request.on("error", reject);
+            if (payload !== undefined) {
+                request.write(payload);
+            }
+            request.end();
+        });
+    }
+    #watchSessionEventsOnce(after, options) {
+        return new Promise((resolve, reject) => {
+            const requestPath = after === undefined
+                ? `/sessions/${encodeURIComponent(options.sessionId)}/stream`
+                : `/sessions/${encodeURIComponent(options.sessionId)}/stream?after=${encodeURIComponent(after)}`;
+            const request = httpRequest({
+                headers: {
+                    accept: "text/event-stream",
+                    authorization: `Bearer ${this.token}`,
+                },
+                method: "GET",
+                path: requestPath,
+                socketPath: this.socketPath,
+            }, (response) => {
+                if ((response.statusCode ?? 500) >= 400) {
+                    reject(new Error(`SSE failed with HTTP ${response.statusCode}`));
+                    response.resume();
+                    return;
+                }
+                let cursor = after;
+                let buffer = "";
+                response.setEncoding("utf8");
+                response.on("data", (chunk) => {
+                    buffer += chunk;
+                    for (;;) {
+                        const boundary = buffer.indexOf("\n\n");
+                        if (boundary < 0) {
+                            break;
+                        }
+                        const rawEvent = buffer.slice(0, boundary);
+                        buffer = buffer.slice(boundary + 2);
+                        const event = parseSseEvent(rawEvent);
+                        if (event === undefined) {
+                            continue;
+                        }
+                        cursor = event.id;
+                        Promise.resolve(options.onEvent(event)).catch(reject);
+                    }
+                });
+                response.on("end", () => resolve(cursor));
+                response.on("error", reject);
+            });
+            const abort = () => {
+                request.destroy();
+                resolve(after);
+            };
+            options.signal?.addEventListener("abort", abort, { once: true });
+            request.on("error", reject);
+            request.end();
+        });
+    }
+}
+function parseSseEvent(raw) {
+    if (raw.startsWith(":")) {
+        return undefined;
+    }
+    const dataLines = raw
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trimStart());
+    if (dataLines.length === 0) {
+        return undefined;
+    }
+    return JSON.parse(dataLines.join("\n"));
+}
+function delay(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted === true) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        timer.unref?.();
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}

package/dist/client/RemoteAgent.d.ts

@@ -0,0 +1,28 @@
+import type { AgentContext, AgentRunOptions, AgentRunResult, AgentSnapshot, ContentBlock } from "../agent/index.js";
+import type { CodingAssistantAgentBackend, CodingAssistantModelChoice } from "../app/CodingAssistantAgentBackend.js";
+import type { ModelCatalog, ProtocolSession, SessionEvent } from "../protocol/index.js";
+import { type Model, type Provider } from "../providers/types.js";
+import { ProtocolHttpClient } from "./ProtocolHttpClient.js";
+export interface RemoteAgentOptions {
+    client: ProtocolHttpClient;
+    context: AgentContext;
+    modelCatalog?: ModelCatalog;
+    session: ProtocolSession;
+}
+export declare class RemoteAgent implements CodingAssistantAgentBackend {
+    #private;
+    readonly context: AgentContext;
+    readonly id: string;
+    constructor(options: RemoteAgentOptions);
+    get canChangeModel(): boolean;
+    get provider(): Provider;
+    get model(): Model;
+    get modelChoices(): readonly CodingAssistantModelChoice[];
+    reset(): void;
+    send(content: string | readonly ContentBlock[], options?: AgentRunOptions): Promise<AgentRunResult>;
+    setEffort(effort: string | undefined): void;
+    setModel(modelId: string, effort: string | undefined, providerId?: string): void;
+    snapshot(): AgentSnapshot;
+    applySessionEvent(event: SessionEvent): void;
+}
+//# sourceMappingURL=RemoteAgent.d.ts.map

package/dist/client/RemoteAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteAgent.d.ts","sourceRoot":"","sources":["../../sources/client/RemoteAgent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,YAAY,EACZ,eAAe,EACf,cAAc,EACd,aAAa,EACb,YAAY,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACR,2BAA2B,EAC3B,0BAA0B,EAC7B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,EAAkB,KAAK,KAAK,EAAE,KAAK,QAAQ,EAAmB,MAAM,uBAAuB,CAAC;AACnG,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,YAAY,CAAC;IACtB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,OAAO,EAAE,eAAe,CAAC;CAC5B;AAED,qBAAa,WAAY,YAAW,2BAA2B;;IAC3D,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBASR,OAAO,EAAE,kBAAkB;IAWvC,IAAI,cAAc,IAAI,OAAO,CAE5B;IAED,IAAI,QAAQ,IAAI,QAAQ,CAQvB;IAED,IAAI,KAAK,IAAI,KAAK,CAMjB;IAED,IAAI,YAAY,IAAI,SAAS,0BAA0B,EAAE,CAMxD;IAED,KAAK,IAAI,IAAI;IAiBP,IAAI,CACN,OAAO,EAAE,MAAM,GAAG,SAAS,YAAY,EAAE,EACzC,OAAO,GAAE,eAAoB,GAC9B,OAAO,CAAC,cAAc,CAAC;IA0E1B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAe3C,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IA4ChF,QAAQ,IAAI,aAAa;IAIzB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;CAuF/C"}

package/dist/client/RemoteAgent.js

@@ -0,0 +1,270 @@
+import { defineProvider } from "../providers/types.js";
+import { ProtocolHttpClient } from "./ProtocolHttpClient.js";
+export class RemoteAgent {
+    context;
+    id;
+    #client;
+    #modelId;
+    #modelCatalog;
+    #models;
+    #providerId;
+    #session;
+    constructor(options) {
+        this.#client = options.client;
+        this.#session = options.session;
+        this.#modelCatalog = options.modelCatalog;
+        this.context = options.context;
+        this.id = options.session.agentId;
+        this.#modelId = options.session.modelId;
+        this.#models = options.session.models;
+        this.#providerId = options.session.providerId;
+    }
+    get canChangeModel() {
+        return !this.#session.modelLocked;
+    }
+    get provider() {
+        return defineProvider({
+            id: this.#providerId,
+            models: this.#models,
+            stream() {
+                throw new Error("RemoteAgent does not expose provider streaming locally.");
+            },
+        });
+    }
+    get model() {
+        const model = this.#models.find((candidate) => candidate.id === this.#modelId);
+        if (model === undefined) {
+            throw new Error(`Unknown remote model '${this.#modelId}'.`);
+        }
+        return model;
+    }
+    get modelChoices() {
+        return (this.#modelCatalog?.providers.flatMap((provider) => provider.models.map((model) => ({ model, providerId: provider.providerId }))) ?? this.#models.map((model) => ({ model, providerId: this.#providerId })));
+    }
+    reset() {
+        this.#session = {
+            ...this.#session,
+            modelLocked: false,
+            status: "idle",
+            snapshot: {
+                ...this.#session.snapshot,
+                messages: [],
+                queue: [],
+                status: "idle",
+            },
+        };
+        void this.#client.reset(this.#session.id).then((response) => {
+            this.#replaceSession(response.session);
+        });
+    }
+    async send(content, options = {}) {
+        const displayText = options.displayText ?? contentToDisplayText(content);
+        const submitted = await this.#client.submitMessage(this.#session.id, {
+            ...(typeof content === "string" ? {} : { content }),
+            ...(options.displayText !== undefined ? { displayText: options.displayText } : {}),
+            text: displayText,
+        });
+        const streamController = new AbortController();
+        let finished;
+        let failure;
+        let aborted = false;
+        const abort = () => {
+            aborted = true;
+            void this.#client.abort(this.#session.id);
+        };
+        options.signal?.addEventListener("abort", abort, { once: true });
+        await this.#client.watchSessionEvents({
+            after: submitted.eventId,
+            sessionId: this.#session.id,
+            signal: streamController.signal,
+            onEvent: async (event) => {
+                if (!isRunEvent(event, submitted.runId)) {
+                    return;
+                }
+                this.applySessionEvent(event);
+                if (event.type === "run_error") {
+                    failure = new Error(event.data.errorMessage);
+                    streamController.abort();
+                    return;
+                }
+                if (event.type === "run_finished") {
+                    finished = {
+                        ...(event.data.agentRunId !== undefined
+                            ? { agentRunId: event.data.agentRunId }
+                            : {}),
+                        messages: this.#session.snapshot.messages,
+                        stopReason: event.data.stopReason,
+                    };
+                    streamController.abort();
+                }
+            },
+        });
+        options.signal?.removeEventListener("abort", abort);
+        if (failure !== undefined) {
+            throw failure;
+        }
+        if (finished === undefined) {
+            return {
+                messages: this.#session.snapshot.messages,
+                runId: submitted.runId,
+                stopReason: aborted ? "aborted" : "error",
+            };
+        }
+        return {
+            messages: finished.messages,
+            runId: finished.agentRunId ?? submitted.runId,
+            stopReason: finished.stopReason,
+        };
+    }
+    setEffort(effort) {
+        this.#session = {
+            ...this.#session,
+            ...(effort !== undefined ? { effort } : {}),
+            snapshot: {
+                ...this.#session.snapshot,
+                ...(effort !== undefined ? { effort } : {}),
+            },
+        };
+        const request = effort !== undefined ? { effort } : {};
+        void this.#client.changeEffort(this.#session.id, request).then((response) => {
+            this.#replaceSession(response.session);
+        });
+    }
+    setModel(modelId, effort, providerId) {
+        const nextProviderId = providerId ?? this.#providerId;
+        if (!this.canChangeModel &&
+            (modelId !== this.#modelId || nextProviderId !== this.#providerId)) {
+            this.setEffort(effort);
+            return;
+        }
+        const nextModels = this.#modelCatalog?.providers.find((provider) => provider.providerId === nextProviderId)
+            ?.models ?? this.#models;
+        if (!nextModels.some((model) => model.id === modelId)) {
+            throw new Error(`Unknown remote model '${modelId}' for provider '${nextProviderId}'.`);
+        }
+        this.#modelId = modelId;
+        this.#models = nextModels;
+        this.#providerId = nextProviderId;
+        this.#session = {
+            ...this.#session,
+            ...(effort !== undefined ? { effort } : {}),
+            modelId,
+            models: nextModels,
+            providerId: nextProviderId,
+            snapshot: {
+                ...this.#session.snapshot,
+                ...(effort !== undefined ? { effort } : {}),
+                modelId,
+                providerId: nextProviderId,
+            },
+        };
+        void this.#client
+            .changeModel(this.#session.id, {
+            ...(effort !== undefined ? { effort } : {}),
+            modelId,
+            providerId: nextProviderId,
+        })
+            .then((response) => {
+            this.#replaceSession(response.session);
+        });
+    }
+    snapshot() {
+        return this.#session.snapshot;
+    }
+    applySessionEvent(event) {
+        if (event.sessionId !== this.#session.id) {
+            return;
+        }
+        if (event.type === "session_created") {
+            this.#replaceSession(event.data.session);
+            return;
+        }
+        if (event.type === "message_submitted") {
+            this.#session = {
+                ...this.#session,
+                modelLocked: true,
+                status: this.#session.status === "running" ? "running" : "queued",
+                snapshot: {
+                    ...this.#session.snapshot,
+                    messages: appendUniqueMessage(this.#session.snapshot.messages, event.data.message),
+                },
+            };
+            return;
+        }
+        if (event.type === "agent_message") {
+            this.#session = {
+                ...this.#session,
+                snapshot: {
+                    ...this.#session.snapshot,
+                    messages: appendUniqueMessage(this.#session.snapshot.messages, event.data.message),
+                },
+            };
+            return;
+        }
+        if (event.type === "run_started") {
+            this.#session = { ...this.#session, status: "running" };
+            return;
+        }
+        if (event.type === "run_error") {
+            this.#session = { ...this.#session, status: "error" };
+            return;
+        }
+        if (event.type === "run_finished") {
+            this.#session = {
+                ...this.#session,
+                status: event.data.stopReason === "aborted" ? "aborted" : "completed",
+            };
+            return;
+        }
+        if (event.type === "session_reset") {
+            this.#session = {
+                ...this.#session,
+                modelLocked: false,
+                snapshot: event.data.snapshot,
+                status: "idle",
+            };
+            return;
+        }
+        if (event.type === "model_changed" || event.type === "effort_changed") {
+            this.#modelId = event.data.modelId;
+            this.#providerId = event.data.snapshot.providerId;
+            this.#session = {
+                ...this.#session,
+                ...(event.data.effort !== undefined ? { effort: event.data.effort } : {}),
+                modelId: event.data.modelId,
+                providerId: event.data.snapshot.providerId,
+                snapshot: event.data.snapshot,
+            };
+        }
+    }
+    #replaceSession(session) {
+        this.#session = session;
+        this.#modelId = session.modelId;
+        this.#models = session.models;
+        this.#providerId = session.providerId;
+    }
+}
+function appendUniqueMessage(messages, message) {
+    if (messages.some((candidate) => candidate.id === message.id)) {
+        return messages;
+    }
+    return [...messages, message];
+}
+function isRunEvent(event, runId) {
+    if (event.type !== "agent_event" &&
+        event.type !== "agent_message" &&
+        event.type !== "run_error" &&
+        event.type !== "run_finished" &&
+        event.type !== "run_started") {
+        return false;
+    }
+    return event.data.runId === runId;
+}
+function contentToDisplayText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .map((block) => (block.type === "text" ? block.text : `[image:${block.mediaType}]`))
+        .join("");
+}

package/dist/client/ensureLocalProtocolServer.d.ts

@@ -0,0 +1,13 @@
+import { type LocalServerPaths } from "../server/index.js";
+import { ProtocolHttpClient } from "./ProtocolHttpClient.js";
+export interface LocalProtocolServerConnection {
+    client: ProtocolHttpClient;
+    paths: LocalServerPaths;
+    token: string;
+}
+export interface EnsureLocalProtocolServerOptions {
+    onStatus?: (message: string) => void;
+}
+export declare function ensureLocalProtocolServer(options?: EnsureLocalProtocolServerOptions): Promise<LocalProtocolServerConnection>;
+export declare function readTokenIfPresent(tokenPath: string): Promise<string | undefined>;
+//# sourceMappingURL=ensureLocalProtocolServer.d.ts.map

package/dist/client/ensureLocalProtocolServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureLocalProtocolServer.d.ts","sourceRoot":"","sources":["../../sources/client/ensureLocalProtocolServer.ts"],"names":[],"mappings":"AAGA,OAAO,EAMH,KAAK,gBAAgB,EACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,MAAM,WAAW,6BAA6B;IAC1C,MAAM,EAAE,kBAAkB,CAAC;IAC3B,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gCAAgC;IAC7C,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED,wBAAsB,yBAAyB,CAC3C,OAAO,GAAE,gCAAqC,GAC/C,OAAO,CAAC,6BAA6B,CAAC,CA2BxC;AAWD,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAMvF"}

package/dist/client/ensureLocalProtocolServer.js

@@ -0,0 +1,112 @@
+import { spawn } from "node:child_process";
+import { open } from "node:fs/promises";
+import { getLocalServerPaths, prepareLocalServerDirectory, readLocalServerToken, removeStaleSocket, writeLocalServerToken, } from "../server/index.js";
+import { ProtocolHttpClient } from "./ProtocolHttpClient.js";
+export async function ensureLocalProtocolServer(options = {}) {
+    const paths = getEnvironmentLocalServerPaths();
+    await prepareLocalServerDirectory(paths.directory);
+    const existingToken = await readTokenIfPresent(paths.tokenPath);
+    if (existingToken !== undefined) {
+        const client = new ProtocolHttpClient({
+            socketPath: paths.socketPath,
+            token: existingToken,
+        });
+        const health = await readHealth(client);
+        if (health?.ready === true) {
+            await waitForReady(client, options);
+            return { client, paths, token: existingToken };
+        }
+        if (health?.healthy === true) {
+            options.onStatus?.("Restarting local daemon.");
+            await stopIncompatibleDaemon(client);
+        }
+    }
+    options.onStatus?.("Starting local daemon.");
+    await removeStaleSocket(paths.socketPath);
+    const token = await writeLocalServerToken(paths.tokenPath);
+    await spawnLocalServer(paths);
+    const client = new ProtocolHttpClient({ socketPath: paths.socketPath, token });
+    await waitForReady(client, options);
+    return { client, paths, token };
+}
+function getEnvironmentLocalServerPaths() {
+    const paths = getLocalServerPaths();
+    return {
+        ...paths,
+        socketPath: process.env.RIG_SERVER_SOCKET_PATH ?? paths.socketPath,
+        tokenPath: process.env.RIG_SERVER_TOKEN_PATH ?? paths.tokenPath,
+    };
+}
+export async function readTokenIfPresent(tokenPath) {
+    try {
+        return await readLocalServerToken(tokenPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readHealth(client) {
+    try {
+        return await client.health();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function stopIncompatibleDaemon(client) {
+    try {
+        await client.shutdown();
+        await delay(100);
+    }
+    catch {
+        // The follow-up stale socket cleanup handles older servers that cannot shut down cleanly.
+    }
+}
+async function spawnLocalServer(paths) {
+    const entrypoint = process.argv[1];
+    if (entrypoint === undefined) {
+        throw new Error("Cannot locate the current CLI entrypoint.");
+    }
+    const log = await open(paths.logPath, "a", 0o600);
+    try {
+        const child = spawn(process.execPath, [...process.execArgv, entrypoint, "--server"], {
+            detached: true,
+            env: {
+                ...process.env,
+                RIG_SERVER_SOCKET_PATH: paths.socketPath,
+                RIG_SERVER_TOKEN_PATH: paths.tokenPath,
+            },
+            stdio: ["ignore", log.fd, log.fd],
+        });
+        child.unref();
+    }
+    finally {
+        await log.close();
+    }
+}
+async function waitForReady(client, options) {
+    const deadline = Date.now() + 5_000;
+    let reportedInitializing = false;
+    while (Date.now() < deadline) {
+        try {
+            const health = await client.health();
+            if (health.ready) {
+                return;
+            }
+            if (!reportedInitializing) {
+                options.onStatus?.("Waiting for daemon initialization.");
+                reportedInitializing = true;
+            }
+        }
+        catch {
+            // The socket may not be accepting connections yet.
+        }
+        await delay(50);
+    }
+    throw new Error("Timed out while waiting for the local Rig server.");
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { ensureLocalProtocolServer, readTokenIfPresent, type LocalProtocolServerConnection, } from "./ensureLocalProtocolServer.js";
+export { ProtocolHttpClient, type ProtocolHttpClientOptions } from "./ProtocolHttpClient.js";
+export { RemoteAgent, type RemoteAgentOptions } from "./RemoteAgent.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../sources/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,yBAAyB,EACzB,kBAAkB,EAClB,KAAK,6BAA6B,GACrC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAC7F,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,3 @@
+export { ensureLocalProtocolServer, readTokenIfPresent, } from "./ensureLocalProtocolServer.js";
+export { ProtocolHttpClient } from "./ProtocolHttpClient.js";
+export { RemoteAgent } from "./RemoteAgent.js";

package/dist/config/createConfigFile.d.ts

@@ -0,0 +1,3 @@
+import type { RigConfig } from "./types.js";
+export declare function createConfigFile(path: string, config?: RigConfig): Promise<void>;
+//# sourceMappingURL=createConfigFile.d.ts.map

package/dist/config/createConfigFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createConfigFile.d.ts","sourceRoot":"","sources":["../../sources/config/createConfigFile.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,wBAAsB,gBAAgB,CAClC,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,SAA8B,GACvC,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/dist/config/createConfigFile.js

@@ -0,0 +1,22 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { stringify } from "smol-toml";
+import { DEFAULT_RIG_CONFIG } from "./defaultConfig.js";
+export async function createConfigFile(path, config = DEFAULT_RIG_CONFIG) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, stringify({
+        defaults: {
+            model: config.defaults.modelId,
+            ...(config.defaults.providerId !== undefined
+                ? { provider: config.defaults.providerId }
+                : {}),
+            ...(config.defaults.effort !== undefined ? { effort: config.defaults.effort } : {}),
+            ...(config.defaults.instructions !== undefined
+                ? { instructions: config.defaults.instructions }
+                : {}),
+        },
+        settings: {
+            show_reasoning: config.settings.showReasoning,
+        },
+    }), { encoding: "utf8", flag: "wx" });
+}

package/dist/config/defaultConfig.d.ts

@@ -0,0 +1,3 @@
+import type { RigConfig } from "./types.js";
+export declare const DEFAULT_RIG_CONFIG: RigConfig;
+//# sourceMappingURL=defaultConfig.d.ts.map

package/dist/config/defaultConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConfig.d.ts","sourceRoot":"","sources":["../../sources/config/defaultConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,eAAO,MAAM,kBAAkB,EAAE,SAOhC,CAAC"}

package/dist/config/defaultConfig.js

@@ -0,0 +1,8 @@
+export const DEFAULT_RIG_CONFIG = {
+    defaults: {
+        modelId: "openai/gpt-5.5",
+    },
+    settings: {
+        showReasoning: false,
+    },
+};