@asterxsk/kiln 0.1.0 → 0.2.0

package/agent/extensions/shared/dashboard-state.ts

@@ -1,99 +1,99 @@
-export const MODEL_INFO_CHANNEL = "dashboard:model-info";
-export const GIT_INFO_CHANNEL = "dashboard:git-info";
-export const REFRESH_CHANNEL = "dashboard:refresh";
-
-export interface ModelInfoState {
-  provider: string;
-  modelId: string;
-  modelName: string;
-  thinking: string;
-  contextTokens: number | null;
-  contextWindow: number;
-  contextPercent: number | null;
-  cost: number;
-  tokensPerSecond: number | null;
-  generating: boolean;
-}
-
-export interface PullRequestInfo {
-  number: number;
-  url: string;
-  isDraft: boolean;
-}
-
-export interface GitInfoState {
-  isRepository: boolean;
-  branch: string | null;
-  changedFiles: number;
-  pullRequest: PullRequestInfo | null;
-}
-
-export function emptyModelInfoState(): ModelInfoState {
-  return {
-    provider: "",
-    modelId: "no-model",
-    modelName: "No model",
-    thinking: "off",
-    contextTokens: null,
-    contextWindow: 0,
-    contextPercent: null,
-    cost: 0,
-    tokensPerSecond: null,
-    generating: false,
-  };
-}
-
-export function emptyGitInfoState(): GitInfoState {
-  return {
-    isRepository: false,
-    branch: null,
-    changedFiles: 0,
-    pullRequest: null,
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function isNullableNumber(value: unknown) {
-  return value === null || typeof value === "number";
-}
-
-export function isModelInfoState(value: unknown): value is ModelInfoState {
-  if (!isRecord(value)) return false;
-
-  return (
-    typeof value.provider === "string" &&
-    typeof value.modelId === "string" &&
-    typeof value.modelName === "string" &&
-    typeof value.thinking === "string" &&
-    isNullableNumber(value.contextTokens) &&
-    typeof value.contextWindow === "number" &&
-    isNullableNumber(value.contextPercent) &&
-    typeof value.cost === "number" &&
-    isNullableNumber(value.tokensPerSecond) &&
-    typeof value.generating === "boolean"
-  );
-}
-
-function isPullRequestInfo(value: unknown): value is PullRequestInfo {
-  if (!isRecord(value)) return false;
-
-  return (
-    typeof value.number === "number" &&
-    typeof value.url === "string" &&
-    typeof value.isDraft === "boolean"
-  );
-}
-
-export function isGitInfoState(value: unknown): value is GitInfoState {
-  if (!isRecord(value)) return false;
-
-  return (
-    typeof value.isRepository === "boolean" &&
-    (value.branch === null || typeof value.branch === "string") &&
-    typeof value.changedFiles === "number" &&
-    (value.pullRequest === null || isPullRequestInfo(value.pullRequest))
-  );
-}
+export const MODEL_INFO_CHANNEL = "dashboard:model-info";
+export const GIT_INFO_CHANNEL = "dashboard:git-info";
+export const REFRESH_CHANNEL = "dashboard:refresh";
+
+export interface ModelInfoState {
+  provider: string;
+  modelId: string;
+  modelName: string;
+  thinking: string;
+  contextTokens: number | null;
+  contextWindow: number;
+  contextPercent: number | null;
+  cost: number;
+  tokensPerSecond: number | null;
+  generating: boolean;
+}
+
+export interface PullRequestInfo {
+  number: number;
+  url: string;
+  isDraft: boolean;
+}
+
+export interface GitInfoState {
+  isRepository: boolean;
+  branch: string | null;
+  changedFiles: number;
+  pullRequest: PullRequestInfo | null;
+}
+
+export function emptyModelInfoState(): ModelInfoState {
+  return {
+    provider: "",
+    modelId: "no-model",
+    modelName: "No model",
+    thinking: "off",
+    contextTokens: null,
+    contextWindow: 0,
+    contextPercent: null,
+    cost: 0,
+    tokensPerSecond: null,
+    generating: false,
+  };
+}
+
+export function emptyGitInfoState(): GitInfoState {
+  return {
+    isRepository: false,
+    branch: null,
+    changedFiles: 0,
+    pullRequest: null,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isNullableNumber(value: unknown) {
+  return value === null || typeof value === "number";
+}
+
+export function isModelInfoState(value: unknown): value is ModelInfoState {
+  if (!isRecord(value)) return false;
+
+  return (
+    typeof value.provider === "string" &&
+    typeof value.modelId === "string" &&
+    typeof value.modelName === "string" &&
+    typeof value.thinking === "string" &&
+    isNullableNumber(value.contextTokens) &&
+    typeof value.contextWindow === "number" &&
+    isNullableNumber(value.contextPercent) &&
+    typeof value.cost === "number" &&
+    isNullableNumber(value.tokensPerSecond) &&
+    typeof value.generating === "boolean"
+  );
+}
+
+function isPullRequestInfo(value: unknown): value is PullRequestInfo {
+  if (!isRecord(value)) return false;
+
+  return (
+    typeof value.number === "number" &&
+    typeof value.url === "string" &&
+    typeof value.isDraft === "boolean"
+  );
+}
+
+export function isGitInfoState(value: unknown): value is GitInfoState {
+  if (!isRecord(value)) return false;
+
+  return (
+    typeof value.isRepository === "boolean" &&
+    (value.branch === null || typeof value.branch === "string") &&
+    typeof value.changedFiles === "number" &&
+    (value.pullRequest === null || isPullRequestInfo(value.pullRequest))
+  );
+}

package/agent/extensions/shared/tool-call-timeout.test.ts

@@ -1,117 +1,117 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import {
-  createToolCallTimeoutGuard,
-  runWithToolCallTimeout,
-  CHILD_TOOL_CALL_TIMEOUT_MS,
-  ToolCallTimeoutError,
-} from "./tool-call-timeout.ts";
-
-test("the production timeout error names the tool and three-minute limit", () => {
-  assert.equal(
-    new ToolCallTimeoutError("fixture_tool", CHILD_TOOL_CALL_TIMEOUT_MS)
-      .message,
-    'Tool call "fixture_tool" timed out after 3 minutes.',
-  );
-});
-
-test("a hung tool call fails clearly and receives an abort signal", async () => {
-  let executionSignal: AbortSignal | undefined;
-
-  await assert.rejects(
-    runWithToolCallTimeout("hung_fixture", 10, undefined, (signal) => {
-      executionSignal = signal;
-      return new Promise(() => {});
-    }),
-    (error: unknown) => {
-      assert.equal(error instanceof ToolCallTimeoutError, true);
-      assert.equal(
-        error instanceof Error ? error.message : "",
-        'Tool call "hung_fixture" timed out after 10 ms.',
-      );
-      return true;
-    },
-  );
-
-  assert.equal(executionSignal?.aborted, true);
-  assert.equal(executionSignal?.reason instanceof ToolCallTimeoutError, true);
-});
-
-test("parent cancellation still stops the timeout wrapper immediately", async () => {
-  const controller = new AbortController();
-  const reason = new Error("cancelled fixture");
-  const pending = runWithToolCallTimeout(
-    "hung_fixture",
-    60_000,
-    controller.signal,
-    () => new Promise(() => {}),
-  );
-
-  controller.abort(reason);
-
-  await assert.rejects(pending, (error: unknown) => error === reason);
-});
-
-test("the guard wraps each definition once and can discover later tools", () => {
-  const definitions = new Map<string, ToolDefinition>();
-  const createDefinition = (name: string): ToolDefinition => ({
-    name,
-    label: name,
-    description: name,
-    parameters: Type.Object({}),
-    async execute() {
-      return { content: [{ type: "text", text: "done" }], details: {} };
-    },
-  });
-  const first = createDefinition("first");
-  definitions.set(first.name, first);
-  const registry = {
-    getAllTools: () => [...definitions.keys()].map((name) => ({ name })),
-    getToolDefinition: (name: string) => definitions.get(name),
-  };
-  const guard = createToolCallTimeoutGuard(10);
-
-  const firstExecute = first.execute;
-  guard.apply(registry);
-  const firstWrappedExecute = first.execute;
-  assert.notEqual(firstWrappedExecute, firstExecute);
-
-  const second = createDefinition("second");
-  const secondExecute = second.execute;
-  definitions.set(second.name, second);
-  guard.apply(registry);
-
-  assert.equal(first.execute, firstWrappedExecute);
-  assert.notEqual(second.execute, secondExecute);
-});
-
-test("successful and terminating tool results pass through unchanged", async () => {
-  const result = {
-    content: [{ type: "text" as const, text: "recorded" }],
-    details: { value: "fixture" },
-    terminate: true,
-  };
-
-  assert.equal(
-    await runWithToolCallTimeout(
-      "structured_output",
-      10,
-      undefined,
-      async () => result,
-    ),
-    result,
-  );
-});
-
-test("the timeout is fresh for each tool call, not shared across calls", async () => {
-  const execute = () =>
-    runWithToolCallTimeout("slow_fixture", 100, undefined, async () => {
-      await new Promise((resolve) => setTimeout(resolve, 60));
-      return "done";
-    });
-
-  assert.equal(await execute(), "done");
-  assert.equal(await execute(), "done");
-});
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import {
+  createToolCallTimeoutGuard,
+  runWithToolCallTimeout,
+  CHILD_TOOL_CALL_TIMEOUT_MS,
+  ToolCallTimeoutError,
+} from "./tool-call-timeout.ts";
+
+test("the production timeout error names the tool and three-minute limit", () => {
+  assert.equal(
+    new ToolCallTimeoutError("fixture_tool", CHILD_TOOL_CALL_TIMEOUT_MS)
+      .message,
+    'Tool call "fixture_tool" timed out after 3 minutes.',
+  );
+});
+
+test("a hung tool call fails clearly and receives an abort signal", async () => {
+  let executionSignal: AbortSignal | undefined;
+
+  await assert.rejects(
+    runWithToolCallTimeout("hung_fixture", 10, undefined, (signal) => {
+      executionSignal = signal;
+      return new Promise(() => {});
+    }),
+    (error: unknown) => {
+      assert.equal(error instanceof ToolCallTimeoutError, true);
+      assert.equal(
+        error instanceof Error ? error.message : "",
+        'Tool call "hung_fixture" timed out after 10 ms.',
+      );
+      return true;
+    },
+  );
+
+  assert.equal(executionSignal?.aborted, true);
+  assert.equal(executionSignal?.reason instanceof ToolCallTimeoutError, true);
+});
+
+test("parent cancellation still stops the timeout wrapper immediately", async () => {
+  const controller = new AbortController();
+  const reason = new Error("cancelled fixture");
+  const pending = runWithToolCallTimeout(
+    "hung_fixture",
+    60_000,
+    controller.signal,
+    () => new Promise(() => {}),
+  );
+
+  controller.abort(reason);
+
+  await assert.rejects(pending, (error: unknown) => error === reason);
+});
+
+test("the guard wraps each definition once and can discover later tools", () => {
+  const definitions = new Map<string, ToolDefinition>();
+  const createDefinition = (name: string): ToolDefinition => ({
+    name,
+    label: name,
+    description: name,
+    parameters: Type.Object({}),
+    async execute() {
+      return { content: [{ type: "text", text: "done" }], details: {} };
+    },
+  });
+  const first = createDefinition("first");
+  definitions.set(first.name, first);
+  const registry = {
+    getAllTools: () => [...definitions.keys()].map((name) => ({ name })),
+    getToolDefinition: (name: string) => definitions.get(name),
+  };
+  const guard = createToolCallTimeoutGuard(10);
+
+  const firstExecute = first.execute;
+  guard.apply(registry);
+  const firstWrappedExecute = first.execute;
+  assert.notEqual(firstWrappedExecute, firstExecute);
+
+  const second = createDefinition("second");
+  const secondExecute = second.execute;
+  definitions.set(second.name, second);
+  guard.apply(registry);
+
+  assert.equal(first.execute, firstWrappedExecute);
+  assert.notEqual(second.execute, secondExecute);
+});
+
+test("successful and terminating tool results pass through unchanged", async () => {
+  const result = {
+    content: [{ type: "text" as const, text: "recorded" }],
+    details: { value: "fixture" },
+    terminate: true,
+  };
+
+  assert.equal(
+    await runWithToolCallTimeout(
+      "structured_output",
+      10,
+      undefined,
+      async () => result,
+    ),
+    result,
+  );
+});
+
+test("the timeout is fresh for each tool call, not shared across calls", async () => {
+  const execute = () =>
+    runWithToolCallTimeout("slow_fixture", 100, undefined, async () => {
+      await new Promise((resolve) => setTimeout(resolve, 60));
+      return "done";
+    });
+
+  assert.equal(await execute(), "done");
+  assert.equal(await execute(), "done");
+});

package/agent/extensions/shared/tool-call-timeout.ts

@@ -1,104 +1,104 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-
-export const CHILD_TOOL_CALL_TIMEOUT_MS = 3 * 60 * 1_000;
-
-interface ToolRegistry {
-  getAllTools(): Array<{ name: string }>;
-  getToolDefinition(name: string): ToolDefinition | undefined;
-}
-
-function formatTimeout(timeoutMs: number) {
-  if (timeoutMs % 60_000 === 0) {
-    const minutes = timeoutMs / 60_000;
-    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
-  }
-  if (timeoutMs % 1_000 === 0) {
-    const seconds = timeoutMs / 1_000;
-    return `${seconds} second${seconds === 1 ? "" : "s"}`;
-  }
-  return `${timeoutMs} ms`;
-}
-
-export class ToolCallTimeoutError extends Error {
-  constructor(toolName: string, timeoutMs: number) {
-    super(
-      `Tool call "${toolName}" timed out after ${formatTimeout(timeoutMs)}.`,
-    );
-    this.name = "ToolCallTimeoutError";
-  }
-}
-
-export async function runWithToolCallTimeout<T>(
-  toolName: string,
-  timeoutMs: number,
-  signal: AbortSignal | undefined,
-  execute: (signal: AbortSignal) => Promise<T>,
-) {
-  const timeoutController = new AbortController();
-  const executionSignal = signal
-    ? AbortSignal.any([signal, timeoutController.signal])
-    : timeoutController.signal;
-  const timeoutError = new ToolCallTimeoutError(toolName, timeoutMs);
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_resolve, reject) => {
-    timer = setTimeout(() => {
-      reject(timeoutError);
-      timeoutController.abort(timeoutError);
-    }, timeoutMs);
-  });
-
-  let removeAbortListener: (() => void) | undefined;
-  const aborted = new Promise<never>((_resolve, reject) => {
-    if (!signal) return;
-    const onAbort = () => {
-      reject(
-        signal.reason instanceof Error
-          ? signal.reason
-          : new Error(`Tool call "${toolName}" was aborted.`),
-      );
-    };
-    if (signal.aborted) {
-      onAbort();
-      return;
-    }
-    signal.addEventListener("abort", onAbort, { once: true });
-    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-  });
-
-  try {
-    return await Promise.race([execute(executionSignal), timeout, aborted]);
-  } finally {
-    if (timer) clearTimeout(timer);
-    removeAbortListener?.();
-  }
-}
-
-/**
- * Wrap every currently registered child tool with an independent execution
- * timeout. Calling apply() again is safe and picks up tools registered later.
- */
-export function createToolCallTimeoutGuard(
-  timeoutMs = CHILD_TOOL_CALL_TIMEOUT_MS,
-) {
-  const wrapped = new WeakSet<ToolDefinition>();
-
-  const wrap = (definition: ToolDefinition) => {
-    if (wrapped.has(definition)) return;
-    wrapped.add(definition);
-
-    const execute = definition.execute;
-    definition.execute = async (toolCallId, params, signal, onUpdate, ctx) =>
-      runWithToolCallTimeout(definition.name, timeoutMs, signal, (signal) =>
-        execute.call(definition, toolCallId, params, signal, onUpdate, ctx),
-      );
-  };
-
-  return {
-    apply(session: ToolRegistry) {
-      for (const { name } of session.getAllTools()) {
-        const definition = session.getToolDefinition(name);
-        if (definition) wrap(definition);
-      }
-    },
-  };
-}
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+
+export const CHILD_TOOL_CALL_TIMEOUT_MS = 3 * 60 * 1_000;
+
+interface ToolRegistry {
+  getAllTools(): Array<{ name: string }>;
+  getToolDefinition(name: string): ToolDefinition | undefined;
+}
+
+function formatTimeout(timeoutMs: number) {
+  if (timeoutMs % 60_000 === 0) {
+    const minutes = timeoutMs / 60_000;
+    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+  }
+  if (timeoutMs % 1_000 === 0) {
+    const seconds = timeoutMs / 1_000;
+    return `${seconds} second${seconds === 1 ? "" : "s"}`;
+  }
+  return `${timeoutMs} ms`;
+}
+
+export class ToolCallTimeoutError extends Error {
+  constructor(toolName: string, timeoutMs: number) {
+    super(
+      `Tool call "${toolName}" timed out after ${formatTimeout(timeoutMs)}.`,
+    );
+    this.name = "ToolCallTimeoutError";
+  }
+}
+
+export async function runWithToolCallTimeout<T>(
+  toolName: string,
+  timeoutMs: number,
+  signal: AbortSignal | undefined,
+  execute: (signal: AbortSignal) => Promise<T>,
+) {
+  const timeoutController = new AbortController();
+  const executionSignal = signal
+    ? AbortSignal.any([signal, timeoutController.signal])
+    : timeoutController.signal;
+  const timeoutError = new ToolCallTimeoutError(toolName, timeoutMs);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(timeoutError);
+      timeoutController.abort(timeoutError);
+    }, timeoutMs);
+  });
+
+  let removeAbortListener: (() => void) | undefined;
+  const aborted = new Promise<never>((_resolve, reject) => {
+    if (!signal) return;
+    const onAbort = () => {
+      reject(
+        signal.reason instanceof Error
+          ? signal.reason
+          : new Error(`Tool call "${toolName}" was aborted.`),
+      );
+    };
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+  });
+
+  try {
+    return await Promise.race([execute(executionSignal), timeout, aborted]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    removeAbortListener?.();
+  }
+}
+
+/**
+ * Wrap every currently registered child tool with an independent execution
+ * timeout. Calling apply() again is safe and picks up tools registered later.
+ */
+export function createToolCallTimeoutGuard(
+  timeoutMs = CHILD_TOOL_CALL_TIMEOUT_MS,
+) {
+  const wrapped = new WeakSet<ToolDefinition>();
+
+  const wrap = (definition: ToolDefinition) => {
+    if (wrapped.has(definition)) return;
+    wrapped.add(definition);
+
+    const execute = definition.execute;
+    definition.execute = async (toolCallId, params, signal, onUpdate, ctx) =>
+      runWithToolCallTimeout(definition.name, timeoutMs, signal, (signal) =>
+        execute.call(definition, toolCallId, params, signal, onUpdate, ctx),
+      );
+  };
+
+  return {
+    apply(session: ToolRegistry) {
+      for (const { name } of session.getAllTools()) {
+        const definition = session.getToolDefinition(name);
+        if (definition) wrap(definition);
+      }
+    },
+  };
+}