@alisio/core 0.1.0-alpha.3

package/dist/config.js

@@ -0,0 +1,416 @@
+import { chmod, mkdir, open, readFile, rename, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { z } from "zod";
+import { exists, readJson } from "./runtime/fs.js";
+import { isPathSpec } from "./runtime/modules.js";
+const providerSchema = z
+    .object({
+    baseURL: z.url().default("https://api.openai.com/v1"),
+    apiKeyEnv: z.string().default("OPENAI_API_KEY"),
+    model: z.string().default(""),
+    apiMode: z.enum(["chat", "responses"]).default("chat"),
+    auth: z.enum(["bearer", "none"]).default("bearer"),
+    tokenParameter: z.enum(["max_tokens", "max_completion_tokens", "omit"]).default("max_tokens"),
+    streamUsage: z.boolean().default(false),
+    /** Context window in tokens; overrides the value reported by GET /models. */
+    contextWindow: z.number().int().positive().optional(),
+})
+    .strict();
+const safeUrl = z
+    .string()
+    .url()
+    .refine((value) => {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password;
+}, { message: "must be an HTTP(S) URL without credentials" });
+const environment = z.record(z.string(), z.string());
+const stdioServerSchema = z
+    .object({
+    transport: z.literal("stdio"),
+    enabled: z.boolean().default(true),
+    command: z.string().trim().min(1),
+    args: z.array(z.string()).default([]),
+    envAllow: z.array(z.string()).default([]),
+    env: environment.default({}),
+})
+    .strict();
+const httpServerSchema = z
+    .object({
+    transport: z.literal("http"),
+    enabled: z.boolean().default(true),
+    url: safeUrl,
+    bearerTokenEnv: z.string().trim().min(1).optional(),
+})
+    .strict();
+const serverSchema = z.discriminatedUnion("transport", [stdioServerSchema, httpServerSchema]);
+const compatibleServerSchema = z.union([
+    serverSchema,
+    z
+        .object({
+        command: z.string().trim().min(1),
+        enabled: z.boolean().default(true),
+        args: z.array(z.string()).default([]),
+        envAllow: z.array(z.string()).default([]),
+        env: environment.default({}),
+    })
+        .strict()
+        .transform((server) => ({ ...server, transport: "stdio" })),
+    z
+        .object({
+        url: safeUrl,
+        enabled: z.boolean().default(true),
+        bearerTokenEnv: z.string().trim().min(1).optional(),
+    })
+        .strict()
+        .transform((server) => ({ ...server, transport: "http" })),
+]);
+const serverName = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const serversSchema = (value) => z.record(z.string(), value).superRefine((servers, context) => {
+    for (const name of Object.keys(servers))
+        if (!serverName.test(name))
+            context.addIssue({
+                code: "custom",
+                path: [name],
+                message: "MCP server names may contain only letters, numbers, dot, underscore and dash",
+            });
+});
+const configObjectSchema = z
+    .object({
+    schemaVersion: z.literal(1).default(1),
+    provider: providerSchema.default(() => providerSchema.parse({})),
+    plugins: z.array(z.string()).default([]),
+    skills: z.array(z.string()).default([]),
+    /** Project-local enable/disable overrides for effective non-plugin skills. */
+    skillOverrides: z.record(z.string(), z.object({ enabled: z.boolean() }).strict()).default({}),
+    mcp: z
+        .object({ servers: serversSchema(compatibleServerSchema).default({}) })
+        .strict()
+        .default({ servers: {} }),
+    /** Compatibility with the common MCP client configuration shape. */
+    mcpServers: serversSchema(compatibleServerSchema).optional(),
+    /** Built-in plugin options keyed by id; each plugin validates its own section. */
+    builtinPlugins: z
+        .record(z.string(), z.object({ enabled: z.boolean().optional() }).passthrough())
+        .default({}),
+    /** Project-local enable/disable overrides for configured external plugins, keyed by plugin id. */
+    pluginOverrides: z.record(z.string(), z.object({ enabled: z.boolean() }).strict()).default({}),
+    /** Host-enforced timeouts for plugin hooks. */
+    pluginHooks: z
+        .object({
+        timeoutMs: z.number().int().min(100).max(120_000).default(15_000),
+        sessionEndTimeoutMs: z.number().int().min(100).max(120_000).default(10_000),
+    })
+        .strict()
+        .default(() => ({ timeoutMs: 15_000, sessionEndTimeoutMs: 10_000 })),
+    context: z
+        .object({
+        /** Use CLAUDE.md where a directory has no AGENTS.md (off by default). */
+        claudeMdFallback: z.boolean().default(false),
+        /** Total bytes of AGENTS.md content injected (closest files kept). */
+        maxBytes: z
+            .number()
+            .int()
+            .min(1024)
+            .max(1_048_576)
+            .default(32 * 1024),
+    })
+        .strict()
+        .default(() => ({ claudeMdFallback: false, maxBytes: 32 * 1024 })),
+    compaction: z
+        .object({
+        auto: z.boolean().default(true),
+        threshold: z.number().min(0.1).max(0.99).default(0.85),
+        keepTurns: z.number().int().min(0).max(20).default(2),
+    })
+        .strict()
+        .default(() => ({ auto: true, threshold: 0.85, keepTurns: 2 })),
+    websearch: z
+        .object({
+        provider: z
+            .enum(["searxng", "duckduckgo-instant", "tavily", "brave", "serpapi", "native"])
+            .optional(),
+        searxngUrl: z.string().optional(),
+        apiKeyEnv: z.string().optional(),
+        /** Only for provider "native": the provider-native tool type sent to the model. */
+        nativeToolType: z.string().default("web_search"),
+    })
+        .strict()
+        .default(() => ({ nativeToolType: "web_search" })),
+    limits: z
+        .object({
+        maxTurns: z.number().int().min(1).max(100).default(20),
+        timeoutMs: z.number().int().min(100).default(300000),
+        maxContextChars: z.number().int().positive().default(160000),
+        maxOutputTokens: z.number().int().positive().default(4096),
+        /** Cumulative tokens per run; default is proportional to the context window. */
+        maxTokens: z.number().int().positive().optional(),
+    })
+        .default(() => ({
+        maxTurns: 20,
+        timeoutMs: 300000,
+        maxContextChars: 160000,
+        maxOutputTokens: 4096,
+    })),
+})
+    .strict()
+    .superRefine((config, context) => {
+    if (!config.mcpServers)
+        return;
+    for (const name of Object.keys(config.mcpServers))
+        if (name in config.mcp.servers)
+            context.addIssue({
+                code: "custom",
+                path: ["mcpServers", name],
+                message: `MCP server "${name}" is defined in both mcp.servers and mcpServers`,
+            });
+});
+export const configSchema = configObjectSchema.transform(({ mcpServers, ...config }) => ({
+    ...config,
+    mcp: { servers: { ...config.mcp.servers, ...mcpServers } },
+}));
+/** Whether legacy provider selection should take priority over a saved plugin profile for this run. */
+export function overridesSavedProviderProfile(provenance, hasEndpointOverride) {
+    return hasEndpointOverride || !!provenance.selectedLayer?.hasLegacyProvider;
+}
+export const configHome = () => process.env.ALISIO_CONFIG_HOME ??
+    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "alisio");
+export const stateHome = () => process.env.ALISIO_STATE_HOME ??
+    join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "alisio");
+/** Highest-priority configuration file selected for a workspace (it may not exist). */
+export function configFile(workspace, options = {}) {
+    // Only explicit/trusted project configuration may redirect credentials to another endpoint.
+    return options.file
+        ? resolve(options.file)
+        : options.trustProject
+            ? join(workspace, ".alisio", "config.json")
+            : join(configHome(), "config.json");
+}
+export async function loadConfigWithProvenance(workspace, options = {}) {
+    const globalFile = join(configHome(), "config.json");
+    const selectedFile = options.file
+        ? resolve(options.file)
+        : options.trustProject
+            ? join(workspace, ".alisio", "config.json")
+            : undefined;
+    const parseLayer = async (file, kind) => {
+        const raw = (await readJson(file)) ?? {};
+        const config = configSchema.parse(raw);
+        config.skills = config.skills.map((p) => resolve(file, "..", p));
+        // Plugin entries are paths (relative to the config file) or npm package names.
+        config.plugins = config.plugins.map((p) => (isPathSpec(p) ? resolve(file, "..", p) : p));
+        for (const server of Object.values(config.mcp.servers))
+            if (server.transport === "stdio") {
+                if (server.command.startsWith("./") || server.command.startsWith("../"))
+                    server.command = resolve(file, "..", server.command);
+                server.args = server.args.map((argument) => argument.startsWith("./") || argument.startsWith("../")
+                    ? resolve(file, "..", argument)
+                    : argument);
+            }
+        const object = raw;
+        const canonical = object.mcp && typeof object.mcp === "object" && !Array.isArray(object.mcp)
+            ? object.mcp.servers
+            : undefined;
+        const alias = object.mcpServers;
+        const sources = Object.fromEntries(Object.keys(config.mcp.servers).map((name) => [
+            name,
+            {
+                kind,
+                file,
+                form: canonical && name in canonical ? "canonical" : "alias",
+            },
+        ]));
+        return { config, keys: new Set(Object.keys(object)), sources };
+    };
+    const global = await parseLayer(globalFile, "global");
+    // Skill activation is deliberately project-local; never carry a similarly named global field
+    // into another workspace.
+    global.config.skillOverrides = {};
+    let config = global.config;
+    let mcpSources = global.sources;
+    let selectedKeys;
+    if (selectedFile && selectedFile !== globalFile) {
+        const selected = await parseLayer(selectedFile, options.file ? "explicit" : "project");
+        selectedKeys = selected.keys;
+        const overlaid = { ...config };
+        for (const key of selected.keys) {
+            if (key === "mcp" || key === "mcpServers")
+                continue;
+            if (key in selected.config)
+                overlaid[key] = selected.config[key];
+        }
+        if (selected.keys.has("mcp") || selected.keys.has("mcpServers"))
+            overlaid.mcp = {
+                servers: { ...config.mcp.servers, ...selected.config.mcp.servers },
+            };
+        mcpSources = { ...mcpSources, ...selected.sources };
+        config = overlaid;
+    }
+    else if (selectedFile) {
+        selectedKeys = global.keys;
+    }
+    config.provider = providerSchema.parse({
+        ...config.provider,
+        ...(process.env.OPENAI_BASE_URL ? { baseURL: process.env.OPENAI_BASE_URL } : {}),
+        ...(process.env.ALISIO_MODEL ? { model: process.env.ALISIO_MODEL } : {}),
+        ...(process.env.ALISIO_API_MODE ? { apiMode: process.env.ALISIO_API_MODE } : {}),
+        ...(options.baseURL ? { baseURL: options.baseURL } : {}),
+        ...(options.model ? { model: options.model } : {}),
+        ...(options.apiMode ? { apiMode: options.apiMode } : {}),
+    });
+    const url = new URL(config.provider.baseURL);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+        throw new Error("baseURL must be an HTTP(S) URL without credentials");
+    return {
+        config: { ...config, mcpSources },
+        provenance: {
+            ...(selectedFile
+                ? {
+                    selectedLayer: {
+                        kind: options.file ? "explicit" : "project",
+                        hasLegacyProvider: selectedKeys?.has("provider") ?? false,
+                    },
+                }
+                : {}),
+        },
+    };
+}
+export async function loadConfig(workspace, options = {}) {
+    return (await loadConfigWithProvenance(workspace, options)).config;
+}
+/** Atomically toggles one MCP server in the form and file that defined it. */
+export async function setMcpServerEnabled(input) {
+    if (!input.source.file)
+        throw new Error("This MCP server is managed by its registering plugin");
+    const file = input.source.file;
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("Alisio configuration must be a JSON object");
+    const raw = parsed;
+    const container = input.source.form === "alias"
+        ? raw.mcpServers
+        : raw.mcp && typeof raw.mcp === "object" && !Array.isArray(raw.mcp)
+            ? raw.mcp.servers
+            : undefined;
+    if (!container || typeof container !== "object" || Array.isArray(container))
+        throw new Error(`MCP server "${input.name}" is no longer present in its defining configuration`);
+    const current = container[input.name];
+    if (!current || typeof current !== "object" || Array.isArray(current))
+        throw new Error(`MCP server "${input.name}" is no longer present in its defining configuration`);
+    container[input.name] = {
+        ...current,
+        enabled: input.enabled,
+    };
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(raw, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporary, file);
+        await chmod(file, 0o600);
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => { });
+        throw error;
+    }
+    return file;
+}
+/** Atomically updates one project plugin override while preserving every unrelated JSON field. */
+export async function setProjectPluginEnabled(input) {
+    const file = join(input.workspace, ".alisio", "config.json");
+    let raw = {};
+    if (await exists(file)) {
+        if (!input.trusted)
+            throw new Error("Trust this project before changing its existing Alisio configuration");
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("Project Alisio configuration must be a JSON object");
+        raw = parsed;
+    }
+    if (input.builtin) {
+        const current = raw.builtinPlugins &&
+            typeof raw.builtinPlugins === "object" &&
+            !Array.isArray(raw.builtinPlugins)
+            ? raw.builtinPlugins
+            : {};
+        const entry = current[input.id] &&
+            typeof current[input.id] === "object" &&
+            !Array.isArray(current[input.id])
+            ? current[input.id]
+            : {};
+        raw.builtinPlugins = { ...current, [input.id]: { ...entry, enabled: input.enabled } };
+    }
+    else {
+        const current = raw.pluginOverrides &&
+            typeof raw.pluginOverrides === "object" &&
+            !Array.isArray(raw.pluginOverrides)
+            ? raw.pluginOverrides
+            : {};
+        raw.pluginOverrides = { ...current, [input.id]: { enabled: input.enabled } };
+    }
+    raw.schemaVersion ??= 1;
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(raw, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporary, file);
+        await chmod(file, 0o600);
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => { });
+        throw error;
+    }
+    return file;
+}
+/** Atomically updates one project skill override while preserving every unrelated JSON field. */
+export async function setProjectSkillEnabled(input) {
+    const file = join(input.workspace, ".alisio", "config.json");
+    let raw = {};
+    if (await exists(file)) {
+        if (!input.trusted)
+            throw new Error("Trust this project before changing its existing Alisio configuration");
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("Project Alisio configuration must be a JSON object");
+        raw = parsed;
+    }
+    const current = raw.skillOverrides &&
+        typeof raw.skillOverrides === "object" &&
+        !Array.isArray(raw.skillOverrides)
+        ? raw.skillOverrides
+        : {};
+    raw.skillOverrides = { ...current, [input.id]: { enabled: input.enabled } };
+    raw.schemaVersion ??= 1;
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(raw, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporary, file);
+        await chmod(file, 0o600);
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => { });
+        throw error;
+    }
+    return file;
+}

