@twinklerg/coden 0.1.0

package/src/cli/index.ts

@@ -0,0 +1,149 @@
+#!/usr/bin/env bun
+import { realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { userConfigDir, userDataDir } from "../config/config.js";
+import { TrustStore } from "../config/trust.js";
+import { BunPackageManager } from "../plugins/bun-package-manager.js";
+import { InstalledPluginLoader } from "../plugins/installed-loader.js";
+import {
+  type InstalledPluginSummary,
+  type ListedPlugin,
+  PluginInstaller,
+  type PluginOperationOptions,
+} from "../plugins/installer.js";
+import { builtinTools } from "../tools/builtin/index.js";
+import {
+  type AgentCommandOptions,
+  ConfigError,
+  collect,
+  parseProvider,
+  positiveInteger,
+  runAgentCommand,
+} from "./agent-command.js";
+import { type PluginCommandService, registerPluginCommand } from "./plugin-command.js";
+
+export interface CliDependencies {
+  pluginService?: PluginCommandService;
+  confirm?: (message: string) => Promise<boolean>;
+}
+
+export function createCliProgram(dependencies: CliDependencies = {}): Command {
+  const confirm = dependencies.confirm ?? createDefaultConfirm;
+  const pluginService = dependencies.pluginService ?? createDefaultPluginService(confirm);
+  const program = new Command()
+    .name("coden")
+    .description("CodeN — a minimal coding agent")
+    .version("0.1.0")
+    .argument("[prompt]", "task to execute")
+    .option("-p, --print", "non-interactive print mode", false)
+    .option("--provider <provider>", "openai or anthropic", parseProvider)
+    .option("--model <model-id>", "model identifier")
+    .option(
+      "--resume [session-id]",
+      "resume a previous session, or list sessions when no id is given",
+    )
+    .option("--auto", "skip permission and project-plugin confirmations", false)
+    .option("--verbose", "show detailed runtime status", false)
+    .option("--max-steps <number>", "maximum model steps", positiveInteger)
+    .option("--plugin <path>", "additional local TypeScript plugin or directory", collect, [])
+    .action((prompt: string | undefined, options: AgentCommandOptions) =>
+      runAgentCommand(prompt, options),
+    );
+
+  registerPluginCommand(program, {
+    service: pluginService,
+    confirm,
+    stdout: process.stdout,
+    stderr: process.stderr,
+  });
+
+  return program;
+}
+
+function createDefaultPluginService(
+  confirm: (message: string) => Promise<boolean>,
+): PluginCommandService {
+  const workspace = process.cwd();
+  const installer = new PluginInstaller(
+    workspace,
+    userDataDir(),
+    new BunPackageManager(),
+    new InstalledPluginLoader(),
+    builtinTools(),
+  );
+  const trustStore = new TrustStore(path.join(userConfigDir(), "trusted-workspaces.json"));
+  return new TrustingPluginService(installer, workspace, trustStore, confirm);
+}
+
+class TrustingPluginService implements PluginCommandService {
+  constructor(
+    private readonly service: PluginCommandService,
+    private readonly workspace: string,
+    private readonly trustStore: TrustStore,
+    private readonly confirm: (message: string) => Promise<boolean>,
+  ) {}
+
+  async install(raw: string, options: PluginOperationOptions): Promise<InstalledPluginSummary> {
+    if (options.scope === "project") await this.ensureProjectTrust();
+    return this.service.install(raw, options);
+  }
+
+  async remove(packageName: string, options: PluginOperationOptions): Promise<void> {
+    return this.service.remove(packageName, options);
+  }
+
+  async sync(options: PluginOperationOptions): Promise<InstalledPluginSummary[]> {
+    if (options.scope === "project") await this.ensureProjectTrust();
+    return this.service.sync(options);
+  }
+
+  async list(): Promise<{ project: ListedPlugin[]; global: ListedPlugin[] }> {
+    return this.service.list();
+  }
+
+  private async ensureProjectTrust(): Promise<void> {
+    const realWorkspace = await realpath(this.workspace);
+    if (await this.trustStore.isWorkspaceTrusted(realWorkspace)) return;
+    const allowed = await this.confirm(
+      `Project npm plugins in ${realWorkspace} run in-process with full user permissions. Trust this workspace?`,
+    );
+    if (!allowed) throw new Error("workspace is not trusted for project npm plugins");
+    await this.trustStore.trustWorkspace(realWorkspace);
+  }
+}
+
+async function createDefaultConfirm(message: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return /^y(?:es)?$/i.test(answer);
+  } finally {
+    rl.close();
+  }
+}
+
+function isExecutableEntry(): boolean {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  // Compare canonical realpaths so symlinked prefixes (e.g. macOS /tmp -> /private/tmp)
+  // don't cause the CLI to silently no-op when it is directly executed.
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(entry);
+  } catch {
+    return false;
+  }
+}
+
+if (isExecutableEntry()) {
+  createCliProgram()
+    .parseAsync()
+    .catch((error) => {
+      process.stderr.write(`coden: ${error instanceof Error ? error.message : String(error)}\n`);
+      // 2 = configuration/setup failure, 1 = execution failure (see design §11.4).
+      process.exitCode = error instanceof ConfigError ? 2 : 1;
+    });
+}

