@valni/cli-darwin-x64 0.0.0-stage → 0.1.2

package/runtime/extensions/pi-switchboard/extensions/switchboard/toolProxy.ts

@@ -0,0 +1,136 @@
+import type { AgentToolResult, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { resolveBaseUrl, resolveSessionId } from "./config.ts";
+import { PROVIDER_ID, spawnedConnectionId } from "./constants.ts";
+
+const MCP_PATH = "/mcp";
+const DISCOVER_TIMEOUT_MS = 10_000;
+const SESSION_HEADER = "X-Switchboard-Session";
+const CONNECTION_TOOLS = new Set(["send_message", "close_automation_connection"]);
+const CONNECTION_ID_PARAM = "connection_id";
+
+function hasConnectionId(record: Record<string, unknown>): boolean {
+	const existing = record[CONNECTION_ID_PARAM];
+	return typeof existing === "string" && existing.trim() !== "";
+}
+
+export function withSpawnedConnectionId(name: string, params: unknown, connectionId: string | null): unknown {
+	if (!CONNECTION_TOOLS.has(name) || connectionId === null) return params;
+	if (params === null || typeof params !== "object" || Array.isArray(params)) return params;
+	const record = params as Record<string, unknown>;
+	if (hasConnectionId(record)) return params;
+	return { ...record, [CONNECTION_ID_PARAM]: connectionId };
+}
+
+export interface AdvertisedTool {
+	name: string;
+	description: string;
+	parameters: Record<string, unknown>;
+	version?: string;
+}
+
+export async function discoverTools(baseUrl: string, bearer: string): Promise<AdvertisedTool[]> {
+	let response: Response;
+	try {
+		response = await fetch(`${baseUrl}${MCP_PATH}`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json", Accept: "application/json", Authorization: `Bearer ${bearer}` },
+			body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }),
+			signal: AbortSignal.timeout(DISCOVER_TIMEOUT_MS),
+		});
+	} catch {
+		return [];
+	}
+	if (!response.ok) return [];
+	const body = (await response.json().catch(() => null)) as {
+		result?: { tools?: Array<{ name?: unknown; description?: unknown; inputSchema?: unknown }> };
+	} | null;
+	const tools = body?.result?.tools;
+	if (!Array.isArray(tools)) return [];
+	const advertised: AdvertisedTool[] = [];
+	for (const tool of tools) {
+		if (typeof tool.name !== "string" || tool.name.length === 0) continue;
+		advertised.push({
+			name: tool.name,
+			description: typeof tool.description === "string" ? tool.description : "",
+			parameters:
+				tool.inputSchema !== null && typeof tool.inputSchema === "object" && !Array.isArray(tool.inputSchema)
+					? (tool.inputSchema as Record<string, unknown>)
+					: {},
+		});
+	}
+	return advertised;
+}
+
+function textResult(text: string, details: unknown): AgentToolResult<unknown> {
+	return { content: [{ type: "text", text }], details };
+}
+
+export function toAgentContent(content: unknown): AgentToolResult<unknown>["content"] {
+	if (!Array.isArray(content)) return [{ type: "text", text: JSON.stringify(content) }];
+	const items: AgentToolResult<unknown>["content"] = [];
+	for (const raw of content) {
+		if (raw === null || typeof raw !== "object") continue;
+		const item = raw as { type?: unknown; text?: unknown; data?: unknown; mimeType?: unknown };
+		if (item.type === "text" && typeof item.text === "string") {
+			items.push({ type: "text", text: item.text });
+		} else if (item.type === "image" && typeof item.data === "string") {
+			items.push({ type: "image", data: item.data, mimeType: typeof item.mimeType === "string" ? item.mimeType : "image/png" });
+		} else {
+			items.push({ type: "text", text: JSON.stringify(raw) });
+		}
+	}
+	return items.length > 0 ? items : [{ type: "text", text: JSON.stringify(content) }];
+}
+
+export async function resolveInvokeToken(ctx: ExtensionContext): Promise<string | null> {
+	let resolution: Awaited<ReturnType<ExtensionContext["modelRegistry"]["getProviderAuth"]>>;
+	try {
+		resolution = await ctx.modelRegistry.getProviderAuth(PROVIDER_ID);
+	} catch {
+		return null;
+	}
+	return resolution?.auth.apiKey ?? null;
+}
+
+export function makeProxyExecute(name: string) {
+	return async (
+		_toolCallId: string,
+		params: unknown,
+		signal: AbortSignal | undefined,
+		_onUpdate: unknown,
+		ctx: ExtensionContext,
+	): Promise<AgentToolResult<unknown>> => {
+		const token = await resolveInvokeToken(ctx);
+		if (!token) return textResult(`Not signed in to Switchboard — cannot run ${name}. Run /login in pi, or set SWITCHBOARD_API_KEY for key-based use.`, null);
+		const headers: Record<string, string> = { "Content-Type": "application/json", Accept: "application/json", Authorization: `Bearer ${token}` };
+		const sessionId = resolveSessionId();
+		if (sessionId !== null) headers[SESSION_HEADER] = sessionId;
+
+		const args = withSpawnedConnectionId(name, params, spawnedConnectionId());
+		let response: Response;
+		try {
+			response = await fetch(`${resolveBaseUrl()}${MCP_PATH}`, {
+				method: "POST",
+				headers,
+				body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
+				signal,
+			});
+		} catch (error) {
+			return textResult(`Could not reach Switchboard to run ${name}: ${String(error)}`, null);
+		}
+
+		const envelope = (await response.json().catch(() => null)) as {
+			result?: { content?: unknown; isError?: boolean };
+			error?: { message?: unknown; code?: unknown };
+		} | null;
+		if (envelope?.error) {
+			const message = typeof envelope.error.message === "string" ? envelope.error.message : `Tool ${name} failed.`;
+			const code = typeof envelope.error.code === "number" || typeof envelope.error.code === "string" ? ` [${envelope.error.code}]` : "";
+			return textResult(`${message}${code}`, envelope);
+		}
+		if (!response.ok || !envelope?.result) {
+			return textResult(`Tool ${name} failed (HTTP ${response.status}).`, envelope);
+		}
+		return { content: toAgentContent(envelope.result.content), details: envelope.result };
+	};
+}