package/dist/core/compaction.d.ts

@@ -0,0 +1,48 @@
+import type { CompactionCheckpoint, CompletionRequest, Message, ModelProvider } from "@alisio/sdk";
+/** Rough provider-agnostic estimate: ~4 characters per token. */
+export declare function estimateTokens(value: string | Message[]): number;
+export declare function shouldCompact(used: number, window: number | undefined, threshold: number): boolean;
+export interface CompactionOptions {
+    /** Recent user turns kept verbatim. */
+    keepTurns?: number;
+    /** Minimum trailing messages kept when falling back to a mid-turn boundary. */
+    minKeepMessages?: number;
+}
+export interface CompactionPlan {
+    cut: number;
+    summarized: Message[];
+    kept: Message[];
+}
+export declare function planCompaction(messages: Message[], options?: CompactionOptions): CompactionPlan | undefined;
+/**
+ * Plain-text transcript used as summarizer input. Provider continuation data (for example
+ * encrypted reasoning) is opaque and is intentionally not included.
+ */
+export declare function serializeForSummary(messages: Message[], maxItemChars?: number): string;
+export declare function renderCheckpoint(c: CompactionCheckpoint): string;
+/** Summarizer instructions: JSON checkpoint plus any extension-requested fields. */
+export declare function checkpointInstructions(extraInstructions?: string[], fields?: Record<string, string>): string;
+export interface CheckpointOutput {
+    structured: boolean;
+    checkpoint?: CompactionCheckpoint;
+    /** Requested extension fields present in the JSON (unvalidated). */
+    extracted: Record<string, unknown>;
+    /** Rendered checkpoint, or the raw model text when the JSON was invalid. */
+    text: string;
+}
+export declare function parseCheckpointOutput(raw: string, fields?: string[]): CheckpointOutput;
+export declare function summarize(provider: ModelProvider, request: {
+    instructions: string;
+    messages: Message[];
+    focus?: string;
+    model?: string;
+    maxOutputTokens: number;
+    signal: AbortSignal;
+    sessionId?: string;
+}): Promise<string>;
+/** Narrow provider-agnostic completion used by compaction and the plugin model service. */
+export declare function completeText(provider: ModelProvider, request: CompletionRequest & {
+    signal: AbortSignal;
+    sessionId?: string;
+}): Promise<string>;
+export declare function summaryMessage(body: string, replaced: number): Message;

