@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/src/shared/json-projection.ts

@@ -0,0 +1,224 @@
+import { jsonParser, type Token } from "stream-json/core/parser.js";
+import { none } from "stream-chain/defs.js";
+import { isRecord, type UnknownRecord } from "./unknown.ts";
+
+export type Projection = (
+  path: readonly (string | number)[],
+  root?: UnknownRecord,
+) => boolean | number;
+export type KeyLimit = (parentPath: readonly (string | number)[], root?: UnknownRecord) => number;
+export type StringChunk = (
+  path: readonly (string | number)[],
+  text: string,
+  root?: UnknownRecord,
+) => void;
+export interface ProjectionLimits {
+  readonly depth: number;
+  readonly nodes: number;
+  readonly arrayLength: number;
+  readonly keyLength: number;
+}
+interface Container {
+  path: (string | number)[];
+  value?: Record<string, unknown> | unknown[];
+  key: string;
+  index: number;
+}
+
+function retained(keep: boolean | number): boolean {
+  return keep === true || (typeof keep === "number" && keep !== 0 && !Number.isNaN(keep));
+}
+
+/** Validate all tokens, assembling selected values only. Skipped strings remain unpacked. */
+export class JsonProjection {
+  private readonly parse = jsonParser({ packValues: false });
+  private readonly stack: Container[] = [];
+  private scalar?: { path: (string | number)[]; text: string; limit: number; number: boolean };
+  private key = false;
+  private keyLimit = 4096;
+  private nodes = 0;
+  private readonly select: Projection;
+  private readonly stringChunk?: StringChunk;
+  private readonly keys: KeyLimit;
+  private readonly limits?: ProjectionLimits;
+  value: unknown;
+  constructor(
+    select: Projection,
+    stringChunk?: StringChunk,
+    keys: KeyLimit = () => 4096,
+    limits?: ProjectionLimits,
+  ) {
+    this.select = select;
+    this.stringChunk = stringChunk;
+    this.keys = keys;
+    this.limits = limits;
+  }
+  private root(): UnknownRecord | undefined {
+    return isRecord(this.value) ? this.value : undefined;
+  }
+  private parent(): Container {
+    const parent = this.stack.at(-1);
+    if (!parent) {
+      throw new SyntaxError("JSON token requires a containing object");
+    }
+    return parent;
+  }
+  private selected(path: readonly (string | number)[]): boolean | number {
+    const parent = this.stack.at(-1);
+    const keep = parent && parent.value === undefined ? false : this.select(path, this.root());
+    if (retained(keep) && this.limits && ++this.nodes > this.limits.nodes) {
+      throw new RangeError("JSON projection exceeds its assembled-node budget.");
+    }
+    return keep;
+  }
+  private nextPath(): (string | number)[] {
+    const parent = this.stack.at(-1);
+    if (
+      this.limits &&
+      (this.stack.length > this.limits.depth || (parent && parent.index >= this.limits.arrayLength))
+    ) {
+      throw new RangeError("JSON projection exceeds its depth or array-position budget.");
+    }
+    if (!parent) {
+      return [];
+    }
+    return [...parent.path, parent.index >= 0 ? parent.index++ : parent.key];
+  }
+  private put(path: readonly (string | number)[], value: unknown): void {
+    const parent = this.stack.at(-1);
+    if (!parent) {
+      this.value = value;
+      return;
+    }
+    const key = path.at(-1);
+    if (parent.value !== undefined && key !== undefined) {
+      Object.defineProperty(parent.value, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+      });
+    }
+  }
+  private startContainer(array: boolean): void {
+    const path = this.nextPath();
+    const keep = this.selected(path);
+    let value: Container["value"];
+    if (retained(keep)) {
+      value = array ? [] : {};
+      this.put(path, value);
+    }
+    this.stack.push({ path, value, key: "", index: array ? 0 : -1 });
+  }
+  private startScalar(number: boolean): void {
+    const path = this.nextPath();
+    const keep = this.selected(path);
+    const selectedLimit = keep === true ? Infinity : Number(keep);
+    const limit = Number.isNaN(selectedLimit) ? 0 : selectedLimit;
+    this.scalar = { path, text: "", limit, number };
+  }
+  private appendKey(text: string): void {
+    const parent = this.parent();
+    if (
+      parent.value !== undefined &&
+      this.limits &&
+      parent.key.length + text.length > this.limits.keyLength
+    ) {
+      throw new RangeError("JSON projection exceeds its property-key budget.");
+    }
+    if (parent.key.length < this.keyLimit) {
+      parent.key += text.slice(0, this.keyLimit - parent.key.length);
+    }
+  }
+  private appendScalar(text: string, string: boolean): void {
+    const scalar = this.scalar;
+    if (!scalar) {
+      return;
+    }
+    if (string) {
+      this.stringChunk?.(scalar.path, text, this.root());
+    }
+    if (scalar.text.length < scalar.limit) {
+      scalar.text += text.slice(0, scalar.limit - scalar.text.length);
+    }
+  }
+  private finishScalar(): void {
+    const scalar = this.scalar;
+    if (scalar && scalar.limit !== 0) {
+      this.put(scalar.path, scalar.number ? Number(scalar.text) : scalar.text);
+    }
+    this.scalar = undefined;
+  }
+  private token(token: Readonly<Token>): void {
+    switch (token.name) {
+      case "startKey": {
+        const parent = this.parent();
+        this.key = true;
+        parent.key = "";
+        this.keyLimit = parent.value === undefined ? 0 : this.keys(parent.path, this.root());
+        break;
+      }
+      case "endKey":
+        this.key = false;
+        break;
+      case "startObject":
+        this.startContainer(false);
+        break;
+      case "startArray":
+        this.startContainer(true);
+        break;
+      case "endObject":
+      case "endArray":
+        this.stack.pop();
+        break;
+      case "startString":
+        this.startScalar(false);
+        break;
+      case "startNumber":
+        this.startScalar(true);
+        break;
+      case "stringChunk":
+      case "numberChunk":
+        if (this.key) {
+          this.appendKey(token.value);
+        } else {
+          this.appendScalar(token.value, token.name === "stringChunk");
+        }
+        break;
+      case "endString":
+      case "endNumber":
+        this.finishScalar();
+        break;
+      case "trueValue":
+      case "falseValue":
+      case "nullValue": {
+        const path = this.nextPath();
+        const keep = this.selected(path);
+        if (retained(keep)) {
+          this.put(path, token.value);
+        }
+        break;
+      }
+      case "keyValue":
+      case "stringValue":
+      case "numberValue":
+      case "whitespace":
+        break; // Packing is disabled; whitespace carries no projected value.
+    }
+  }
+  write(chunk: string | symbol): void {
+    if (typeof chunk === "symbol" && chunk !== none) {
+      throw new TypeError("Unknown JSON tokenizer sentinel");
+    }
+    const output = this.parse(typeof chunk === "symbol" ? none : chunk);
+    if (typeof output !== "symbol") {
+      for (const token of output.values) {
+        this.token(token);
+      }
+    }
+  }
+  finish(): unknown {
+    this.write(none);
+    return this.value;
+  }
+}