package/runtime/extensions/pi-switchboard/extensions/switchboard/tools.ts

@@ -0,0 +1,16 @@
+import { Type } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type AdvertisedTool, makeProxyExecute } from "./toolProxy.ts";
+
+export function registerServerTools(pi: ExtensionAPI, tools: AdvertisedTool[]): void {
+	for (const tool of tools) {
+		if (!tool.name) continue;
+		pi.registerTool({
+			name: tool.name,
+			label: tool.name,
+			description: tool.description,
+			parameters: Type.Unsafe(tool.parameters),
+			execute: makeProxyExecute(tool.name),
+		});
+	}
+}

package/runtime/extensions/pi-switchboard/extensions/switchboard/types.ts

@@ -0,0 +1,37 @@
+import type { Model } from "@earendil-works/pi-ai";
+
+export const KIND_TO_API = {
+	anthropic: "anthropic-messages",
+	openai_generic: "openai-completions",
+	openai_pro: "openai-responses",
+} as const;
+
+export type SwitchboardKind = keyof typeof KIND_TO_API;
+
+export interface KindProfile {
+	model: string;
+	maxTokensCeiling?: number;
+	vision?: boolean;
+	thinking?: { modes: string[] } | false;
+	reasoningEffort?: string[] | false;
+}
+
+export interface ModelRecord {
+	id: string;
+	kind: Record<string, KindProfile>;
+}
+
+export interface ModelRecordPrice {
+	input_micro_cents_per_mtok: number;
+	output_micro_cents_per_mtok: number;
+	cached_input_micro_cents_per_mtok: number | null;
+	effective_at: number;
+}
+
+export interface ModelsPage {
+	models: ModelRecord[];
+	prices: Record<string, ModelRecordPrice>;
+	context_windows?: Record<string, number>;
+}
+
+export type RegistryModel = Model<(typeof KIND_TO_API)[SwitchboardKind]>;

package/runtime/extensions/pi-switchboard/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "pi-switchboard",
+	"version": "0.11.2",
+	"type": "module",
+	"description": "Route the pi coding agent through Switchboard: one prepaid balance, spend controls, and a ledger for every model in the catalog",
+	"keywords": [
+		"pi-package"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Valni-Labs/pi-switchboard"
+	},
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"scripts": {
+		"test": "npm run typecheck && node --test \"extensions/switchboard/tests/*.test.ts\"",
+		"typecheck": "tsc --noEmit"
+	},
+	"pi": {
+		"extensions": [
+			"./extensions"
+		]
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "0.82.1",
+		"@earendil-works/pi-coding-agent": "0.82.1",
+		"typescript": "5.9.3"
+	}
+}

package/runtime/extensions/pi-switchboard/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"target": "es2023",
+		"module": "nodenext",
+		"moduleResolution": "nodenext",
+		"allowImportingTsExtensions": true,
+		"noEmit": true,
+		"strict": true,
+		"skipLibCheck": true,
+		"types": ["node"]
+	},
+	"include": ["extensions/**/*.ts"]
+}

