@valni/cli-darwin-x64 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@valni/cli-darwin-x64",
-	"version": "0.1.5",
+	"version": "0.1.7",
 	"license": "SEE LICENSE IN LICENSE",
 	"publishConfig": {
 		"access": "public"

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

@@ -48,13 +48,11 @@ export async function loadRegistryModels(): Promise<Record<string, RegistryModel
 	const distDirectory = findPiAiDist();
 	const registry: Record<string, RegistryModel> = {};
 	if (distDirectory === undefined) {
-		const names = AI_PACKAGES.map(([scope, name]) => `${scope}/${name}`).join(" or ");
-		console.error(
-			`pi-switchboard: no ${names} beside the host executable, so models list without a context window or display name.`,
-		);
+		// The catalog supplies the context window and the display name, and a
+		// genuinely missing context window is reported precisely in
+		// buildModelConfigs. The registry is only a source of last resort.
 		return registry;
 	}
-	const missing: string[] = [];
 	for (const file of REGISTRY_FILES) {
 		let loaded: Record<string, Record<string, RegistryModel>>;
 		try {
@@ -63,10 +61,9 @@ export async function loadRegistryModels(): Promise<Record<string, RegistryModel
 				Record<string, RegistryModel>
 			>;
 		} catch (error) {
-			if (isModuleNotFound(error)) {
-				missing.push(file);
-				continue;
-			}
+			// A registry file that is not there is not a problem: everything a
+			// user sees first comes from the catalog.
+			if (isModuleNotFound(error)) continue;
 			throw error;
 		}
 		for (const exported of Object.values(loaded)) {
@@ -76,11 +73,6 @@ export async function loadRegistryModels(): Promise<Record<string, RegistryModel
 			}
 		}
 	}
-	if (missing.length === REGISTRY_FILES.length) {
-		console.error(
-			`pi-switchboard: no model registry in ${distDirectory}/providers (${missing.join(", ")}). Models will list without a context window or display name.`,
-		);
-	}
 	return registry;
 }
 