package/src/cli/plugin-command.ts

@@ -0,0 +1,217 @@
+import type { Command } from "commander";
+import type {
+  InstalledPluginSummary,
+  ListedPlugin,
+  PluginOperationOptions,
+} from "../plugins/installer.js";
+
+export interface PluginCommandService {
+  install(raw: string, options: PluginOperationOptions): Promise<InstalledPluginSummary>;
+  remove(packageName: string, options: PluginOperationOptions): Promise<void>;
+  sync(options: PluginOperationOptions): Promise<InstalledPluginSummary[]>;
+  list(): Promise<{ project: ListedPlugin[]; global: ListedPlugin[] }>;
+}
+
+export interface PluginCommandDependencies {
+  service: PluginCommandService;
+  confirm(message: string): Promise<boolean>;
+  stdout: Pick<NodeJS.WriteStream, "write">;
+  stderr: Pick<NodeJS.WriteStream, "write">;
+}
+
+interface ScopeOptions {
+  global?: boolean;
+}
+
+interface MutatingOptions extends ScopeOptions {
+  allowScripts?: boolean;
+  yes?: boolean;
+}
+
+interface ListOptions {
+  project?: boolean;
+  global?: boolean;
+}
+
+export function registerPluginCommand(
+  program: Command,
+  dependencies: PluginCommandDependencies,
+): void {
+  const plugin = program.command("plugin").description("manage installed npm plugins");
+
+  plugin
+    .command("install")
+    .argument("<specifier>", "npm:<package> or npm:<package>@<version-or-tag>")
+    .option("--global", "install in the user-global scope")
+    .option(
+      "--allow-scripts",
+      "allow npm lifecycle scripts with full user permissions during dependency install",
+    )
+    .option("--yes", "skip confirmation prompts")
+    .action((specifier: string, options: MutatingOptions) =>
+      runPluginAction(dependencies, async () => {
+        const operation = operationOptions(options);
+        if (!(await confirmMutation(dependencies, "Install", specifier, options))) return;
+        const result = await dependencies.service.install(specifier, operation);
+        dependencies.stdout.write(renderInstallSummary(result, operation.allowScripts));
+      }),
+    );
+
+  plugin
+    .command("remove")
+    .argument("<package>", "installed npm package name")
+    .option("--global", "remove from the user-global scope")
+    .option(
+      "--allow-scripts",
+      "allow npm lifecycle scripts with full user permissions while rebuilding dependencies",
+    )
+    .option("--yes", "skip confirmation prompts")
+    .action((packageName: string, options: MutatingOptions) =>
+      runPluginAction(dependencies, async () => {
+        const operation = operationOptions(options);
+        if (!(await confirmMutation(dependencies, "Remove", packageName, options))) return;
+        await dependencies.service.remove(packageName, operation);
+        dependencies.stdout.write(
+          `Removed ${packageName} from ${operation.scope} plugins.\nRestart CodeN to use npm plugin changes.\n`,
+        );
+      }),
+    );
+
+  plugin
+    .command("list")
+    .option("--project", "show only project plugins")
+    .option("--global", "show only user-global plugins")
+    .action((options: ListOptions) =>
+      runPluginAction(dependencies, async () => {
+        if (options.project && options.global) {
+          throw new Error("plugin list accepts only one of --project or --global");
+        }
+        const result = await dependencies.service.list();
+        dependencies.stdout.write(renderList(result, options));
+      }),
+    );
+
+  plugin
+    .command("sync")
+    .option("--global", "sync the user-global plugin runtime")
+    .option(
+      "--allow-scripts",
+      "allow npm lifecycle scripts with full user permissions during dependency install",
+    )
+    .option("--yes", "skip confirmation prompts")
+    .action((options: MutatingOptions) =>
+      runPluginAction(dependencies, async () => {
+        const operation = operationOptions(options);
+        if (!(await confirmMutation(dependencies, "Sync", `${operation.scope} plugins`, options)))
+          return;
+        const synced = await dependencies.service.sync(operation);
+        dependencies.stdout.write(
+          renderSyncSummary(operation.scope, synced, operation.allowScripts),
+        );
+      }),
+    );
+}
+
+function operationOptions(options: MutatingOptions): PluginOperationOptions {
+  return {
+    scope: options.global ? "global" : "project",
+    allowScripts: options.allowScripts === true,
+  };
+}
+
+async function confirmMutation(
+  dependencies: PluginCommandDependencies,
+  verb: string,
+  target: string,
+  options: MutatingOptions,
+): Promise<boolean> {
+  if (!options.yes) {
+    const allowed = await dependencies.confirm(
+      `${verb} ${target}? npm plugins run with full process permissions; validation imports plugin top-level code with full permissions. Continue?`,
+    );
+    if (!allowed) return false;
+  }
+  if (options.allowScripts) {
+    dependencies.stderr.write(
+      "Warning: --allow-scripts lets this package and transitive dependencies run lifecycle scripts with your user permissions.\n",
+    );
+    if (!options.yes) {
+      const allowed = await dependencies.confirm(
+        "Allow npm lifecycle scripts to run with full user permissions?",
+      );
+      if (!allowed) return false;
+    }
+  }
+  return true;
+}
+
+async function runPluginAction(
+  dependencies: PluginCommandDependencies,
+  action: () => Promise<void>,
+): Promise<void> {
+  try {
+    await action();
+  } catch (error) {
+    dependencies.stderr.write(`coden: ${sanitizeError(error)}\n`);
+    process.exitCode = 2;
+  }
+}
+
+function renderInstallSummary(result: InstalledPluginSummary, allowScripts: boolean): string {
+  return [
+    `Installed ${result.packageName}@${result.version} (${result.scope})`,
+    `Requested: ${result.requested}`,
+    `Tools: ${result.tools.length > 0 ? result.tools.slice().sort().join(", ") : "none"}`,
+    `Lifecycle scripts: ${allowScripts ? "enabled" : "disabled"}`,
+    "Restart CodeN to use npm plugin changes.",
+    "",
+  ].join("\n");
+}
+
+function renderSyncSummary(
+  scope: "project" | "global",
+  synced: InstalledPluginSummary[],
+  allowScripts: boolean,
+): string {
+  const packages = synced
+    .slice()
+    .sort((left, right) => left.packageName.localeCompare(right.packageName))
+    .map((item) => `${item.packageName}@${item.version}`);
+  return [
+    `Synced ${scope} plugins: ${packages.join(", ") || "none"}`,
+    `Lifecycle scripts: ${allowScripts ? "enabled" : "disabled"}`,
+    "Restart CodeN to use npm plugin changes.",
+    "",
+  ].join("\n");
+}
+
+function renderList(
+  result: { project: ListedPlugin[]; global: ListedPlugin[] },
+  options: ListOptions,
+): string {
+  const sections: string[] = [];
+  if (!options.global) sections.push(renderListSection("Project plugins", result.project));
+  if (!options.project) sections.push(renderListSection("Global plugins", result.global));
+  return `${sections.join("\n")}\n`;
+}
+
+function renderListSection(title: string, plugins: ListedPlugin[]): string {
+  const sorted = plugins
+    .slice()
+    .sort((left, right) => left.packageName.localeCompare(right.packageName));
+  if (sorted.length === 0) return `${title}: none\n`;
+  const lines = sorted.map((plugin) => {
+    const shadowed = plugin.shadowedByProject ? " (shadowed by project)" : "";
+    return `  ${plugin.packageName}@${plugin.version} requested ${plugin.requested}; ${plugin.tools.length} tool(s)${shadowed}`;
+  });
+  return `${title}:\n${lines.join("\n")}\n`;
+}
+
+function sanitizeError(error: unknown): string {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const value of Object.values(process.env)) {
+    if (!value || value.length < 8) continue;
+    message = message.split(value).join("[redacted]");
+  }
+  return message;
+}

