@centerforagenticai/pi-multi-account 0.1.1

package/src/bounded-file-lines.ts

@@ -0,0 +1,97 @@
+import { closeSync, openSync, readSync } from "node:fs";
+
+export const DEFAULT_FILE_READ_CHUNK_BYTES = 64 * 1024;
+const MAX_FILE_READ_CHUNK_BYTES = 1024 * 1024;
+
+export interface BoundedFileLineReadOptions {
+	readonly maxLineBytes: number;
+	readonly chunkBytes?: number;
+	readonly includeIncompleteFinalLine?: boolean;
+	readonly maxBytes?: number;
+	readonly onReadChunk?: (bytes: number) => void;
+}
+
+export function normalizedFileReadChunkBytes(value: number | undefined): number {
+	const chunkBytes = value ?? DEFAULT_FILE_READ_CHUNK_BYTES;
+	if (
+		!Number.isSafeInteger(chunkBytes) ||
+		chunkBytes < 1 ||
+		chunkBytes > MAX_FILE_READ_CHUNK_BYTES
+	) {
+		throw new RangeError("chunkBytes must be a safe integer from 1 to 1048576.");
+	}
+	return chunkBytes;
+}
+
+/**
+ * Iterate complete bounded UTF-8 lines without decoding or retaining the whole file.
+ * Lines above maxLineBytes are skipped until their next newline.
+ */
+export function* iterateBoundedFileLines(
+	path: string,
+	options: BoundedFileLineReadOptions,
+): Generator<string> {
+	if (!Number.isSafeInteger(options.maxLineBytes) || options.maxLineBytes < 1) {
+		throw new RangeError("maxLineBytes must be a positive safe integer.");
+	}
+	const chunkBytes = normalizedFileReadChunkBytes(options.chunkBytes);
+	if (
+		options.maxBytes !== undefined &&
+		(!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)
+	) {
+		throw new RangeError("maxBytes must be a non-negative safe integer.");
+	}
+	const includeIncompleteFinalLine = options.includeIncompleteFinalLine ?? true;
+	const descriptor = openSync(path, "r");
+	const readBuffer = Buffer.allocUnsafe(chunkBytes);
+	let fragments: Buffer[] = [];
+	let lineBytes = 0;
+	let oversized = false;
+
+	const addSegment = (segment: Buffer): void => {
+		if (oversized || segment.length === 0) return;
+		if (lineBytes + segment.length > options.maxLineBytes) {
+			fragments = [];
+			lineBytes = 0;
+			oversized = true;
+			return;
+		}
+		fragments.push(Buffer.from(segment));
+		lineBytes += segment.length;
+	};
+	const finishLine = (): string | undefined => {
+		const value = oversized
+			? undefined
+			: Buffer.concat(fragments, lineBytes).toString("utf8");
+		fragments = [];
+		lineBytes = 0;
+		oversized = false;
+		return value;
+	};
+
+	let remainingBytes = options.maxBytes ?? Number.POSITIVE_INFINITY;
+	try {
+		while (remainingBytes > 0) {
+			const requested = Math.min(readBuffer.length, remainingBytes);
+			const bytesRead = readSync(descriptor, readBuffer, 0, requested, null);
+			if (bytesRead === 0) break;
+			remainingBytes -= bytesRead;
+			options.onReadChunk?.(bytesRead);
+			let segmentStart = 0;
+			for (let index = 0; index < bytesRead; index += 1) {
+				if (readBuffer[index] !== 0x0a) continue;
+				addSegment(readBuffer.subarray(segmentStart, index));
+				const line = finishLine();
+				if (line !== undefined) yield line;
+				segmentStart = index + 1;
+			}
+			addSegment(readBuffer.subarray(segmentStart, bytesRead));
+		}
+		if (includeIncompleteFinalLine && (fragments.length > 0 || oversized)) {
+			const line = finishLine();
+			if (line !== undefined) yield line;
+		}
+	} finally {
+		closeSync(descriptor);
+	}
+}

package/src/catalog-rebinding.ts