@@ -109,10 +101,11 @@ function toModelConfig(
 	price: ModelRecordPrice | undefined,
 	registryModel: RegistryModel | undefined,
 	catalogContextWindow: number | undefined,
+	catalogDisplayName: string | undefined,
 ) {
 	return {
 		id: record.id,
-		name: registryModel?.name ?? record.id,
+		name: catalogDisplayName ?? registryModel?.name ?? record.id,
 		api: KIND_TO_API[kindTag],
 		baseUrl: `${resolveBaseUrl()}${SENTINEL_SEGMENT}${kindTag}`,
 		reasoning: supportsReasoning(kindTag, profile) ?? registryModel?.reasoning ?? false,
@@ -127,12 +120,13 @@ function toModelConfig(
 	};
 }
 
-export async function discoverCatalog(baseUrl: string, bearer: string): Promise<ModelsPage> {
+export async function discoverCatalog(baseUrl: string, bearer: string, signal?: AbortSignal): Promise<ModelsPage> {
+	const timeout = AbortSignal.timeout(CATALOG_FETCH_TIMEOUT_MS);
 	let response: Response;
 	try {
 		response = await fetch(`${baseUrl}${MODELS_PATH}`, {
 			headers: { Authorization: `Bearer ${bearer}` },
-			signal: AbortSignal.timeout(CATALOG_FETCH_TIMEOUT_MS),
+			signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
 		});
 	} catch (error) {
 		if (isAbortError(error)) throw error;
@@ -168,7 +162,15 @@ export function buildModelConfigs(catalog: ModelsPage, registry: Record<string,
 		const catalogContextWindow = catalog.context_windows?.[record.id];
 		if (catalogContextWindow === undefined && registry[record.id]?.contextWindow === undefined) assumed++;
 		modelConfigs.push(
-			toModelConfig(record, kindTag, record.kind[kindTag], catalog.prices[record.id], registry[record.id], catalogContextWindow),
+			toModelConfig(
+				record,
+				kindTag,
+				record.kind[kindTag],
+				catalog.prices[record.id],
+				registry[record.id],
+				catalogContextWindow,
+				catalog.display_names?.[record.id],
+			),
 		);
 	}
 	if (skipped.length > 0) {

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

@@ -99,22 +99,27 @@ export default async function (pi: ExtensionAPI) {
 		refreshModels: async (context: RefreshModelsContext) => {
 			const bearer = credentialBearer(context.credential);
 			if (!bearer) {
-				await context.store.delete();
+				await context.publish({ persist: null });
 				return [];
 			}
-			const stored = await context.store.read();
 			if (!context.allowNetwork) {
-				return stored ? ([...stored.models] as ReturnType<typeof buildModelConfigs>) : startupModels;
+				return context.stored
+					? ([...context.stored.models] as ReturnType<typeof buildModelConfigs>)
+					: startupModels;
 			}
-			const catalog = await discoverCatalog(baseUrl, bearer);
+			const catalog = await discoverCatalog(baseUrl, bearer, context.signal);
 			const configs = buildModelConfigs(catalog, registry);
-			await context.store.write({
-				models: configs as unknown as ModelsStoreEntry["models"],
-				checkedAt: Math.floor(Date.now() / MILLISECONDS_PER_SECOND),
+			const published = await context.publish({
+				persist: {
+					models: configs as unknown as ModelsStoreEntry["models"],
+					checkedAt: Math.floor(Date.now() / MILLISECONDS_PER_SECOND),
+				},
 			});
+			if (!published) return configs;
 			if (context.credential?.type === "oauth") {
 				try {
-					registerServerTools(pi, await discoverTools(baseUrl, bearer));
+					const tools = await discoverTools(baseUrl, bearer, context.signal);
+					if (!context.signal.aborted) registerServerTools(pi, tools);
 				} catch (error) {
 					console.error("pi-switchboard: server tool discovery failed", error);
 				}

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

@@ -28,14 +28,15 @@ export interface AdvertisedTool {
 	version?: string;
 }
 
-export async function discoverTools(baseUrl: string, bearer: string): Promise<AdvertisedTool[]> {
+export async function discoverTools(baseUrl: string, bearer: string, signal?: AbortSignal): Promise<AdvertisedTool[]> {
+	const timeout = AbortSignal.timeout(DISCOVER_TIMEOUT_MS);
 	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),
+			signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
 		});
 	} catch {
 		return [];

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

@@ -1,4 +1,6 @@
-import { Type } from "@earendil-works/pi-ai";
+// typebox directly, not through a harness package: this extension runs in
+// more than one host and must not name any of them at runtime.
+import { Type } from "typebox";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { type AdvertisedTool, makeProxyExecute } from "./toolProxy.ts";
 

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

@@ -31,7 +31,10 @@ export interface ModelRecordPrice {
 export interface ModelsPage {
 	models: ModelRecord[];
 	prices: Record<string, ModelRecordPrice>;
+	/** Real context window per model id, from the catalog. */
 	context_windows?: Record<string, number>;
+	/** Human-readable name per model id, from the catalog. */
+	display_names?: Record<string, string>;
 }
 
 export type RegistryModel = Model<(typeof KIND_TO_API)[SwitchboardKind]>;

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

@@ -1,6 +1,6 @@
 {
 	"name": "pi-switchboard",
-	"version": "0.11.2",
+	"version": "0.11.3",
 	"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": [
@@ -23,8 +23,8 @@
 		]
 	},
 	"devDependencies": {
-		"@earendil-works/pi-ai": "0.82.1",
-		"@earendil-works/pi-coding-agent": "0.82.1",
+		"@earendil-works/pi-ai": ">=1.0.0",
+		"@earendil-works/pi-coding-agent": ">=1.0.0",
 		"typescript": "5.9.3"
 	}
 }

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

@@ -0,0 +1,88 @@
+import type { AssistantMessage, AssistantMessageEvent } from "@earendil-works/pi-ai";
+
+// Generic event stream class for async iteration
+export class EventStream<T, R = T> implements AsyncIterable<T> {
+	private queue: T[] = [];
+	private waiting: ((value: IteratorResult<T>) => void)[] = [];
+	private done = false;
+	private finalResultPromise: Promise<R>;
+	private resolveFinalResult!: (result: R) => void;
+	private isComplete: (event: T) => boolean;
+	private extractResult: (event: T) => R;
+
+	constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R) {
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+		this.finalResultPromise = new Promise((resolve) => {
+			this.resolveFinalResult = resolve;
+		});
+	}
+
+	push(event: T): void {
+		if (this.done) return;
+
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+
+		// Deliver to waiting consumer or queue it
+		const waiter = this.waiting.shift();
+		if (waiter) {
+			waiter({ value: event, done: false });
+		} else {
+			this.queue.push(event);
+		}
+	}
+
+	end(result?: R): void {
+		this.done = true;
+		if (result !== undefined) {
+			this.resolveFinalResult(result);
+		}
+		// Notify all waiting consumers that we're done
+		while (this.waiting.length > 0) {
+			const waiter = this.waiting.shift()!;
+			waiter({ value: undefined as any, done: true });
+		}
+	}
+
+	async *[Symbol.asyncIterator](): AsyncIterator<T> {
+		while (true) {
+			if (this.queue.length > 0) {
+				yield this.queue.shift()!;
+			} else if (this.done) {
+				return;
+			} else {
+				const result = await new Promise<IteratorResult<T>>((resolve) => this.waiting.push(resolve));
+				if (result.done) return;
+				yield result.value;
+			}
+		}
+	}
+
+	result(): Promise<R> {
+		return this.finalResultPromise;
+	}
+}
+
+export class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+	constructor() {
+		super(
+			(event) => event.type === "done" || event.type === "error",
+			(event) => {
+				if (event.type === "done") {
+					return event.message;
+				} else if (event.type === "error") {
+					return event.error;
+				}
+				throw new Error("Unexpected event type for final result");
+			},
+		);
+	}
+}
+
+/** Factory function for AssistantMessageEventStream (for use in extensions) */
+export function createAssistantMessageEventStream(): AssistantMessageEventStream {
+	return new AssistantMessageEventStream();
+}

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

@@ -0,0 +1,49 @@
+import type { TextContent, Tool, TranscriptContext } from "@earendil-works/pi-ai";
+
+/**
+ * Read the system prompt and the tools out of a transcript.
+ *
+ * Both hosts hand a provider the same shape now: system messages replayed in
+ * order, where later content appends to the prompt and tools are added and
+ * removed by name. Doing the replay here rather than calling a host helper is
+ * what keeps a host package out of the runtime imports.
+ */
+
+interface SystemMessage {
+	role: string;
+	content: string | TextContent[];
+	toolsAdded?: Tool[];
+	toolsRemoved?: { name: string }[];
+}
+
+function isSystemMessage(message: unknown): message is SystemMessage {
+	return message !== null && typeof message === "object" && (message as { role?: unknown }).role === "system";
+}
+
+function contentText(content: string | TextContent[]): string {
+	if (typeof content === "string") return content;
+	return content
+		.filter((part) => part.type === "text")
+		.map((part) => part.text)
+		.join("");
+}
+
+export function hostSystemPrompt(context: TranscriptContext): string | undefined {
+	const parts: string[] = [];
+	for (const message of context.messages) {
+		if (!isSystemMessage(message)) continue;
+		const text = contentText(message.content);
+		if (text.length > 0) parts.push(text);
+	}
+	return parts.length > 0 ? parts.join("\n\n") : undefined;
+}
+
+export function hostTools(context: TranscriptContext): Tool[] {
+	const tools = new Map<string, Tool>();
+	for (const message of context.messages) {
+		if (!isSystemMessage(message)) continue;
+		for (const tool of message.toolsRemoved ?? []) tools.delete(tool.name);
+		for (const tool of message.toolsAdded ?? []) tools.set(tool.name, tool);
+	}
+	return [...tools.values()];
+}

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

@@ -0,0 +1,124 @@
+import { parse as partialParse } from "partial-json";
+
+const VALID_JSON_ESCAPES = new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+
+function isControlCharacter(char: string): boolean {
+	const codePoint = char.codePointAt(0);
+	return codePoint !== undefined && codePoint >= 0x00 && codePoint <= 0x1f;
+}
+
+function escapeControlCharacter(char: string): string {
+	switch (char) {
+		case "\b":
+			return "\\b";
+		case "\f":
+			return "\\f";
+		case "\n":
+			return "\\n";
+		case "\r":
+			return "\\r";
+		case "\t":
+			return "\\t";
+		default:
+			return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+	}
+}
+
+/**
+ * Repairs malformed JSON string literals by:
+ * - escaping raw control characters inside strings
+ * - doubling backslashes before invalid escape characters
+ */
+export function repairJson(json: string): string {
+	let repaired = "";
+	let inString = false;
+
+	for (let index = 0; index < json.length; index++) {
+		const char = json[index];
+
+		if (!inString) {
+			repaired += char;
+			if (char === '"') {
+				inString = true;
+			}
+			continue;
+		}
+
+		if (char === '"') {
+			repaired += char;
+			inString = false;
+			continue;
+		}
+
+		if (char === "\\") {
+			const nextChar = json[index + 1];
+			if (nextChar === undefined) {
+				repaired += "\\\\";
+				continue;
+			}
+
+			if (nextChar === "u") {
+				const unicodeDigits = json.slice(index + 2, index + 6);
+				if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+					repaired += `\\u${unicodeDigits}`;
+					index += 5;
+					continue;
+				}
+			}
+
+			if (VALID_JSON_ESCAPES.has(nextChar)) {
+				repaired += `\\${nextChar}`;
+				index += 1;
+				continue;
+			}
+
+			repaired += "\\\\";
+			continue;
+		}
+
+		repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+	}
+
+	return repaired;
+}
+
+export function parseJsonWithRepair<T>(json: string): T {
+	try {
+		return JSON.parse(json) as T;
+	} catch (error) {
+		const repairedJson = repairJson(json);
+		if (repairedJson !== json) {
+			return JSON.parse(repairedJson) as T;
+		}
+		throw error;
+	}
+}
+
+/**
+ * Attempts to parse potentially incomplete JSON during streaming.
+ * Always returns a valid object, even if the JSON is incomplete.
+ *
+ * @param partialJson The partial JSON string from streaming
+ * @returns Parsed object or empty object if parsing fails
+ */
+export function parseStreamingJson<T = Record<string, unknown>>(partialJson: string | undefined): T {
+	if (!partialJson || partialJson.trim() === "") {
+		return {} as T;
+	}
+
+	try {
+		return parseJsonWithRepair<T>(partialJson);
+	} catch {
+		try {
+			const result = partialParse(partialJson);
+			return (result ?? {}) as T;
+		} catch {
+			try {
+				const result = partialParse(repairJson(partialJson));
+				return (result ?? {}) as T;
+			} catch {
+				return {} as T;
+			}
+		}
+	}
+}

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

@@ -1,13 +1,10 @@
 import {
 	type Api,
+	type AssistantMessageEventStream as HostAssistantMessageEventStream,
 	type AssistantMessage,
-	type AssistantMessageEventStream,
-	createAssistantMessageEventStream,
-	type Context,
 	type ImageContent,
 	type Message,
 	type Model,
-	parseStreamingJson,
 	type SimpleStreamOptions,
 	type StopReason,
 	type TextContent,
@@ -15,7 +12,11 @@ import {
 	type Tool,
 	type ToolCall,
 	type ToolResultMessage,
+	type TranscriptContext,
 } from "@earendil-works/pi-ai";
+import { type AssistantMessageEventStream, createAssistantMessageEventStream } from "./eventStream.ts";
+import { hostSystemPrompt, hostTools } from "./hostContext.ts";
+import { parseStreamingJson } from "./jsonParse.ts";
 import { messages as sdkMessages, native } from "@valni/switchboard";
 
 const SSE_DATA_PREFIX = "data:";
@@ -111,6 +112,7 @@ export function normalizeContextMessages(model: Model<KnownApi>, contextMessages
 
 	const transformed: Message[] = [];
 	for (const message of imageAware) {
+		if (message.role === "system") continue;
 		if (message.role === "user") {
 			transformed.push(message);
 			continue;
@@ -246,14 +248,16 @@ function chatUserParts(content: (TextContent | ImageContent)[]): sdkMessages.Par
 
 function buildOpenAIChatRequest(
 	model: Model<KnownApi>,
-	context: Context,
+	context: TranscriptContext,
 	options: SimpleStreamOptions | undefined,
 ): native.OpenAIChatRequest {
 	const normalized = normalizeContextMessages(model, context.messages);
 	const requestMessages: sdkMessages.Message[] = [];
+	const systemPrompt = hostSystemPrompt(context);
+	const tools = hostTools(context);
 
-	if (context.systemPrompt) {
-		requestMessages.push(sdkMessages.Message.system(sanitizeText(context.systemPrompt)));
+	if (systemPrompt) {
+		requestMessages.push(sdkMessages.Message.system(sanitizeText(systemPrompt)));
 	}
 
 	for (let index = 0; index < normalized.length; index++) {
@@ -320,7 +324,7 @@ function buildOpenAIChatRequest(
 		messages: requestMessages,
 		max_tokens: resolveMaxTokens(model, options),
 		temperature: options?.temperature ?? null,
-		tools: context.tools && context.tools.length > 0 ? context.tools.map((tool) => new JsonSchemaTool(tool)) : null,
+		tools: tools.length > 0 ? tools.map((tool) => new JsonSchemaTool(tool)) : null,
 		reasoning_effort: reasoningLevel ?? null,
 	});
 }
@@ -520,9 +524,9 @@ function completionsUrl(baseUrl: string): string {
 
 export function streamLocalModel(
 	model: Model<Api>,
-	context: Context,
+	context: TranscriptContext,
 	options?: SimpleStreamOptions,
-): AssistantMessageEventStream {
+): HostAssistantMessageEventStream {
 	const stream = createAssistantMessageEventStream();
 
 	(async () => {
@@ -579,7 +583,7 @@ export function streamLocalModel(
 			}
 
 			if (options?.signal?.aborted) throw new Error("Request was aborted");
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
+			if (output.stopReason === "aborted" || output.stopReason === "error" || output.stopReason === "pending") {
 				throw new Error(output.errorMessage || "An unknown error occurred");
 			}
 			if (!state.sawTerminalEvent) throw new Error("The stream ended before a terminal event");
@@ -598,5 +602,9 @@ export function streamLocalModel(
 		}
 	})();
 
-	return stream;
+	// The host's stream type has private members, so only its own class satisfies
+	// it nominally. The object here is the same shape and the host only iterates
+	// it, so the cast sits at this one boundary rather than importing the host's
+	// constructor and naming its package at runtime.
+	return stream as unknown as HostAssistantMessageEventStream;
 }

package/runtime/extensions/switchboard-local/node_modules/partial-json/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Promplate Dev Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/runtime/extensions/switchboard-local/node_modules/partial-json/README.md

@@ -0,0 +1,131 @@
+# Partial JSON Parser
+
+Sometimes we need **LLM (Large Language Models)** to produce **structural information** instead of natural language. The easiest way is to use JSON.
+
+But before receiving the last token of response, the JSON is broken, which means you can't use `JSON.parse` to decode it. But we still want to stream the data to the user.
+
+Here comes `partial-json`, a lightweight and customizable library for parsing partial JSON strings. Here is a [demo](https://promplate.dev/partial-json-parser).
+
+(Note that there is [a Python implementation](https://github.com/promplate/partial-json-parser) too)
+
+## Installation
+
+```sh
+npm i partial-json # or pnpm / bun / yarn
+```
+
+`partial-json` is implemented purely in JavaScript, and have both `commonjs` and `esm` builds.
+
+## Usage
+
+### Importing the library
+
+You can import the `parse` function and the `Allow` object from the library like this:
+
+```js
+import { parse, Allow } from "partial-json";
+```
+
+The `Allow` object is just an Enum for options. It determines what types can be partial. types not included in `allow` only appears after its completion can be ensured.
+
+### Parsing complete / partial JSON strings
+
+The `parse` function works just like the built-in `JSON.parse` when parsing a complete JSON string:
+
+```js
+let result = parse('{"key":"value"}');
+console.log(result); // Outputs: { key: 'value' }
+```
+
+You can parse a partial JSON string by passing an additional parameter to the `parse` function. This parameter is a **bitwise OR** of the constants from the `Allow` object:
+
+(Note that you can directly import the constants you need from `partial-json`)
+
+```js
+import { parse, STR, OBJ } from "partial-json";
+
+result = parse('{"key": "v', STR | OBJ);
+console.log(result); // Outputs: { key: 'v' }
+```
+
+In this example, `Allow.STR` tells the parser that it's okay if a string is incomplete, and `Allow.OBJ` tells the parser so as an object. The parser then try to return as much data as it can.
+
+If you don't allow partial strings, then it will not add `"key"` to the object because `"v` is not close:
+
+```js
+result = parse('{"key": "v', OBJ);
+console.log(result); // Outputs: {}
+
+result = parse('{"key": "value"', OBJ);
+console.log(result); // Outputs: { key: 'value' }
+```
+
+Similarity, you can parse partial arrays or even partial special values if you allow it:
+
+(Note that `allow` defaults to `Allow.ALL`)
+
+```js
+result = parse('[ {"key1": "value1", "key2": [ "value2');
+console.log(result); // Outputs: [ { key1: 'value1', key2: [ 'value2' ] } ]
+
+result = parse("-Inf");
+console.log(result); // Outputs: -Infinity
+```
+
+### Handling malformed JSON
+
+If the JSON string is malformed, the `parse` function will throw an error:
+
+```js
+parse("wrong"); // MalformedJSON [Error]: SyntaxError: Unexpected token 'w', "wrong" is not valid JSON at position 0
+```
+
+## API Reference
+
+### parse(jsonString, [allowPartial])
+
+- `jsonString` `<string>`: The JSON string to parse.
+- `allowPartial` `<number>`: Specify what kind of partialness is allowed during JSON parsing (default: `Allow.ALL`).
+
+Returns the parsed JavaScript value.
+
+### Allow
+
+An object that specifies what kind of partialness is allowed during JSON parsing. It has the following properties:
+
+- `STR`: Allow partial string.
+- `NUM`: Allow partial number.
+- `ARR`: Allow partial array.
+- `OBJ`: Allow partial object.
+- `NULL`: Allow partial null.
+- `BOOL`: Allow partial boolean.
+- `NAN`: Allow partial NaN.
+- `INFINITY`: Allow partial Infinity.
+- `_INFINITY`: Allow partial -Infinity.
+- `INF`: Allow both partial Infinity and -Infinity.
+- `SPECIAL`: Allow all special values.
+- `ATOM`: Allow all atomic values.
+- `COLLECTION`: Allow all collection values.
+- `ALL`: Allow all values.
+
+## Testing
+
+To run the tests for this library, you should clone the repository and install the dependencies:
+
+```sh
+git clone https://github.com/promplate/partial-json-parser-js.git
+cd partial-json-parser-js
+npm i
+```
+
+Then, you can run the tests using [Vitest](https://vitest.dev/):
+
+```sh
+npm run test
+```
+
+Please note that while we strive to cover as many edge cases as possible, it's always possible that some cases might not be covered.
+
+## License
+
+This project is licensed under the MIT License.

package/runtime/extensions/switchboard-local/node_modules/partial-json/dist/index.js

@@ -0,0 +1,220 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = void 0;
+const options_1 = require("./options");
+Object.defineProperty(exports, "Allow", { enumerable: true, get: function () { return options_1.Allow; } });
+__exportStar(require("./options"), exports);
+class PartialJSON extends Error {
+}
+exports.PartialJSON = PartialJSON;
+class MalformedJSON extends Error {
+}
+exports.MalformedJSON = MalformedJSON;
+/**
+ * Parse incomplete JSON
+ * @param {string} jsonString Partial JSON to be parsed
+ * @param {number} allowPartial Specify what types are allowed to be partial, see {@link Allow} for details
+ * @returns The parsed JSON
+ * @throws {PartialJSON} If the JSON is incomplete (related to the `allow` parameter)
+ * @throws {MalformedJSON} If the JSON is malformed
+ */
+function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+    if (typeof jsonString !== "string") {
+        throw new TypeError(`expecting str, got ${typeof jsonString}`);
+    }
+    if (!jsonString.trim()) {
+        throw new Error(`${jsonString} is empty`);
+    }
+    return _parseJSON(jsonString.trim(), allowPartial);
+}
+exports.parseJSON = parseJSON;
+;
+const _parseJSON = (jsonString, allow) => {
+    const length = jsonString.length;
+    let index = 0;
+    const markPartialJSON = (msg) => {
+        throw new PartialJSON(`${msg} at position ${index}`);
+    };
+    const throwMalformedError = (msg) => {
+        throw new MalformedJSON(`${msg} at position ${index}`);
+    };
+    const parseAny = () => {
+        skipBlank();
+        if (index >= length)
+            markPartialJSON("Unexpected end of input");
+        if (jsonString[index] === '"')
+            return parseStr();
+        if (jsonString[index] === "{")
+            return parseObj();
+        if (jsonString[index] === "[")
+            return parseArr();
+        if (jsonString.substring(index, index + 4) === "null" || (options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return null;
+        }
+        if (jsonString.substring(index, index + 4) === "true" || (options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return true;
+        }
+        if (jsonString.substring(index, index + 5) === "false" || (options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index)))) {
+            index += 5;
+            return false;
+        }
+        if (jsonString.substring(index, index + 8) === "Infinity" || (options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index)))) {
+            index += 8;
+            return Infinity;
+        }
+        if (jsonString.substring(index, index + 9) === "-Infinity" || (options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index)))) {
+            index += 9;
+            return -Infinity;
+        }
+        if (jsonString.substring(index, index + 3) === "NaN" || (options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index)))) {
+            index += 3;
+            return NaN;
+        }
+        return parseNum();
+    };
+    const parseStr = () => {
+        const start = index;
+        let escape = false;
+        index++; // skip initial quote
+        while (index < length && (jsonString[index] !== '"' || (escape && jsonString[index - 1] === "\\"))) {
+            escape = jsonString[index] === "\\" ? !escape : false;
+            index++;
+        }
+        if (jsonString.charAt(index) == '"') {
+            try {
+                return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+            }
+            catch (e) {
+                throwMalformedError(String(e));
+            }
+        }
+        else if (options_1.Allow.STR & allow) {
+            try {
+                return JSON.parse(jsonString.substring(start, index - Number(escape)) + '"');
+            }
+            catch (e) {
+                // SyntaxError: Invalid escape sequence
+                return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + '"');
+            }
+        }
+        markPartialJSON("Unterminated string literal");
+    };
+    const parseObj = () => {
+        index++; // skip initial brace
+        skipBlank();
+        const obj = {};
+        try {
+            while (jsonString[index] !== "}") {
+                skipBlank();
+                if (index >= length && options_1.Allow.OBJ & allow)
+                    return obj;
+                const key = parseStr();
+                skipBlank();
+                index++; // skip colon
+                try {
+                    const value = parseAny();
+                    obj[key] = value;
+                }
+                catch (e) {
+                    if (options_1.Allow.OBJ & allow)
+                        return obj;
+                    else
+                        throw e;
+                }
+                skipBlank();
+                if (jsonString[index] === ",")
+                    index++; // skip comma
+            }
+        }
+        catch (e) {
+            if (options_1.Allow.OBJ & allow)
+                return obj;
+            else
+                markPartialJSON("Expected '}' at end of object");
+        }
+        index++; // skip final brace
+        return obj;
+    };
+    const parseArr = () => {
+        index++; // skip initial bracket
+        const arr = [];
+        try {
+            while (jsonString[index] !== "]") {
+                arr.push(parseAny());
+                skipBlank();
+                if (jsonString[index] === ",") {
+                    index++; // skip comma
+                }
+            }
+        }
+        catch (e) {
+            if (options_1.Allow.ARR & allow) {
+                return arr;
+            }
+            markPartialJSON("Expected ']' at end of array");
+        }
+        index++; // skip final bracket
+        return arr;
+    };
+    const parseNum = () => {
+        if (index === 0) {
+            if (jsonString === "-")
+                throwMalformedError("Not sure what '-' is");
+            try {
+                return JSON.parse(jsonString);
+            }
+            catch (e) {
+                if (options_1.Allow.NUM & allow)
+                    try {
+                        return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+                    }
+                    catch (e) { }
+                throwMalformedError(String(e));
+            }
+        }
+        const start = index;
+        if (jsonString[index] === "-")
+            index++;
+        while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1)
+            index++;
+        if (index == length && !(options_1.Allow.NUM & allow))
+            markPartialJSON("Unterminated number literal");
+        try {
+            return JSON.parse(jsonString.substring(start, index));
+        }
+        catch (e) {
+            if (jsonString.substring(start, index) === "-")
+                markPartialJSON("Not sure what '-' is");
+            try {
+                return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+            }
+            catch (e) {
+                throwMalformedError(String(e));
+            }
+        }
+    };
+    const skipBlank = () => {
+        while (index < length && " \n\r\t".includes(jsonString[index])) {
+            index++;
+        }
+    };
+    return parseAny();
+};
+const parse = parseJSON;
+exports.parse = parse;

package/runtime/extensions/switchboard-local/node_modules/partial-json/dist/options.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Sometimes you don't allow every type to be partially parsed.
+ * For example, you may not want a partial number because it may increase its size gradually before it's complete.
+ * In this case, you can use the `Allow` object to control what types you allow to be partially parsed.
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = void 0;
+/**
+ * allow partial strings like `"hello \u12` to be parsed as `"hello "`
+ */
+exports.STR = 0b000000001;
+/**
+ * allow partial numbers like `123.` to be parsed as `123`
+ */
+exports.NUM = 0b000000010;
+/**
+ * allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+ */
+exports.ARR = 0b000000100;
+/**
+ * allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+ */
+exports.OBJ = 0b000001000;
+/**
+ * allow `nu` to be parsed as `null`
+ */
+exports.NULL = 0b000010000;
+/**
+ * allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+ */
+exports.BOOL = 0b000100000;
+/**
+ * allow `Na` to be parsed as `NaN`
+ */
+exports.NAN = 0b001000000;
+/**
+ * allow `Inf` to be parsed as `Infinity`
+ */
+exports.INFINITY = 0b010000000;
+/**
+ * allow `-Inf` to be parsed as `-Infinity`
+ */
+exports._INFINITY = 0b100000000;
+exports.INF = exports.INFINITY | exports._INFINITY;
+exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+exports.COLLECTION = exports.ARR | exports.OBJ;
+exports.ALL = exports.ATOM | exports.COLLECTION;
+/**
+ * Control what types you allow to be partially parsed.
+ * The default is to allow all types to be partially parsed, which in most casees is the best option.
+ * @example
+ * If you don't want to allow partial objects, you can use the following code:
+ * ```ts
+ * import { Allow, parse } from "partial-json";
+ * parse(`[{"a": 1, "b": 2}, {"a": 3,`, Allow.ARR); // [ { a: 1, b: 2 } ]
+ * ```
+ * Or you can use `~` to disallow a type:
+ * ```ts
+ * parse(`[{"a": 1, "b": 2}, {"a": 3,`, ~Allow.OBJ); // [ { a: 1, b: 2 } ]
+ * ```
+ * @example
+ * If you don't want to allow partial strings, you can use the following code:
+ * ```ts
+ * import { Allow, parse } from "partial-json";
+ * parse(`["complete string", "incompl`, ~Allow.STR); // [ 'complete string' ]
+ * ```
+ */
+exports.Allow = { STR: exports.STR, NUM: exports.NUM, ARR: exports.ARR, OBJ: exports.OBJ, NULL: exports.NULL, BOOL: exports.BOOL, NAN: exports.NAN, INFINITY: exports.INFINITY, _INFINITY: exports._INFINITY, INF: exports.INF, SPECIAL: exports.SPECIAL, ATOM: exports.ATOM, COLLECTION: exports.COLLECTION, ALL: exports.ALL };
+exports.default = exports.Allow;

package/runtime/extensions/switchboard-local/node_modules/partial-json/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "partial-json",
+  "version": "0.1.7",
+  "description": "Parse partial JSON generated by LLM",
+  "keywords": [
+    "JSON",
+    "parser",
+    "LLM",
+    "nlp"
+  ],
+  "homepage": "https://promplate.dev/partial-json-parser",
+  "repository": "https://github.com/promplate/partial-json-parser-js",
+  "license": "MIT",
+  "author": "Muspi Merol <me@promplate.dev>",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./options": {
+      "types": "./dist/options.d.ts",
+      "default": "./dist/options.js"
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "coverage": "vitest run --coverage",
+    "test": "vitest",
+    "test:ui": "vitest --ui"
+  },
+  "devDependencies": {
+    "@vitest/coverage-istanbul": "^1.2.2",
+    "@vitest/ui": "^1.2.2",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.2"
+  }
+}

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

@@ -1,6 +1,6 @@
 {
 	"name": "switchboard-local",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"type": "module",
 	"description": "Local models in the pi model picker, managed end to end",
 	"keywords": [
@@ -24,11 +24,12 @@
 		]
 	},
 	"dependencies": {
-		"@valni/switchboard": "git+https://github.com/Valni-Labs/switchboard-ts.git#d132540a1fd86491ffabb9327ec38bb903f709a3"
+		"@valni/switchboard": "git+https://github.com/Valni-Labs/switchboard-ts.git#d132540a1fd86491ffabb9327ec38bb903f709a3",
+		"partial-json": "0.1.7"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-ai": "0.82.1",
-		"@earendil-works/pi-coding-agent": "0.82.1",
+		"@earendil-works/pi-ai": ">=1.0.0",
+		"@earendil-works/pi-coding-agent": ">=1.0.0",
 		"typescript": "5.9.3"
 	}
 }

package/runtime/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@valni/cli",
 	"private": true,
-	"version": "0.1.5",
+	"version": "0.1.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"valniConfig": {
@@ -38,11 +38,11 @@
 		"prepublishOnly": "npm run clean && npm run build && npm run shrinkwrap"
 	},
 	"dependencies": {
-		"@valni/agent-core": "^0.1.5",
-		"@valni/ai": "^0.1.5",
-		"@valni/tui": "^0.1.5",
-		"pi-switchboard": "git+https://github.com/Valni-Labs/pi-switchboard.git#b35310164e79b3f99bfd697622527a8458e1719d",
-		"switchboard-local": "git+https://github.com/Valni-Labs/switchboard-local.git#bda14d2d85735da4519f4545b598b4c5e97e7d3b",
+		"@valni/agent-core": "^0.1.7",
+		"@valni/ai": "^0.1.7",
+		"@valni/tui": "^0.1.7",
+		"pi-switchboard": "git+https://github.com/Valni-Labs/pi-switchboard.git#774f1a7985a755fcd483313b729864aa8a9418c3",
+		"switchboard-local": "git+https://github.com/Valni-Labs/switchboard-local.git#4ec07263591a4f329fd12eab04d62d6c455be666",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "5.6.2",
 		"cross-spawn": "7.0.6",

package/runtime/valni

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/runtime/valni
 size: 76058832 bytes
-sha256: 9b45d462f5ec1584ac199c4d4056aae97d26bccca546f0040de9724ea86984b1
+sha256: 270e1c1d383b4800d98c432e23186cd63690ca5c8387a97cbcd4bd8057343ad1