package/src/config/config.ts

@@ -0,0 +1,96 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export type ProviderName = "openai" | "anthropic";
+export interface CodeNConfig {
+  provider: ProviderName;
+  model: string;
+  maxSteps: number;
+  contextWindow: number;
+  reservedOutputTokens: number;
+  safetyMargin: number;
+  plugins: string[];
+  dataDir: string;
+}
+export type ConfigOverrides = Partial<Omit<CodeNConfig, "plugins" | "dataDir">> & {
+  plugins?: string[];
+};
+
+export function userConfigDir(): string {
+  return process.env.XDG_CONFIG_HOME
+    ? path.join(process.env.XDG_CONFIG_HOME, "coden")
+    : path.join(os.homedir(), ".config", "coden");
+}
+export function userDataDir(): string {
+  return process.env.XDG_DATA_HOME
+    ? path.join(process.env.XDG_DATA_HOME, "coden")
+    : path.join(os.homedir(), ".local", "share", "coden");
+}
+async function readJson(file: string): Promise<ConfigOverrides> {
+  try {
+    const raw = JSON.parse(await readFile(file, "utf8")) as Record<string, unknown>;
+    return pickOverrides(raw);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw new Error(
+      `Cannot read config ${file}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+function pickOverrides(raw: Record<string, unknown>): ConfigOverrides {
+  const overrides: ConfigOverrides = {};
+  if (raw.provider === "openai" || raw.provider === "anthropic") overrides.provider = raw.provider;
+  if (typeof raw.model === "string") overrides.model = raw.model;
+  if (typeof raw.maxSteps === "number") overrides.maxSteps = raw.maxSteps;
+  if (typeof raw.contextWindow === "number") overrides.contextWindow = raw.contextWindow;
+  if (typeof raw.reservedOutputTokens === "number")
+    overrides.reservedOutputTokens = raw.reservedOutputTokens;
+  if (typeof raw.safetyMargin === "number") overrides.safetyMargin = raw.safetyMargin;
+  if (Array.isArray(raw.plugins))
+    overrides.plugins = raw.plugins.filter((item): item is string => typeof item === "string");
+  return overrides;
+}
+
+export async function loadConfig(
+  workspace: string,
+  cli: ConfigOverrides = {},
+): Promise<CodeNConfig> {
+  const defaults: CodeNConfig = {
+    provider: "openai",
+    model: "gpt-5-mini",
+    maxSteps: 20,
+    contextWindow: 128000,
+    reservedOutputTokens: 8192,
+    safetyMargin: 4096,
+    plugins: [],
+    dataDir: userDataDir(),
+  };
+  const user = await readJson(path.join(userConfigDir(), "config.json"));
+  const project = await readJson(path.join(workspace, ".coden", "config.json"));
+  const env: ConfigOverrides = {};
+  if (process.env.CODEN_PROVIDER === "openai" || process.env.CODEN_PROVIDER === "anthropic")
+    env.provider = process.env.CODEN_PROVIDER;
+  if (process.env.CODEN_MODEL) env.model = process.env.CODEN_MODEL;
+  if (process.env.CODEN_MAX_STEPS) env.maxSteps = Number(process.env.CODEN_MAX_STEPS);
+  const merged = { ...defaults, ...user, ...project, ...env, ...cli };
+  merged.plugins = [...(user.plugins ?? []), ...(project.plugins ?? []), ...(cli.plugins ?? [])];
+  if (merged.provider !== "openai" && merged.provider !== "anthropic")
+    throw new Error("provider must be openai or anthropic");
+  if (typeof merged.model !== "string" || !merged.model.trim())
+    throw new Error("model must be a non-empty string");
+  if (!Number.isInteger(merged.maxSteps) || merged.maxSteps < 1)
+    throw new Error("maxSteps must be a positive integer");
+  for (const key of ["contextWindow", "reservedOutputTokens", "safetyMargin"] as const) {
+    if (!Number.isInteger(merged[key]) || merged[key] < 0)
+      throw new Error(`${key} must be a non-negative integer`);
+  }
+  if (merged.contextWindow === 0 || merged.reservedOutputTokens === 0)
+    throw new Error("contextWindow and reservedOutputTokens must be positive");
+  if (merged.contextWindow <= merged.reservedOutputTokens + merged.safetyMargin)
+    throw new Error("contextWindow must exceed reservedOutputTokens plus safetyMargin");
+  if (!Array.isArray(merged.plugins) || merged.plugins.some((item) => typeof item !== "string"))
+    throw new Error("plugins must be an array of paths");
+  return merged;
+}

package/src/config/trust.ts

@@ -0,0 +1,35 @@
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export class TrustStore {
+  constructor(private readonly file: string) {}
+  async isTrusted(realPath: string): Promise<boolean> {
+    return (await this.read()).includes(realPath);
+  }
+  async isWorkspaceTrusted(workspace: string): Promise<boolean> {
+    return this.isTrusted(await realpath(workspace));
+  }
+  async trustWorkspace(workspace: string): Promise<void> {
+    return this.trust(await realpath(workspace));
+  }
+  async trust(realPath: string): Promise<void> {
+    const values = await this.read();
+    if (!values.includes(realPath)) values.push(realPath);
+    await mkdir(path.dirname(this.file), { recursive: true });
+    await writeFile(this.file, `${JSON.stringify(values, null, 2)}\n`, {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+  }
+  private async read(): Promise<string[]> {
+    try {
+      const value = JSON.parse(await readFile(this.file, "utf8"));
+      return Array.isArray(value)
+        ? value.filter((item): item is string => typeof item === "string")
+        : [];
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+      throw error;
+    }
+  }
+}

package/src/context/manager.ts

@@ -0,0 +1,186 @@
+import type { AgentMessage, ModelRequest, ToolDefinition } from "../core/types.js";
+
+export interface ContextBudget {
+  contextWindow: number;
+  reservedOutputTokens: number;
+  safetyMargin: number;
+}
+export interface PreparedContext {
+  messages: AgentMessage[];
+  estimatedTokens: number;
+  compacted: boolean;
+}
+export interface CompactionRange {
+  start: number;
+  end: number;
+}
+
+interface MessageUnit {
+  messages: AgentMessage[];
+  start: number;
+  end: number;
+}
+
+export class TokenEstimator {
+  estimateText(text: string): number {
+    return Math.ceil(text.length / 3.5);
+  }
+  estimateMessages(messages: AgentMessage[]): number {
+    return messages.reduce(
+      (sum, message) => sum + 6 + this.estimateText(JSON.stringify(message)),
+      0,
+    );
+  }
+  estimateTools(tools: ToolDefinition[]): number {
+    return this.estimateText(JSON.stringify(tools.map(({ execute: _, ...tool }) => tool)));
+  }
+}
+
+export class ContextManager {
+  readonly estimator = new TokenEstimator();
+  private summary: AgentMessage | undefined;
+  private compactionRange: CompactionRange | undefined;
+  private compactedThrough = 0;
+  constructor(
+    readonly budget: ContextBudget,
+    private readonly threshold = 0.8,
+  ) {}
+  inputBudget(): number {
+    return this.budget.contextWindow - this.budget.reservedOutputTokens - this.budget.safetyMargin;
+  }
+
+  prepare(messages: AgentMessage[], tools: ToolDefinition[]): PreparedContext {
+    const system = messages[0] ?? { role: "system", content: "You are CodeN." };
+    const units = buildMessageUnits(messages.slice(1));
+    const toolTokens = this.estimator.estimateTools(tools);
+    const limit = this.inputBudget();
+    let retained = this.summary
+      ? units.filter((unit) => unit.end > this.compactedThrough)
+      : [...units];
+    const recentCount = Math.min(3, retained.length);
+    let projected = this.project(system, retained);
+    let estimated = this.estimator.estimateMessages(projected) + toolTokens;
+    let compacted = false;
+
+    if (estimated > limit * this.threshold && retained.length > recentCount) {
+      const old = retained.slice(0, -recentCount);
+      retained = retained.slice(-recentCount);
+      const oldMessages = [
+        ...(this.summary ? [this.summary] : []),
+        ...old.flatMap((unit) => unit.messages),
+      ];
+      this.compactionRange = { start: old[0]?.start ?? 1, end: old.at(-1)?.end ?? 1 };
+      this.compactedThrough = this.compactionRange.end;
+      this.summary = {
+        role: "system",
+        content: `Compacted conversation summary:\n${summarizeDeterministically(oldMessages)}`,
+      };
+      projected = this.project(system, retained);
+      estimated = this.estimator.estimateMessages(projected) + toolTokens;
+      compacted = true;
+    }
+
+    while (estimated > limit && retained.length > 1) {
+      retained = retained.slice(1);
+      projected = this.project(system, retained);
+      estimated = this.estimator.estimateMessages(projected) + toolTokens;
+      compacted = true;
+    }
+    return { messages: projected, estimatedTokens: estimated, compacted };
+  }
+
+  forceCompact(messages: AgentMessage[], tools: ToolDefinition[]): PreparedContext {
+    const system = messages[0] ?? { role: "system", content: "You are CodeN." };
+    const units = buildMessageUnits(messages.slice(1));
+    const unsummarized = this.summary
+      ? units.filter((unit) => unit.end > this.compactedThrough)
+      : units;
+    const retained = unsummarized.slice(-1);
+    const old = unsummarized.slice(0, -1);
+    const oldMessages = [
+      ...(this.summary ? [this.summary] : []),
+      ...old.flatMap((unit) => unit.messages),
+    ];
+    if (old.length) {
+      this.compactionRange = { start: old[0]?.start ?? 1, end: old.at(-1)?.end ?? 1 };
+      this.compactedThrough = this.compactionRange.end;
+    }
+    this.summary = {
+      role: "system",
+      content: `Emergency compacted summary:\n${summarizeDeterministically(oldMessages)}`,
+    };
+    const projected = this.project(system, retained);
+    const estimated =
+      this.estimator.estimateMessages(projected) + this.estimator.estimateTools(tools);
+    return { messages: projected, estimatedTokens: estimated, compacted: true };
+  }
+
+  setSummary(content: string, compactedThrough = 0): void {
+    this.summary = { role: "system", content };
+    this.compactedThrough = compactedThrough;
+  }
+  getSummary(): string | undefined {
+    return this.summary?.content;
+  }
+  getCompactionRange(): CompactionRange | undefined {
+    return this.compactionRange;
+  }
+  clearSummary(): void {
+    this.summary = undefined;
+    this.compactionRange = undefined;
+    this.compactedThrough = 0;
+  }
+
+  private project(system: AgentMessage, units: MessageUnit[]): AgentMessage[] {
+    return [
+      system,
+      ...(this.summary ? [this.summary] : []),
+      ...units.flatMap((unit) => unit.messages),
+    ];
+  }
+}
+
+function buildMessageUnits(messages: AgentMessage[]): MessageUnit[] {
+  const units: MessageUnit[] = [];
+  let current: MessageUnit | undefined;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (!message) continue;
+    const sourceIndex = index + 1;
+    if (message.role === "user" || !current) {
+      if (current) units.push(current);
+      current = { messages: [message], start: sourceIndex, end: sourceIndex };
+    } else {
+      current.messages.push(message);
+      current.end = sourceIndex;
+    }
+  }
+  if (current) units.push(current);
+  return units;
+}
+
+function summarizeDeterministically(messages: AgentMessage[]): string {
+  const lines = messages.map((message) => {
+    if (message.role === "tool")
+      return `Tool ${message.name} (${message.isError ? "error" : "ok"}): ${message.content.slice(0, 300)}`;
+    return `${message.role}: ${message.content.slice(0, 500)}`;
+  });
+  return lines.join("\n").slice(0, 6000);
+}
+
+export function toModelRequest(
+  model: string,
+  prepared: PreparedContext,
+  tools: ToolDefinition[],
+  budget: ContextBudget,
+  signal?: AbortSignal,
+): ModelRequest {
+  const request: ModelRequest = {
+    model,
+    messages: prepared.messages,
+    tools,
+    maxOutputTokens: budget.reservedOutputTokens,
+  };
+  if (signal) request.signal = signal;
+  return request;
+}

package/src/context/truncate.ts

@@ -0,0 +1,9 @@
+export function truncateOutput(value: string, maxChars: number): string {
+  if (value.length <= maxChars) return value;
+  const markerBudget = 80;
+  const kept = Math.max(0, maxChars - markerBudget);
+  const head = Math.ceil(kept / 2);
+  const tail = Math.floor(kept / 2);
+  const omitted = value.length - head - tail;
+  return `${value.slice(0, head)}\n... [${omitted} characters omitted] ...\n${value.slice(value.length - tail)}`;
+}