package/src/shared/lazy-tools.ts

@@ -1,36 +1,85 @@
 import { getCurrentSystemMessage } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionContext, SessionManager } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  SessionManager,
+} from "@earendil-works/pi-coding-agent";
 
-const declarations = new WeakMap<ExtensionContext["sessionManager"], {
-	leaf: string | null; count: number | undefined; current: ReturnType<typeof getCurrentSystemMessage>;
-}>();
+const declarations = new WeakMap<
+  ExtensionContext["sessionManager"],
+  {
+    leaf: string | null;
+    count: number | undefined;
+    current: ReturnType<typeof getCurrentSystemMessage>;
+  }
+>();
 
 /** Only our unnamespaced tools are owned here; foreign public IDs pass through untouched. */
 export function activateTools(pi: ExtensionAPI, names: readonly string[]): void {
-	const available = pi.getAllTools();
-	const active = pi.getActiveTools();
-	const added = names.filter((name) => !active.includes(name) && available.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace)));
-	if (added.length) pi.setActiveTools([...active, ...new Set(added)]);
+  const available = pi.getAllTools();
+  const active = pi.getActiveTools();
+  const added = names.filter(
+    (name) =>
+      !active.includes(name) &&
+      available.some(
+        (tool) =>
+          tool.name === name &&
+          !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
+      ),
+  );
+  if (added.length > 0) {
+    pi.setActiveTools([...active, ...new Set(added)]);
+  }
 }
 
 /** Official 1.0 SDK creation omits initial resume restoration; tree/reload are native. */