package/runtime/extensions/switchboard-local/.github/workflows/ci.yml

@@ -0,0 +1,80 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  typecheck-test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Verify dependency token
+        env:
+          TOKEN: ${{ secrets.VALNI_REPO_READ_TOKEN }}
+        run: |
+          if [ -z "$TOKEN" ]; then
+            echo "::error::VALNI_REPO_READ_TOKEN is empty or not in scope for this repository"
+            exit 1
+          fi
+          # Both are pulled by the lockfile, and a fine-grained token can hold one without the other.
+          for repo in switchboard-ts SwitchboardNative; do
+            if ! git ls-remote "https://oauth2:${TOKEN}@github.com/Valni-Labs/${repo}.git" HEAD > /dev/null 2>&1; then
+              echo "::error::VALNI_REPO_READ_TOKEN cannot read Valni-Labs/${repo}"
+              exit 1
+            fi
+          done
+
+      - name: Install dependencies
+        env:
+          TOKEN: ${{ secrets.VALNI_REPO_READ_TOKEN }}
+        run: |
+          # Keep the credential in a throwaway config for this step only. Later steps run
+          # code from the pull request, which must never be able to read the token.
+          CONFIG="$(mktemp)"
+          export GIT_CONFIG_GLOBAL="$CONFIG"
+          trap 'rm -f "$CONFIG"' EXIT
+          git config --global url."https://oauth2:${TOKEN}@github.com/".insteadOf "ssh://git@github.com/"
+          git config --global --add url."https://oauth2:${TOKEN}@github.com/".insteadOf "git@github.com:"
+          npm ci --ignore-scripts
+
+      - name: Confirm no credential survived the install
+        run: |
+          if [ -f "$HOME/.gitconfig" ] && grep -q "oauth2:" "$HOME/.gitconfig"; then
+            echo "::error::a token was left in $HOME/.gitconfig"
+            exit 1
+          fi
+
+      - name: Typecheck and test
+        run: npm test
+
+      - name: Confirm the extension loads in pi
+        run: |
+          npx pi --no-extensions --extension ./extensions/local/index.ts --list-models 2> >(tee /tmp/pi-stderr.txt >&2)
+          # The version line is the reliable signal. Stock pi swallows extension load
+          # errors on --list-models, so its absence is how a broken extension shows up.
+          if ! grep -q "switchboard-local v" /tmp/pi-stderr.txt; then
+            echo "::error::the extension never ran; it printed no version line"
+            exit 1
+          fi
+          # Hosts that do report load failures, such as valni-cli, are caught here too.
+          if grep -q "Failed to load extension" /tmp/pi-stderr.txt; then
+            echo "::error::the extension failed to load in pi"
+            exit 1
+          fi

package/runtime/extensions/switchboard-local/.github/workflows/release.yml

@@ -0,0 +1,46 @@
+name: Release
+
+on:
+  workflow_dispatch:
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Read the version
+        id: version
+        run: echo "tag=v$(node -p "require('./package.json').version")" >> "$GITHUB_OUTPUT"
+
+      - name: Refuse to release a tag that already exists
+        run: |
+          if git rev-parse "${{ steps.version.outputs.tag }}" >/dev/null 2>&1; then
+            echo "::error::${{ steps.version.outputs.tag }} already exists. Bump the version in package.json first."
+            exit 1
+          fi
+
+      - name: Refuse to release a commit CI has not passed
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          STATE="$(gh api "repos/${{ github.repository }}/commits/${{ github.sha }}/check-runs" \
+            --jq '[.check_runs[] | select(.name == "typecheck-test") | .conclusion] | first // "missing"')"
+          if [ "$STATE" != "success" ]; then
+            echo "::error::CI on ${{ github.sha }} is '${STATE}', not success"
+            exit 1
+          fi
+
+      - name: Tag and publish the release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release create "${{ steps.version.outputs.tag }}" \
+            --target "${{ github.sha }}" \
+            --title "${{ steps.version.outputs.tag }}" \
+            --generate-notes

package/runtime/extensions/switchboard-local/README.md

