@cr1ms0n/pi-subagent 0.8.9 → 0.9.0

package/src/model-policy.ts

@@ -1,169 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { isThinkingLevel, type ThinkingLevel } from "./thinking.js";
-
-export const MODEL_POLICY_CONFIG_FILE = path.join(os.homedir(), ".pi", "subagent.json");
-
-export interface ModelRoute {
-  model: string;
-  /** Immutable order owned by the user configuration. */
-  fallbackModels: readonly string[];
-  /** Optional route default; callers may override it with task/agent/profile settings. */
-  thinking?: ThinkingLevel;
-}
-
-export interface ModelPolicySnapshot {
-  default: ModelRoute;
-  agents: ReadonlyMap<string, ModelRoute>;
-  source: string;
-}
-
-export interface ModelPolicyValidation {
-  route?: ModelRoute;
-  error?: string;
-}
-
-const AGENT_NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
-
-function invalid(source: string, message: string): never {
-  throw new Error(`Invalid modelPolicy in ${source}: ${message}`);
-}
-
-function modelId(value: unknown, pathName: string, source: string): string {
-  if (typeof value !== "string") invalid(source, `${pathName}.model must be a string in provider/model-id form`);
-  const model = value.trim();
-  const slash = model.indexOf("/");
-  if (!model || slash <= 0 || slash === model.length - 1 || /[\x00-\x1f\s]/.test(model)) {
-    invalid(source, `${pathName}.model must be a non-empty provider/model-id without whitespace`);
-  }
-  return model;
-}
-
-function route(value: unknown, pathName: string, source: string): ModelRoute {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    invalid(source, `${pathName} must be an object`);
-  }
-  const record = value as Record<string, unknown>;
-  const unknown = Object.keys(record).filter((key) => key !== "model" && key !== "fallbackModels" && key !== "thinking");
-  if (unknown.length) invalid(source, `${pathName} has unknown field(s): ${unknown.join(", ")}`);
-  const model = modelId(record.model, pathName, source);
-  const rawFallbacks = record.fallbackModels === undefined ? [] : record.fallbackModels;
-  if (!Array.isArray(rawFallbacks)) invalid(source, `${pathName}.fallbackModels must be an array`);
-  const fallbackModels = rawFallbacks.map((value, index) => modelId(value, `${pathName}.fallbackModels[${index}]`, source));
-  if (new Set(fallbackModels).size !== fallbackModels.length) invalid(source, `${pathName}.fallbackModels must not contain duplicates`);
-  if (fallbackModels.includes(model)) invalid(source, `${pathName}.fallbackModels must not repeat the primary model`);
-  const thinking = record.thinking;
-  if (thinking !== undefined && !isThinkingLevel(thinking)) {
-    invalid(source, `${pathName}.thinking must be a non-empty Pi thinking level string without whitespace or control characters`);
-  }
-  return Object.freeze({
-    model,
-    fallbackModels: Object.freeze([...fallbackModels]),
-    ...(thinking === undefined ? {} : { thinking }),
-  });
-}
-
-/** Parse only the modelPolicy subtree; no provider catalog or credentials are read. */
-export function parseModelPolicy(raw: unknown, source = MODEL_POLICY_CONFIG_FILE): ModelPolicySnapshot {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    invalid(source, "modelPolicy must be an object");
-  }
-  const record = raw as Record<string, unknown>;
-  const unknown = Object.keys(record).filter((key) => key !== "default" && key !== "agents");
-  if (unknown.length) invalid(source, `modelPolicy has unknown field(s): ${unknown.join(", ")}`);
-  if (!("default" in record)) invalid(source, "modelPolicy.default is required");
-  const defaultRoute = route(record.default, "modelPolicy.default", source);
-  const agents = new Map<string, ModelRoute>();
-  const rawAgents = record.agents === undefined ? {} : record.agents;
-  if (!rawAgents || typeof rawAgents !== "object" || Array.isArray(rawAgents)) {
-    invalid(source, "modelPolicy.agents must be an object");
-  }
-  for (const [name, value] of Object.entries(rawAgents as Record<string, unknown>)) {
-    const normalized = name.trim().toLowerCase();
-    if (!AGENT_NAME.test(normalized)) invalid(source, `modelPolicy.agents key ${JSON.stringify(name)} is not a valid agent name`);
-    if (agents.has(normalized)) invalid(source, `modelPolicy.agents contains duplicate agent ${normalized}`);
-    agents.set(normalized, route(value, `modelPolicy.agents.${normalized}`, source));
-  }
-  return Object.freeze({ default: defaultRoute, agents, source });
-}
-
-/** Read the raw config only far enough to validate modelPolicy. */
-export async function readModelPolicyFile(file = MODEL_POLICY_CONFIG_FILE): Promise<ModelPolicySnapshot> {
-  let raw: unknown;
-  try {
-    raw = JSON.parse(await fs.readFile(file, "utf8"));
-  } catch (error: any) {
-    if (error?.code === "ENOENT") throw new Error(`Model policy is not configured. Create ${file} using the model policy template.`);
-    throw new Error(`Could not read ${file} as JSON; model policy was not loaded.`);
-  }
-  if (!raw || typeof raw !== "object" || Array.isArray(raw) || !("modelPolicy" in (raw as Record<string, unknown>))) {
-    throw new Error(`Model policy is missing from ${file}. Add modelPolicy.default using the model policy template.`);
-  }
-  return parseModelPolicy((raw as Record<string, unknown>).modelPolicy, file);
-}
-
-export function resolveModelRoute(policy: ModelPolicySnapshot, agent?: string): ModelRoute {
-  const name = agent?.trim().toLowerCase();
-  return (name && policy.agents.get(name)) || policy.default;
-}
-
-/** Validate the caller-owned fields against the immutable configured route. */
-export function validateModelRequest(
-  policy: ModelPolicySnapshot,
-  options: { agent?: string; model?: string; fallbackModels?: string[]; fallbackModelsProvided?: boolean },
-): ModelPolicyValidation {
-  const route = resolveModelRoute(policy, options.agent);
-  const actualModel = options.model?.trim();
-  if (!actualModel) return { error: `model is required; expected configured model ${route.model}` };
-  if (actualModel !== route.model) {
-    return { error: `model ${JSON.stringify(actualModel)} does not match the configured model ${JSON.stringify(route.model)}${options.agent ? ` for agent ${options.agent}` : ""}` };
-  }
-  if (options.fallbackModelsProvided) {
-    const requested = (options.fallbackModels ?? []).map((model) => model.trim());
-    if (requested.length !== route.fallbackModels.length || requested.some((model, index) => model !== route.fallbackModels[index])) {
-      return {
-        error: `fallback_models must exactly match the configured order for ${actualModel}: [${route.fallbackModels.join(", ")}]`,
-      };
-    }
-  }
-  return { route };
-}
-
-export function formatModelPolicyPrompt(policy: ModelPolicySnapshot | undefined, error?: string): string {
-  if (!policy) {
-    return [
-      "## Subagent model policy",
-      error || `No valid model policy is configured at ${MODEL_POLICY_CONFIG_FILE}.`,
-      "Management actions (status/wait/cancel/steer/diff/apply/discard) remain available, but every new task/tasks[] spawn and plan request is rejected until modelPolicy is configured.",
-      "Use the package model-policy template; do not invent model IDs or fallback models.",
-    ].join("\n");
-  }
-  const lines = [
-    "## Subagent model policy",
-    "Every new task/tasks[] spawn must pass model explicitly and it must exactly match this mapping. Management actions do not need model.",
-    `default (agentless and unmapped agents): model=${policy.default.model}; fallback_models=[${policy.default.fallbackModels.join(", ")}]; thinking=${policy.default.thinking ?? "(unset)"}`,
-  ];
-  for (const [agent, route] of [...policy.agents.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-    lines.push(`agent:${agent}: model=${route.model}; fallback_models=[${route.fallbackModels.join(", ")}]; thinking=${route.thinking ?? "(unset)"}`);
-  }
-  lines.push(
-    "If fallback_models is omitted, the configured list is used. If it is supplied, it must match the configured list exactly, including order.",
-    "thinking is a route default: explicit task thinking, agent thinking, and profile taskDefaults.thinking override it; parent thinking is used only when the route is unset.",
-    "Do not use model/fallback_models from agent frontmatter, taskDefaults, or the parent session; those legacy model fields are ignored.",
-  );
-  return lines.join("\n");
-}
-
-export function modelPolicyTemplate(): string {
-  return JSON.stringify({
-    modelPolicy: {
-      default: { model: "<provider/model-id>", fallbackModels: [], thinking: "medium" },
-      agents: { "<agent-name>": { model: "<provider/model-id>", fallbackModels: [], thinking: "high" } },
-    },
-  }, null, 2);
-}
-
-export function modelPolicySource(file = MODEL_POLICY_CONFIG_FILE): string {
-  return path.normalize(file);
-}