-export function restoreLazyTools(pi: ExtensionAPI, ctx: ExtensionContext, loader: string, names: readonly string[]): void {
-	const available = pi.getAllTools();
-	// A tool-only allowlist must remain usable without its discovery entry.
-	if (!available.some((tool) => tool.name === loader && !("namespace" in tool && tool.namespace))) {
-		activateTools(pi, names);
-		return;
-	}
-	const manager = ctx.sessionManager, leaf = manager.getLeafId(), count = (manager as Partial<SessionManager>).getEntryCount?.();
-	let cached = declarations.get(manager);
-	if (count === undefined || !cached || cached.leaf !== leaf || cached.count !== count) {
-		cached = { leaf, count, current: getCurrentSystemMessage(manager.buildSessionProjection().messages) };
-		declarations.set(manager, cached);
-	}
-	const declared = cached.current;
-	if (!declared) return;
-	const selected = declared?.toolsAdded ?? [];
-	const restored = names.filter((name) => selected.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace))
-		&& available.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace)));
-	activateTools(pi, restored);
+export function restoreLazyTools(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  loader: string,
+  names: readonly string[],
+): void {
+  const available = pi.getAllTools();
+  // A tool-only allowlist must remain usable without its discovery entry.
+  if (
+    !available.some(
+      (tool) =>
+        tool.name === loader &&
+        !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
+    )
+  ) {
+    activateTools(pi, names);
+    return;
+  }
+  const manager = ctx.sessionManager,
+    leaf = manager.getLeafId(),
+    count = (manager as Partial<SessionManager>).getEntryCount?.();
+  let cached = declarations.get(manager);
+  if (count === undefined || !cached || cached.leaf !== leaf || cached.count !== count) {
+    cached = {
+      leaf,
+      count,
+      current: getCurrentSystemMessage(manager.buildSessionProjection().messages),
+    };
+    declarations.set(manager, cached);
+  }
+  const declared = cached.current;
+  if (!declared) {
+    return;
+  }
+  const selected = declared.toolsAdded ?? [];
+  const restored = names.filter(
+    (name) =>
+      selected.some(
+        (tool) =>
+          tool.name === name &&
+          !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
+      ) &&
+      available.some(
+        (tool) =>
+          tool.name === name &&
+          !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
+      ),
+  );
+  activateTools(pi, restored);
 }

package/src/shared/message-output.ts