@@ -0,0 +1,177 @@
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+
+export interface LiveCatalogCost extends Record<string, unknown> {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  tiers?: Array<
+    Record<string, unknown> & {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+      inputTokensAbove: number;
+    }
+  >;
+}
+
+export interface LiveCatalogModel extends Record<string, unknown> {
+  id: string;
+  name: string;
+  provider: string;
+  api: string;
+  baseUrl: string;
+  reasoning: boolean;
+  input: ("text" | "image")[];
+  cost: LiveCatalogCost;
+  contextWindow: number;
+  maxTokens: number;
+}
+
+export interface LiveModelRegistrySurface {
+  getAll(): readonly unknown[];
+}
+
+export interface AliasCatalogRequest {
+  registry: unknown;
+  baseProvider: string;
+  aliasProvider: string;
+  displayLabel: string;
+}
+
+export class CatalogRebindingCompatibilityError extends Error {
+  readonly feature = "pi.model-registry-live-catalog" as const;
+  readonly remediation =
+    "Use the current public ExtensionContext.modelRegistry.getAll surface; do not import a private registry or hard-code model IDs.";
+
+  constructor(message: string) {
+    super(
+      `[pi.model-registry-live-catalog] ${message} Action: ${
+        "Use the current public ExtensionContext.modelRegistry.getAll surface; do not import a private registry or hard-code model IDs."
+      }`,
+    );
+    this.name = "CatalogRebindingCompatibilityError";
+  }
+}
+
+const isRecord = (value: unknown): value is Record<PropertyKey, unknown> =>
+  typeof value === "object" && value !== null;
+
+function isLiveCatalogModel(value: unknown): value is LiveCatalogModel {
+  return (
+    isRecord(value) &&
+    typeof value.id === "string" &&
+    typeof value.name === "string" &&
+    typeof value.provider === "string" &&
+    typeof value.api === "string" &&
+    typeof value.baseUrl === "string" &&
+    typeof value.reasoning === "boolean" &&
+    Array.isArray(value.input) &&
+    isRecord(value.cost) &&
+    typeof value.contextWindow === "number" &&
+    typeof value.maxTokens === "number"
+  );
+}
+
+function readLiveCatalog(registry: unknown): readonly unknown[] {
+  if (!isRecord(registry) || typeof registry.getAll !== "function") {
+    throw new CatalogRebindingCompatibilityError(
+      "ExtensionContext.modelRegistry.getAll is unavailable, so the live base catalog cannot be derived.",
+    );
+  }
+
+  let catalog: unknown;
+  try {
+    catalog = Reflect.apply(registry.getAll, registry, []);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CatalogRebindingCompatibilityError(
+      `ExtensionContext.modelRegistry.getAll threw: ${detail}`,
+    );
+  }
+
+  if (!Array.isArray(catalog)) {
+    throw new CatalogRebindingCompatibilityError(
+      `ExtensionContext.modelRegistry.getAll returned ${typeof catalog}; expected an array.`,
+    );
+  }
+  return catalog;
+}
+
+function cloneModel(model: LiveCatalogModel): LiveCatalogModel {
+  try {
+    return structuredClone(model) as LiveCatalogModel;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CatalogRebindingCompatibilityError(
+      `Live model ${model.provider}/${model.id} could not be losslessly cloned: ${detail}`,
+    );
+  }
+}
+
+/**
+ * Reads and deep-clones every model for one live provider. Future public model
+ * fields are preserved and no mutable descendant is shared with the registry.
+ */
+function cloneLiveProviderCatalog(
+  registry: unknown,
+  baseProvider: string,
+): LiveCatalogModel[] {
+  const models: LiveCatalogModel[] = [];
+  for (const candidate of readLiveCatalog(registry)) {
+    if (!isRecord(candidate) || candidate.provider !== baseProvider) continue;
+    if (!isLiveCatalogModel(candidate)) {
+      const modelId = typeof candidate.id === "string" ? candidate.id : "<unknown>";
+      throw new CatalogRebindingCompatibilityError(
+        `Live ${baseProvider} model ${modelId} is missing a required public model field.`,
+      );
+    }
+    models.push(cloneModel(candidate));
+  }
+  return models;
+}
+
+/**
+ * Converts a lossless live snapshot into provider-registration models. Only the
+ * registry-owned provider identity is removed; all current/future model fields
+ * and nested metadata remain deeply cloned.
+ */
+export function cloneProviderModelCatalog(
+  registry: unknown,
+  baseProvider: string,
+): ProviderModelConfig[] {
+  return cloneLiveProviderCatalog(registry, baseProvider).map((model) => {
+    const providerModel = cloneModel(model);
+    Reflect.deleteProperty(providerModel, "provider");
+    return providerModel as ProviderModelConfig;
+  });
+}
+
+/**
+ * Derives aliases from the registry snapshot available at call time. The deep
+ * clone deliberately occurs before the two intentional identity/display
+ * replacements, preserving current and future data fields without shared
+ * mutable descendants.
+ */
+export function deriveLiveAliasCatalog(
+  request: AliasCatalogRequest,
+): LiveCatalogModel[] {
+  const { baseProvider, aliasProvider, displayLabel } = request;
+  if (!baseProvider.trim() || !aliasProvider.trim()) {
+    throw new CatalogRebindingCompatibilityError(
+      "Base and alias provider IDs must both be non-empty.",
+    );
+  }
+  if (baseProvider === aliasProvider) {
+    throw new CatalogRebindingCompatibilityError(
+      `Alias provider ${aliasProvider} must be distinct from its base provider.`,
+    );
+  }
+
+  return cloneLiveProviderCatalog(request.registry, baseProvider).map((alias) => {
+    alias.provider = aliasProvider;
+    alias.name = `${alias.name} (${displayLabel})`;
+    return alias;
+  });
+}