package/dist/core/compaction.js

@@ -0,0 +1,206 @@
+import { z } from "zod";
+/** Rough provider-agnostic estimate: ~4 characters per token. */
+export function estimateTokens(value) {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    return Math.ceil(text.length / 4);
+}
+export function shouldCompact(used, window, threshold) {
+    return !!window && window > 0 && used >= window * threshold;
+}
+/**
+ * Indexes where history can be split without separating an assistant tool call from its
+ * results: every call before the index is answered before the index, and the kept part
+ * does not start with a tool result.
+ */
+function boundaries(messages) {
+    const open = new Set();
+    const valid = [];
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        if (!m)
+            continue;
+        if (i > 0 && m.role !== "tool" && open.size === 0)
+            valid.push(i);
+        if (m.role === "assistant")
+            for (const c of m.calls)
+                open.add(c.id);
+        if (m.role === "tool")
+            open.delete(m.callId);
+    }
+    return open.size ? undefined : valid;
+}
+export function planCompaction(messages, options = {}) {
+    const keepTurns = Math.max(0, options.keepTurns ?? 2), minKeep = Math.max(1, options.minKeepMessages ?? 4);
+    const valid = boundaries(messages);
+    if (!valid?.length)
+        return undefined;
+    // Turn starts: user messages at a safe boundary (the first message always is one).
+    const turns = [
+        ...(messages[0]?.role === "user" ? [0] : []),
+        ...valid.filter((i) => messages[i]?.role === "user"),
+    ];
+    let cut = 0;
+    if (keepTurns === 0)
+        cut = messages.length;
+    else if (turns.length > keepTurns)
+        cut = turns.at(-keepTurns) ?? 0;
+    // Fewer turns than requested: still keep the latest turn intact.
+    else if (turns.length >= 2)
+        cut = turns.at(-1) ?? 0;
+    // Summarizing fewer than two messages gains nothing; inside one long turn, fall back to
+    // the latest mid-turn boundary that keeps enough recent messages.
+    if (cut < 2) {
+        const fallback = valid.filter((i) => messages.length - i >= minKeep).at(-1);
+        cut = fallback ?? 0;
+    }
+    if (cut < 2)
+        return undefined;
+    return { cut, summarized: messages.slice(0, cut), kept: messages.slice(cut) };
+}
+const clip = (text, max) => text.length > max ? `${text.slice(0, max)}… [truncated]` : text;
+/**
+ * Plain-text transcript used as summarizer input. Provider continuation data (for example
+ * encrypted reasoning) is opaque and is intentionally not included.
+ */
+export function serializeForSummary(messages, maxItemChars = 4_000) {
+    const lines = [];
+    for (const m of messages) {
+        if (m.role === "user") {
+            lines.push(`${m.summary ? "PREVIOUS SUMMARY" : "USER"}: ${clip(m.text, maxItemChars)}`);
+            // Attachments never reach the summarizer as bytes: only mime type and dimensions, as text.
+            for (const a of m.attachments ?? [])
+                lines.push(`ATTACHMENT: ${a.mimeType}${a.width && a.height ? ` ${a.width}x${a.height}` : ""}, ${a.bytes} bytes`);
+        }
+        else if (m.role === "assistant") {
+            if (m.text)
+                lines.push(`ASSISTANT: ${clip(m.text, maxItemChars)}`);
+            for (const c of m.calls)
+                lines.push(`TOOL CALL ${c.id} ${c.name}: ${clip(c.arguments, maxItemChars)}`);
+        }
+        else {
+            const text = m.result.content.map((c) => c.text).join("\n");
+            lines.push(`TOOL RESULT ${m.callId}${m.result.isError ? " (error)" : ""}: ${clip(text, maxItemChars)}`);
+        }
+    }
+    return lines.join("\n");
+}
+const text = z.string().trim().max(4_000);
+const list = z.array(text).max(40).default([]);
+const checkpointSchema = z.object({
+    goal: text.min(1),
+    instructions: list,
+    discoveries: list,
+    accomplished: list,
+    currentState: text.default(""),
+    nextSteps: list,
+    relevantFiles: list,
+});
+const section = (title, body) => {
+    const content = Array.isArray(body)
+        ? body.length
+            ? body.map((b) => `- ${b}`).join("\n")
+            : "- (none)"
+        : body || "(none)";
+    return `## ${title}\n${content}`;
+};
+export function renderCheckpoint(c) {
+    return [
+        section("Goal", c.goal),
+        section("User instructions/constraints", c.instructions),
+        section("Discoveries", c.discoveries),
+        section("Accomplished", c.accomplished),
+        section("Current state", c.currentState),
+        section("Next steps", c.nextSteps),
+        section("Relevant files", c.relevantFiles),
+    ].join("\n\n");
+}
+/** Summarizer instructions: JSON checkpoint plus any extension-requested fields. */
+export function checkpointInstructions(extraInstructions = [], fields = {}) {
+    const extra = Object.entries(fields)
+        .map(([name, description]) => `,\n "${name}": ${description}`)
+        .join("");
+    return [
+        `You compress the history of a coding-agent session into a checkpoint that lets the agent
+continue without the original messages. Reply with ONLY a JSON object (no prose):
+{"checkpoint":{"goal":string,"instructions":string[],"discoveries":string[],"accomplished":string[],"currentState":string,"nextSteps":string[],"relevantFiles":string[]}${extra}}
+"instructions" are the user's instructions and constraints. Keep file paths, symbols,
+commands, tool call IDs and error messages exact. Do not invent facts. Be concise.`,
+        ...extraInstructions.filter((x) => x.trim()),
+    ].join("\n\n");
+}
+function extractJson(raw) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(raw)?.[1];
+    const candidate = fenced ?? raw.slice(raw.indexOf("{"), raw.lastIndexOf("}") + 1);
+    return JSON.parse(candidate);
+}
+export function parseCheckpointOutput(raw, fields = []) {
+    const fallback = { structured: false, extracted: {}, text: raw.trim() };
+    let value;
+    try {
+        value = extractJson(raw);
+    }
+    catch {
+        return fallback;
+    }
+    const parsed = z.object({ checkpoint: checkpointSchema }).passthrough().safeParse(value);
+    if (!parsed.success)
+        return fallback;
+    const record = value;
+    const extracted = Object.fromEntries(fields.filter((f) => f !== "checkpoint" && f in record).map((f) => [f, record[f]]));
+    const checkpoint = parsed.data.checkpoint;
+    return { structured: true, checkpoint, extracted, text: renderCheckpoint(checkpoint) };
+}
+export async function summarize(provider, request) {
+    const focus = request.focus?.trim()
+        ? `\n\nAdditional focus requested by the user: ${request.focus.trim()}`
+        : "";
+    const text = await completeText(provider, {
+        system: request.instructions,
+        messages: [
+            {
+                role: "user",
+                text: `Checkpoint this session transcript.${focus}\n\n<transcript>\n${serializeForSummary(request.messages)}\n</transcript>`,
+            },
+        ],
+        maxTokens: request.maxOutputTokens,
+        signal: request.signal,
+        ...(request.model ? { model: request.model } : {}),
+        ...(request.sessionId ? { sessionId: request.sessionId } : {}),
+    });
+    if (!text)
+        throw new Error("Summarizer returned an empty summary");
+    return text;
+}
+/** Narrow provider-agnostic completion used by compaction and the plugin model service. */
+export async function completeText(provider, request) {
+    let text = "", completed = false;
+    for await (const event of provider.stream({
+        instructions: request.system,
+        messages: request.messages.map((m) => m.role === "user"
+            ? { role: "user", text: m.text }
+            : { role: "assistant", text: m.text, calls: [] }),
+        tools: [],
+        maxOutputTokens: request.maxTokens ?? 2048,
+        signal: request.signal,
+        ...(request.model ? { model: request.model } : {}),
+        ...(request.sessionId ? { sessionId: request.sessionId } : {}),
+    })) {
+        request.signal.throwIfAborted();
+        if (event.type === "completed") {
+            completed = true;
+            text = event.message.text || text;
+        }
+        else if (event.type === "text_delta")
+            text += event.delta;
+    }
+    if (!completed)
+        throw new Error("Completion ended without a completed response");
+    return text.trim();
+}
+export function summaryMessage(body, replaced) {
+    return {
+        role: "user",
+        summary: true,
+        text: `[Checkpoint of ${replaced} earlier messages, generated by context compaction]\n\n${body}`,
+    };
+}