@@ -0,0 +1,146 @@
+import { formatToolCall } from "./formatters.ts";
+import type {
+  DisplayItem,
+  ErrorInfo,
+  ObservedMessage,
+  ReadonlySingleResult,
+  SingleResult,
+  ToolCallSummary,
+} from "./types.ts";
+
+type AssistantObservation = Extract<ObservedMessage, { role: "assistant" }>;
+type ToolObservation = Extract<ObservedMessage, { role: "toolResult" }>;
+function assistantText(message: AssistantObservation): string {
+  if (
+    (message.errorMessage !== undefined && message.errorMessage.length > 0) ||
+    message.stopReason === "error"
+  ) {
+    return "";
+  }
+  for (let j = message.content.length - 1; j >= 0; j--) {
+    const part = message.content[j];
+    if (part.type === "text" && part.text.trim().length > 0) {
+      return part.text;
+    }
+  }
+  return "";
+}
+/** Last non-error assistant text, accepting honest incomplete native observations. */
+export function getFinalOutput(messages: readonly ObservedMessage[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "assistant") {
+      const text = assistantText(message);
+      if (text !== "") {
+        return text;
+      }
+    }
+  }
+  return "";
+}
+export function getSingleResultOutput(
+  result: Readonly<Pick<SingleResult, "finalOutput" | "messages">>,
+): string {
+  return result.finalOutput ?? getFinalOutput(result.messages ?? []);
+}
+export function formatResourceLimitExceeded(input: {
+  readonly agent: string;
+  readonly kind: "maxExecutionTimeMs" | "maxTokens";
+  readonly limit: number;
+  readonly observed?: number;
+}): string {
+  if (input.kind === "maxExecutionTimeMs") {
+    return `Resource limit exceeded for ${input.agent}: maxExecutionTimeMs ${input.limit}ms.`;
+  }
+  return `Resource limit exceeded for ${input.agent}: maxTokens ${input.limit}${input.observed !== undefined ? ` (observed ${input.observed})` : ""}.`;
+}
+function assistantItems(message: AssistantObservation): DisplayItem[] {
+  return message.content.flatMap((part): DisplayItem[] => {
+    if (part.type === "text") {
+      return [{ type: "text", text: part.text }];
+    }
+    return part.type === "toolCall"
+      ? [{ type: "tool", name: part.name, args: part.arguments }]
+      : [];
+  });
+}
+export function getDisplayItems(messages: readonly ObservedMessage[] | undefined): DisplayItem[] {
+  return (messages ?? []).flatMap((message) =>
+    message.role === "assistant" ? assistantItems(message) : [],
+  );
+}
+function extractToolCallSummaries(
+  messages: readonly ObservedMessage[] | undefined,
+): ToolCallSummary[] {
+  return (messages ?? []).flatMap((message) => {
+    if (message.role !== "assistant") {
+      return [];
+    }
+    return message.content.flatMap((part) =>
+      part.type === "toolCall"
+        ? [
+            {
+              text: formatToolCall(part.name, part.arguments),
+              expandedText: formatToolCall(part.name, part.arguments, true),
+            },
+          ]
+        : [],
+    );
+  });
+}
+export function compactForegroundResult(result: ReadonlySingleResult): ReadonlySingleResult {
+  if (result.progress?.status === "running") {
+    return result;
+  }
+  const toolCalls =
+    result.toolCalls !== undefined && result.toolCalls.length > 0
+      ? result.toolCalls
+      : extractToolCallSummaries(result.messages);
+  return {
+    ...result,
+    messages: undefined,
+    progress: undefined,
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+  };
+}
+function lastAssistantText(messages: readonly ObservedMessage[]): number {
+  return messages.findLastIndex(
+    (message) =>
+      message.role === "assistant" &&
+      message.content.some((part) => part.type === "text" && part.text.trim().length > 0),
+  );
+}
+function toolExitCode(message: ToolObservation, text: string | undefined): number | undefined {
+  const match = text?.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
+  return message.observedExitCode ?? (match ? parseInt(match[1], 10) : undefined);
+}
+function toolError(message: ToolObservation): ErrorInfo | undefined {
+  const text = message.content.find((part) => part.type === "text")?.text;
+  const code = toolExitCode(message, text);
+  if (message.isError === true) {
+    return {
+      hasError: true,
+      exitCode: code ?? 1,
+      errorType: message.toolName !== "" ? message.toolName : "tool",
+      details: text?.slice(0, 200),
+    };
+  }
+  if (message.toolName === "bash" && text !== undefined && code !== undefined && code !== 0) {
+    return { hasError: true, exitCode: code, errorType: "bash", details: text.slice(0, 200) };
+  }
+  return undefined;
+}
+/** Errors superseded by later assistant success do not fail the result. */
+export function detectSubagentError(messages: readonly ObservedMessage[]): ErrorInfo {
+  const start = lastAssistantText(messages) + 1;
+  for (let i = messages.length - 1; i >= start; i--) {
+    const message = messages[i];
+    if (message.role === "toolResult") {
+      const error = toolError(message);
+      if (error) {
+        return error;
+      }
+    }
+  }
+  return { hasError: false };
+}