package/src/catalog-registration-probe.ts

@@ -0,0 +1,111 @@
+import type {
+  ProviderConfig,
+  ProviderModelConfig,
+} from "@earendil-works/pi-coding-agent";
+import {
+  deriveLiveAliasCatalog,
+  type LiveCatalogModel,
+  type LiveModelRegistrySurface,
+} from "./catalog-rebinding.js";
+
+export interface AliasProviderProbe {
+  baseProvider: string;
+  aliasProvider: string;
+  displayLabel: string;
+  isolatedApi: string;
+  streamSimple: NonNullable<ProviderConfig["streamSimple"]>;
+}
+
+export interface ProviderRegistrationSurface {
+  registerProvider(name: string, config: ProviderConfig): void;
+  unregisterProvider(name: string): void;
+}
+
+export interface CatalogRegistrationProbeInput {
+  extensionApi: ProviderRegistrationSurface;
+  extensionContext: { modelRegistry: LiveModelRegistrySurface };
+  aliases: readonly AliasProviderProbe[];
+}
+
+export interface AliasRegistrationRecord {
+  baseProvider: string;
+  aliasProvider: string;
+  isolatedApi: string;
+  sourceApis: readonly string[];
+  models: readonly LiveCatalogModel[];
+}
+
+function asProviderModel(
+  model: LiveCatalogModel,
+  isolatedApi: string,
+): ProviderModelConfig {
+  const registeredModel = structuredClone(model);
+  Reflect.deleteProperty(registeredModel, "provider");
+  registeredModel.api = isolatedApi;
+  return registeredModel as ProviderModelConfig;
+}
+
+/**
+ * Investigation-only composition probe. It reads the live public registry on
+ * every invocation, then calls the public provider-registration surface. An
+ * isolated API ID is used only at registration time so OAuth-specific stream
+ * behavior cannot replace a base provider's shared API handler.
+ */
+export function registerLiveAliasCatalogs(
+  input: CatalogRegistrationProbeInput,
+): AliasRegistrationRecord[] {
+  const seenProviders = new Set<string>();
+  const seenApis = new Set<string>();
+  const records: AliasRegistrationRecord[] = [];
+
+  for (const aliasRequest of input.aliases) {
+    if (seenProviders.has(aliasRequest.aliasProvider)) {
+      throw new Error(`Duplicate alias provider: ${aliasRequest.aliasProvider}`);
+    }
+    if (seenApis.has(aliasRequest.isolatedApi)) {
+      throw new Error(`Duplicate isolated API handler slot: ${aliasRequest.isolatedApi}`);
+    }
+
+    const aliases = deriveLiveAliasCatalog({
+      registry: input.extensionContext.modelRegistry,
+      baseProvider: aliasRequest.baseProvider,
+      aliasProvider: aliasRequest.aliasProvider,
+      displayLabel: aliasRequest.displayLabel,
+    });
+    const sourceApis = [...new Set(aliases.map(({ api }) => api))];
+    if (sourceApis.includes(aliasRequest.isolatedApi)) {
+      throw new Error(
+        `Alias provider ${aliasRequest.aliasProvider} must use an isolated API handler slot, not source API ${aliasRequest.isolatedApi}.`,
+      );
+    }
+
+    seenProviders.add(aliasRequest.aliasProvider);
+    seenApis.add(aliasRequest.isolatedApi);
+
+    // Public unregister is required even for an empty new snapshot: Pi treats
+    // registerProvider({ models: [] }) as no replacement, which would otherwise
+    // leave the previous alias catalog stale.
+    input.extensionApi.unregisterProvider(aliasRequest.aliasProvider);
+    const firstAlias = aliases[0];
+    if (firstAlias) {
+      input.extensionApi.registerProvider(aliasRequest.aliasProvider, {
+        api: aliasRequest.isolatedApi,
+        baseUrl: firstAlias.baseUrl,
+        streamSimple: aliasRequest.streamSimple,
+        models: aliases.map((model) =>
+          asProviderModel(model, aliasRequest.isolatedApi),
+        ),
+      });
+    }
+
+    records.push({
+      baseProvider: aliasRequest.baseProvider,
+      aliasProvider: aliasRequest.aliasProvider,
+      isolatedApi: aliasRequest.isolatedApi,
+      sourceApis,
+      models: aliases,
+    });
+  }
+
+  return records;
+}