@@ -0,0 +1,98 @@
+# switchboard-local
+
+Local models in the pi model picker. You paste a Hugging Face link, it downloads, and the model
+appears in `/model` at $0. No account, no network at inference time.
+
+```
+pi install https://github.com/Valni-Labs/switchboard-local
+```
+
+That follows `main`. To pin to a release instead:
+
+```
+pi install https://github.com/Valni-Labs/switchboard-local@v0.2.0
+```
+
+## Use it
+
+```
+/switchboard-local
+```
+
+Pick **Add a model…** and paste a link or a bare `owner/repository`. Or skip the menu:
+
+```
+/switchboard-local huggingface.co/mlx-community/Llama-3.2-1B-Instruct-4bit
+```
+
+The first model you add also installs the engine. That happens once and takes a few minutes.
+Afterwards `/model` lists every local model you have, alongside your cloud models.
+
+## What it installs
+
+Everything it manages lives in `~/.switchboard-local/`, outside the package, so `pi update` never
+wipes it.
+
+| Path | What |
+| --- | --- |
+| `~/.switchboard-local/mlx-venv` | Python environment plus `mlx-lm` |
+| `~/.switchboard-local/llama` | llama.cpp build and GGUF weights |
+| `~/.switchboard-local/state.json` | Ports, engine process ids, llama.cpp build |
+
+MLX weights go to the standard Hugging Face cache (`~/.cache/huggingface/hub`), so anything you
+already downloaded is picked up automatically.
+
+## Engines
+
+Two engines, picked for you. Paste any model and the right one runs it.
+
+| Engine | Format | Machines | Acceleration |
+| --- | --- | --- | --- |
+| MLX | safetensors, such as `mlx-community/*` | Apple Silicon | Metal |
+| GGUF | `.gguf`, such as `unsloth/*-GGUF` | macOS, Windows, Linux | Metal, Vulkan, CPU |
+
+MLX exists only on Apple Silicon, so GGUF is what covers Windows and Linux. The extension reads
+the repository and routes to whichever engine can run it, and says so plainly when neither can.
+
+For GGUF you may name a quantization, or leave it out and get `Q4_K_M` when it exists, else the
+smallest:
+
+```
+/switchboard-local unsloth/Qwen3-4B-Instruct-2507-GGUF:Q4_K_M
+/switchboard-local unsloth/Qwen3-4B-Instruct-2507-GGUF
+```
+
+The llama.cpp build is downloaded for you. On Windows and Linux it uses the Vulkan build, which
+gives GPU speed on NVIDIA, AMD and Intel without a CUDA install, and falls back to CPU if Vulkan
+will not start.
+
+## How it works
+
+pi is Node and cannot load a model into itself, so each engine runs as a child process bound to
+`127.0.0.1`, and every downloaded model is registered against the engine that holds it. pi's own
+OpenAI client does the talking, which is why streaming, native tool calls and token counts all
+work without any protocol code here.
+
+Nothing is sent anywhere. The only network traffic is downloading the model from Hugging Face.
+
+- Models cost `$0.00` and are listed straight from the engine, so the picker always matches disk.
+- The provider declares a local credential, so local models need no login and work signed out.
+- Engines start on demand and stop when pi exits, including runs with no session. Each runs in its
+  own process group, so a stop takes its workers with it and never holds pi open.
+- Several pi sessions share one engine rather than loading a model twice. The engine is stopped by
+  the last session using it, so quitting one window never pulls a model out from under another.
+
+## Not yet
+
+- `$0` usage events into the Switchboard ledger. Inference would still stay on the machine; only
+  the token count would be reported afterwards.
+- Reasoning models are listed without a thinking level, so pi offers no thinking-level selector.
+
+## Develop
+
+```
+npm test
+pi -ne -e ./extensions/local/index.ts --list-models
+```
+
+`-ne` disables other extensions so you are testing this one alone.

package/runtime/extensions/switchboard-local/extensions/local/engine.ts

@@ -0,0 +1,28 @@
+export interface Progress {
+	label: string;
+	fraction?: number;
+}
+
+export interface LocalModelInfo {
+	id: string;
+	engine: LocalEngineId;
+	baseUrl: string;
+	contextWindow: number;
+	vision?: boolean;
+}
+
+export type LocalEngineId = "mlx" | "gguf";
+
+export interface LocalEngine {
+	readonly id: LocalEngineId;
+	readonly label: string;
+	supported(): boolean;
+	unsupportedReason(): string;
+	isInstalled(): boolean;
+	isRunning(): boolean;
+	ensureReady(onProgress: (progress: Progress) => void, signal?: AbortSignal): Promise<void>;
+	baseUrl(): string;
+	addModel(repoId: string, onProgress: (progress: Progress) => void, signal?: AbortSignal): Promise<void>;
+	listModels(signal?: AbortSignal): Promise<LocalModelInfo[]>;
+	stop(): Promise<void>;
+}