package/src/shared/model-info.ts

@@ -1,81 +1,117 @@
 export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-export type ThinkingLevel = typeof THINKING_LEVELS[number];
-export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
-
-export interface ModelInfo {
-	provider: string;
-	id: string;
-	fullId: string;
-	reasoning?: boolean;
-	thinkingLevelMap?: ThinkingLevelMap;
-}
+import type { ModelInfo, ThinkingLevel, ThinkingLevelMap } from "./types/config.ts";
+export type { ModelInfo, ThinkingLevel, ThinkingLevelMap } from "./types/config.ts";
 
 interface RegistryModelLike {
-	provider: string;
-	id: string;
-	reasoning?: boolean;
-	thinkingLevelMap?: ThinkingLevelMap;
+  readonly provider: string;
+  readonly id: string;
+  readonly reasoning?: boolean;
+  readonly thinkingLevelMap?: ThinkingLevelMap;
 }
 
 export function toModelInfo(model: RegistryModelLike): ModelInfo {
-	return {
-		provider: model.provider,
-		id: model.id,
-		fullId: `${model.provider}/${model.id}`,
-		reasoning: model.reasoning,
-		thinkingLevelMap: model.thinkingLevelMap,
-	};
+  return {
+    provider: model.provider,
+    id: model.id,
+    fullId: `${model.provider}/${model.id}`,
+    reasoning: model.reasoning,
+    thinkingLevelMap: model.thinkingLevelMap,
+  };
 }
 
-export function providerQualifiedModelId(provider: string | undefined, model: string | undefined): string | undefined {
-	if (!model) return undefined;
-	return provider && !model.startsWith(`${provider}/`) ? `${provider}/${model}` : model;
+export function providerQualifiedModelId(
+  provider: string | undefined,
+  model: string | undefined,
+): string | undefined {
+  if (model === undefined || model.length === 0) {
+    return undefined;
+  }
+  return provider !== undefined && provider.length > 0 && !model.startsWith(`${provider}/`)
+    ? `${provider}/${model}`
+    : model;
 }
 
 /** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
  * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
  * (e.g. no model was specified, or the model has no suffix and no config was provided). */
-export function resolveEffectiveThinking(model: string | undefined, configThinking: string | undefined): string | undefined {
-	if (!model) return undefined;
-	const { thinkingSuffix } = splitKnownThinkingSuffix(model);
-	if (thinkingSuffix) return thinkingSuffix.slice(1);
-	return THINKING_LEVELS.find((level) => level === configThinking);
+export function resolveEffectiveThinking(
+  model: string | undefined,
+  configThinking: string | undefined,
+): string | undefined {
+  if (model === undefined || model.length === 0) {
+    return undefined;
+  }
+  const { thinkingSuffix } = splitKnownThinkingSuffix(model);
+  if (thinkingSuffix.length > 0) {
+    return thinkingSuffix.slice(1);
+  }
+  return THINKING_LEVELS.find((level) => level === configThinking);
 }
 
-export function splitKnownThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
-	const colonIdx = model.lastIndexOf(":");
-	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
-	const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
-	if (!suffix) return { baseModel: model, thinkingSuffix: "" };
-	return {
-		baseModel: model.substring(0, colonIdx),
-		thinkingSuffix: `:${suffix}`,
-	};
+export function splitKnownThinkingSuffix(model: string): {
+  baseModel: string;
+  thinkingSuffix: string;
+} {
+  const colonIdx = model.lastIndexOf(":");
+  if (colonIdx === -1) {
+    return { baseModel: model, thinkingSuffix: "" };
+  }
+  const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
+  if (suffix === undefined) {
+    return { baseModel: model, thinkingSuffix: "" };
+  }
+  return {
+    baseModel: model.substring(0, colonIdx),
+    thinkingSuffix: `:${suffix}`,
+  };
 }
 
-export function findModelInfo(model: string | undefined, availableModels: ModelInfo[] | undefined, preferredProvider?: string): ModelInfo | undefined {
-	if (!model || !availableModels || availableModels.length === 0) return undefined;
-	const { baseModel } = splitKnownThinkingSuffix(model);
-	const exact = availableModels.find((entry) => entry.fullId === baseModel);
-	if (exact) return exact;
+export function findModelInfo(
+  model: string | undefined,
+  availableModels: readonly ModelInfo[] | undefined,
+  preferredProvider?: string,
+): ModelInfo | undefined {
+  if (
+    model === undefined ||
+    model.length === 0 ||
+    availableModels === undefined ||
+    availableModels.length === 0
+  ) {
+    return undefined;
+  }
+  const { baseModel } = splitKnownThinkingSuffix(model);
+  const exact = availableModels.find((entry) => entry.fullId === baseModel);
+  if (exact) {
+    return exact;
+  }
 
-	const matches = availableModels.filter((entry) => entry.id === baseModel);
-	if (preferredProvider) {
-		const preferred = matches.find((entry) => entry.provider === preferredProvider);
-		if (preferred) return preferred;
-	}
-	return matches.length === 1 ? matches[0] : undefined;
+  const matches = availableModels.filter((entry) => entry.id === baseModel);
+  if (preferredProvider !== undefined && preferredProvider.length > 0) {
+    const preferred = matches.find((entry) => entry.provider === preferredProvider);
+    if (preferred) {
+      return preferred;
+    }
+  }
+  return matches.length === 1 ? matches[0] : undefined;
 }
 
 export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
-	if (!model) return [...THINKING_LEVELS];
-	if (model.reasoning === false) return ["off"];
+  if (model === undefined) {
+    return [...THINKING_LEVELS];
+  }
+  if (model.reasoning === false) {
+    return ["off"];
+  }
 
-	const levels = THINKING_LEVELS.filter((level) => {
-		const mapped = model.thinkingLevelMap?.[level];
-		if (mapped === null) return false;
-		if (level === "xhigh" || level === "max") return mapped !== undefined;
-		return true;
-	});
-	return levels;
+  const levels = THINKING_LEVELS.filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+    if (mapped === null) {
+      return false;
+    }
+    if (level === "xhigh" || level === "max") {
+      return mapped !== undefined;
+    }
+    return true;
+  });
+  return levels;
 }

package/src/shared/native-import.ts

@@ -0,0 +1,25 @@
+import { registerHooks } from "node:module";
+
+/** Resolve only this native Node importer's literal SDK import to the selected host. */
+// ponytail: Jiti rewrites callback imports and loses their originating parent URL.
+// Jiti adapters must use the approved declaration-typed selected URL import boundary.
+export async function importSelectedNative<T>(
+  parentURL: string,
+  specifier: string,
+  targetURL: string,
+  load: () => Promise<T>,
+): Promise<T> {
+  const hooks = registerHooks({
+    resolve(request, context, nextResolve) {
+      if (request === specifier && context.parentURL === parentURL) {
+        return nextResolve(targetURL, context);
+      }
+      return nextResolve(request, context);
+    },
+  });
+  try {
+    return await load();
+  } finally {
+    hooks.deregister();
+  }
+}