@anureo/adapter-pi 0.0.0-stage → 0.3.0

package/src/index.js

@@ -0,0 +1,6 @@
+// Publishes the Pi adapter, host integration contracts and mapping and catalog helpers.
+export { PiAdapter, PiBackendSession, createPiAdapter } from "./adapter.js";
+export { VERIFIED_PI_VERSIONS, resolvePiProfile } from "./profile.js";
+export { createPiHost } from "./host.js";
+export { createRedactor, permissionTools, piTurnError, historyItems, usageOf } from "./mapping.js";
+export { createPiCatalogSession } from "./catalog.js";

package/src/mapping.d.ts

@@ -0,0 +1,104 @@
+import type { FileChange, HarnessError, HistoryItem, InputBlock, Item, JsonValue, Usage } from '@anureo/protocol';
+import type { PiHostContent, PiHostEntry, PiHostImage, PiHostMessage } from "./host.js";
+/** Text and JSON projection shared by live item publication and history reconstruction. */
+export type Redactor = ReturnType<typeof createRedactor>;
+/**
+ * Replace literal secrets in mapped content with `[REDACTED]`. The list is captured at creation,
+ * sorted longest first, and defaults to empty. Empty entries are ignored.
+ *
+ * JSON projection preserves keys, omits undefined object properties, and replaces unsupported
+ * values and containers beyond depth 24 with null. Property access errors propagate to the caller.
+ * PiAdapter captures this redactor at construction and shares it with its backends.
+ */
+export declare function createRedactor(secrets?: readonly string[]): {
+    text(value: string): string;
+    json(value: unknown): JsonValue;
+};
+/** Built-in tools selected for read-only sessions. The host retains its process rights. */
+export declare const READ_ONLY_TOOLS: readonly ["read", "grep", "find", "ls"];
+/** Built-in tool allowlist for agent-full-access sessions. */
+export declare const FULL_ACCESS_TOOLS: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
+/** Permission values advertised by the adapter's configuration schema. */
+export declare const PERMISSION_MODES: readonly ["read-only", "agent-full-access"];
+/** Supported tool-allowlist policy, with no approval interaction. */
+export type PiPermissionMode = typeof PERMISSION_MODES[number];
+/**
+ * Return a fresh Pi tool allowlist for a permission mode. Omission returns undefined so
+ * PiBackendSession.hostOptions can retain host defaults and setConfig can skip changing tools.
+ * Unsupported values throw INVALID_PARAMS before the allowlist is applied.
+ */
+export declare function permissionTools(mode: unknown): string[] | undefined;
+/** Classify a Pi tool by its native name for AHP tool items. Unrecognized names map to `other`. */
+export declare function toolKind(name: string): ToolCallItem['kind'];
+/**
+ * Derive file-change evidence from tool arguments alone. Other tools return undefined and file
+ * tools without a string path return an empty list. A write has an unknown operation because
+ * arguments cannot tell whether the target already exists. Write evidence is always partial.
+ * An edit is complete when all supplied fragments have both texts and at least one fragment exists.
+ */
+export declare function piFileChanges(name: string, args: unknown): FileChange[] | undefined;
+/**
+ * Build a tool-call item with redacted arguments and file evidence. PiBackendSession.startTool
+ * supplies running as the status, then stores and publishes the item on a tool-start event.
+ */
+export declare function toolItem(redact: Redactor, id: string, name: string, args: unknown, status: ItemStatus): ToolCallItem;
+/**
+ * Extract a string content field or concatenate text blocks from a Pi result. Text block values
+ * are coerced to strings, with nullish text treated as empty. Missing or unsupported content
+ * returns an empty string. Structured details are omitted.
+ */
+export declare function toolOutputText(result: unknown): string;
+/**
+ * Copy a tool item with redacted result text and a status of failed or completed according to
+ * the native error flag. A supplied stopped status takes precedence. PiBackendSession.endTool
+ * stores and publishes the copy for a matching live call.
+ */
+export declare function completeTool(redact: Redactor, previous: ToolCallItem, result: unknown, isError: boolean, stopped?: ItemStatus): ToolCallItem;
+/** Pass through string content or join only the text blocks without separators. */
+export declare function contentText(content: string | PiHostContent[]): string;
+/**
+ * Convert submission input to Pi text and inline images, joining text blocks with blank lines.
+ * Unsupported blocks or images without nonempty data and MIME type throw CAPABILITY_UNSUPPORTED.
+ * Image data is passed through without checking base64 encoding. PiBackendSession.submit forwards
+ * the text and any images to the host after conversion succeeds.
+ */
+export declare function nativeInput(input: InputBlock[]): {
+    text: string;
+    images: PiHostImage[];
+};
+/**
+ * Sum reported native token counts across the supplied messages, with zero totals when none
+ * report usage. Scope defaults to turn. PiBackendSession.finishTurn supplies assistant messages
+ * and publishes the result in the usage update and turn completion.
+ */
+export declare function usageOf(messages: readonly PiHostMessage[], scope?: Usage['scope']): Usage;
+/**
+ * Return a sanitized failure for stopReason error, or undefined otherwise. The first recognized
+ * HTTP status number in the native message determines the code. Only rate limits and service
+ * failures are marked retryable. PiBackendSession.messageEnd saves the failure for finishTurn
+ * and clears it on a later stop or toolUse. An interruption takes precedence at completion.
+ */
+export declare function piTurnError(message: PiHostMessage | undefined): HarnessError | undefined;
+/**
+ * Identify turn-start user entry ids in oldest-first branch history. Known live turn bindings
+ * take precedence. Otherwise, only a first message or a user message after an assistant message
+ * whose stop reason differs from toolUse starts a turn. PiBackendSession.forkHost rejects targets
+ * outside this set.
+ */
+export declare function turnStarts(entries: readonly PiHostEntry[], known: ReadonlyMap<string, string>): Set<string>;
+/**
+ * Reconstruct redacted items in transcript order from oldest-first active-branch entries.
+ * `turns` maps user entry ids to live AHP turn ids. Unbound turns use native-prefixed ids.
+ * Items before the first recognized turn use `native:session`.
+ * A result updates the most recent preceding call with its id, even across a turn boundary.
+ * Calls without a result omit status. User items retain only text. Input entries are left intact.
+ *
+ * PiBackendSession.readHistory reconstructs the branch before capping and paging the snapshot,
+ * so a returned call can include its result even when the result came from a later turn.
+ */
+export declare function historyItems(redact: Redactor, entries: readonly PiHostEntry[], turns: ReadonlyMap<string, string>): HistoryItem[];
+type ToolCallItem = Extract<Item, {
+    type: 'toolCall';
+}>;
+type ItemStatus = NonNullable<Item['status']>;
+export {};

package/src/mapping.js

@@ -0,0 +1,324 @@
+import { HarnessSdkError } from '@anureo/sdk';
+/**
+ * Replace literal secrets in mapped content with `[REDACTED]`. The list is captured at creation,
+ * sorted longest first, and defaults to empty. Empty entries are ignored.
+ *
+ * JSON projection preserves keys, omits undefined object properties, and replaces unsupported
+ * values and containers beyond depth 24 with null. Property access errors propagate to the caller.
+ * PiAdapter captures this redactor at construction and shares it with its backends.
+ */
+export function createRedactor(secrets = []) {
+    const values = [...new Set(secrets.filter(secret => secret.length > 0))].sort((a, b) => b.length - a.length);
+    const text = (value) => values.reduce((out, secret) => out.split(secret).join('[REDACTED]'), value);
+    /** Bound container traversal so cyclic or excessively nested input cannot recurse indefinitely. */
+    const project = (value, depth) => {
+        if (typeof value === 'string')
+            return text(value);
+        if (value === null || typeof value === 'number' || typeof value === 'boolean')
+            return value;
+        if (depth > 24)
+            return null;
+        if (Array.isArray(value))
+            return value.map(entry => project(entry, depth + 1));
+        if (value && typeof value === 'object') {
+            const defined = Object.entries(value).filter(([, entry]) => entry !== undefined);
+            return Object.fromEntries(defined.map(([key, entry]) => [key, project(entry, depth + 1)]));
+        }
+        return null;
+    };
+    return { text, json: value => project(value, 0) };
+}
+/** Built-in tools selected for read-only sessions. The host retains its process rights. */
+export const READ_ONLY_TOOLS = ['read', 'grep', 'find', 'ls'];
+/** Built-in tool allowlist for agent-full-access sessions. */
+export const FULL_ACCESS_TOOLS = ['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls'];
+/** Permission values advertised by the adapter's configuration schema. */
+export const PERMISSION_MODES = ['read-only', 'agent-full-access'];
+/**
+ * Return a fresh Pi tool allowlist for a permission mode. Omission returns undefined so
+ * PiBackendSession.hostOptions can retain host defaults and setConfig can skip changing tools.
+ * Unsupported values throw INVALID_PARAMS before the allowlist is applied.
+ */
+export function permissionTools(mode) {
+    if (mode === undefined)
+        return undefined;
+    if (mode === 'read-only')
+        return [...READ_ONLY_TOOLS];
+    if (mode === 'agent-full-access')
+        return [...FULL_ACCESS_TOOLS];
+    throw new HarnessSdkError('INVALID_PARAMS', 'Unsupported Pi permission mode');
+}
+/** Classify a Pi tool by its native name for AHP tool items. Unrecognized names map to `other`. */
+export function toolKind(name) {
+    if (name === 'bash' || name === 'powershell')
+        return 'command';
+    if (name === 'edit' || name === 'write')
+        return 'fileChange';
+    if (name.startsWith('mcp__'))
+        return 'mcp';
+    return 'other';
+}
+/**
+ * Derive file-change evidence from tool arguments alone. Other tools return undefined and file
+ * tools without a string path return an empty list. A write has an unknown operation because
+ * arguments cannot tell whether the target already exists. Write evidence is always partial.
+ * An edit is complete when all supplied fragments have both texts and at least one fragment exists.
+ */
+export function piFileChanges(name, args) {
+    if (name !== 'edit' && name !== 'write')
+        return undefined;
+    const input = record(args);
+    const path = input.path;
+    if (typeof path !== 'string')
+        return [];
+    return [name === 'write' ? writeFileChange(path, input) : editFileChange(path, input)];
+}
+/**
+ * Build a tool-call item with redacted arguments and file evidence. PiBackendSession.startTool
+ * supplies running as the status, then stores and publishes the item on a tool-start event.
+ */
+export function toolItem(redact, id, name, args, status) {
+    return buildToolItem({ redact, id, name, args, status });
+}
+/**
+ * Extract a string content field or concatenate text blocks from a Pi result. Text block values
+ * are coerced to strings, with nullish text treated as empty. Missing or unsupported content
+ * returns an empty string. Structured details are omitted.
+ */
+export function toolOutputText(result) {
+    const content = record(result).content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map(record).filter(part => part.type === 'text').map(part => String(part.text ?? '')).join('');
+}
+/**
+ * Copy a tool item with redacted result text and a status of failed or completed according to
+ * the native error flag. A supplied stopped status takes precedence. PiBackendSession.endTool
+ * stores and publishes the copy for a matching live call.
+ */
+export function completeTool(redact, previous, result, isError, stopped) {
+    return { ...previous, status: stopped ?? (isError ? 'failed' : 'completed'), output: redact.text(toolOutputText(result)) };
+}
+/** Pass through string content or join only the text blocks without separators. */
+export function contentText(content) {
+    if (typeof content === 'string')
+        return content;
+    return content.flatMap(part => part.type === 'text' ? [part.text] : []).join('');
+}
+/**
+ * Convert submission input to Pi text and inline images, joining text blocks with blank lines.
+ * Unsupported blocks or images without nonempty data and MIME type throw CAPABILITY_UNSUPPORTED.
+ * Image data is passed through without checking base64 encoding. PiBackendSession.submit forwards
+ * the text and any images to the host after conversion succeeds.
+ */
+export function nativeInput(input) {
+    const text = [];
+    const images = [];
+    for (const block of input) {
+        if (block.type === 'text')
+            text.push(block.text);
+        else if (block.type === 'image' && block.data && block.mimeType)
+            images.push({ data: block.data, mimeType: block.mimeType });
+        else
+            throw new HarnessSdkError('CAPABILITY_UNSUPPORTED', 'Input cannot be represented by the Pi SDK');
+    }
+    return { text: text.join('\n\n'), images };
+}
+/**
+ * Sum reported native token counts across the supplied messages, with zero totals when none
+ * report usage. Scope defaults to turn. PiBackendSession.finishTurn supplies assistant messages
+ * and publishes the result in the usage update and turn completion.
+ */
+export function usageOf(messages, scope = 'turn') {
+    const total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    for (const message of messages) {
+        if (!message.usage)
+            continue;
+        total.input += message.usage.input;
+        total.output += message.usage.output;
+        total.cacheRead += message.usage.cacheRead;
+        total.cacheWrite += message.usage.cacheWrite;
+        total.total += message.usage.totalTokens;
+    }
+    return { provider: 'pi', scope, source: 'native', ...total };
+}
+/**
+ * Return a sanitized failure for stopReason error, or undefined otherwise. The first recognized
+ * HTTP status number in the native message determines the code. Only rate limits and service
+ * failures are marked retryable. PiBackendSession.messageEnd saves the failure for finishTurn
+ * and clears it on a later stop or toolUse. An interruption takes precedence at completion.
+ */
+export function piTurnError(message) {
+    if (!message || message.stopReason !== 'error')
+        return undefined;
+    const code = turnErrorCode(message.errorMessage ?? '');
+    return { code, message: 'Pi model request failed', retryable: code === 'RATE_LIMITED' || code === 'NATIVE_SERVICE_UNAVAILABLE', outcomeUnknown: false };
+}
+/**
+ * Identify turn-start user entry ids in oldest-first branch history. Known live turn bindings
+ * take precedence. Otherwise, only a first message or a user message after an assistant message
+ * whose stop reason differs from toolUse starts a turn. PiBackendSession.forkHost rejects targets
+ * outside this set.
+ */
+export function turnStarts(entries, known) {
+    const starts = new Set();
+    let previous;
+    for (const entry of entries) {
+        if (entry.kind !== 'message' || !entry.message)
+            continue;
+        if (entry.message.role === 'user' && (known.has(entry.id) || canStartTurnAfter(previous))) {
+            starts.add(entry.id);
+        }
+        previous = entry.message;
+    }
+    return starts;
+}
+/**
+ * Reconstruct redacted items in transcript order from oldest-first active-branch entries.
+ * `turns` maps user entry ids to live AHP turn ids. Unbound turns use native-prefixed ids.
+ * Items before the first recognized turn use `native:session`.
+ * A result updates the most recent preceding call with its id, even across a turn boundary.
+ * Calls without a result omit status. User items retain only text. Input entries are left intact.
+ *
+ * PiBackendSession.readHistory reconstructs the branch before capping and paging the snapshot,
+ * so a returned call can include its result even when the result came from a later turn.
+ */
+export function historyItems(redact, entries, turns) {
+    const starts = turnStarts(entries, turns);
+    const items = [];
+    let turnId = 'native:session';
+    let nativeTurnId;
+    const toolCalls = new Map();
+    for (const entry of entries) {
+        if (starts.has(entry.id)) {
+            nativeTurnId = entry.id;
+            turnId = turns.get(entry.id) ?? `native:${entry.id}`;
+        }
+        const base = { turnId, ...(nativeTurnId ? { nativeTurnId } : {}), nativeItemId: entry.id };
+        for (const mapped of historyEntryItems({ redact, entry, base })) {
+            if (mapped.item.type === 'toolCall')
+                toolCalls.set(mapped.item.id, mapped);
+            items.push(mapped);
+        }
+        applyHistoryToolResult(redact, entry, toolCalls);
+    }
+    return items;
+}
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+/** Use the supplied whole-file text as evidence. The arguments establish neither existence nor prior contents. */
+function writeFileChange(path, input) {
+    const materials = typeof input.content === 'string'
+        ? [{ format: 'text', scope: 'file', oldText: null, newText: input.content }]
+        : [{ format: 'unavailable', reason: 'notProvided' }];
+    return { path, operation: 'unknown', materials, completeness: 'partial' };
+}
+/** Retain usable edit fragments even when other supplied fragments are incomplete. */
+function editFileChange(path, input) {
+    const edits = Array.isArray(input.edits) ? input.edits.map(record) : [];
+    const fragments = edits.flatMap((edit) => {
+        if (typeof edit.oldText !== 'string' || typeof edit.newText !== 'string')
+            return [];
+        return [{ format: 'text', scope: 'fragment', oldText: edit.oldText, newText: edit.newText }];
+    });
+    const complete = fragments.length > 0 && fragments.length === edits.length;
+    return {
+        path,
+        operation: 'modify',
+        materials: fragments.length ? fragments : [{ format: 'unavailable', reason: 'notProvided' }],
+        completeness: complete ? 'complete' : 'partial',
+    };
+}
+/** Apply the same content projection to live and historical calls. A transcript call alone leaves status unset. */
+function buildToolItem(call) {
+    const { redact, id, name, args } = call;
+    const fileChanges = piFileChanges(name, args);
+    return {
+        id,
+        type: 'toolCall',
+        kind: toolKind(name),
+        title: name,
+        toolName: name,
+        nativeType: name,
+        input: redact.json(args),
+        ...(Object.hasOwn(call, 'status') ? { status: call.status } : {}),
+        ...(fileChanges ? { fileChanges: redact.json(fileChanges) } : {}),
+    };
+}
+/** Classify the first recognized status number without exposing the provider's error text. */
+function turnErrorCode(errorMessage) {
+    const status = /\b(401|403|429|5\d\d)\b/.exec(errorMessage)?.[1];
+    switch (status) {
+        case '401': return 'AUTH_REQUIRED';
+        case '403': return 'AUTH_FORBIDDEN';
+        case '429': return 'RATE_LIMITED';
+        case undefined: return 'PI_TURN_FAILED';
+        default: return 'NATIVE_SERVICE_UNAVAILABLE';
+    }
+}
+/** Infer a boundary from the prior message when a user entry has no known live binding. */
+function canStartTurnAfter(previous) {
+    return !previous || (previous.role === 'assistant' && previous.stopReason !== 'toolUse');
+}
+/** Complete the matched call at its original position in history. Unmatched results are discarded. */
+function applyHistoryToolResult(redact, entry, toolCalls) {
+    const message = entry.message;
+    if (entry.kind !== 'message' || message?.role !== 'toolResult' || !message.toolCallId)
+        return;
+    const previous = toolCalls.get(message.toolCallId);
+    if (previous?.item.type !== 'toolCall')
+        return;
+    const result = { content: contentText(message.content) };
+    previous.item = completeTool(redact, previous.item, result, message.isError === true);
+}
+/** Project one entry using the turn metadata supplied by historyItems. Results update earlier items. */
+function historyEntryItems({ redact, entry, base }) {
+    if (entry.kind === 'compaction') {
+        return [{
+                ...base,
+                item: {
+                    id: entry.id,
+                    type: 'compaction',
+                    status: 'completed',
+                    ...(entry.summary ? { summary: redact.text(entry.summary) } : {}),
+                },
+            }];
+    }
+    const message = entry.message;
+    if (entry.kind !== 'message' || !message)
+        return [];
+    if (message.role === 'user') {
+        return [{
+                ...base,
+                item: {
+                    id: entry.id,
+                    type: 'userMessage',
+                    status: 'completed',
+                    content: [{ type: 'text', text: redact.text(contentText(message.content)) }],
+                },
+            }];
+    }
+    if (message.role !== 'assistant' || !Array.isArray(message.content))
+        return [];
+    return assistantHistoryItems({ redact, message, content: message.content, base });
+}
+/** Keep native block indexes in text and reasoning ids. Text is final only on stop with no tool calls. */
+function assistantHistoryItems({ redact, message, content, base }) {
+    const hasTools = content.some(part => part.type === 'toolCall');
+    return content.flatMap((part, index) => {
+        const id = `${base.nativeItemId}:${index}`;
+        if (part.type === 'text') {
+            const text = redact.text(part.text);
+            const phase = !hasTools && message.stopReason === 'stop' ? 'final' : 'commentary';
+            return [{ ...base, item: { id, type: 'agentMessage', status: 'completed', text, phase } }];
+        }
+        if (part.type === 'thinking')
+            return [{ ...base, item: { id, type: 'reasoning', status: 'completed', text: redact.text(part.thinking) } }];
+        if (part.type === 'toolCall') {
+            const item = buildToolItem({ redact, id: part.id, name: part.name, args: part.arguments });
+            return [{ ...base, item }];
+        }
+        return [];
+    });
+}

package/src/options.d.ts

@@ -0,0 +1,20 @@
+import type { PiHostFactory } from "./host.js";
+/** Configure Pi host acquisition, persistence and history for createPiAdapter. */
+export interface PiAdapterOptions {
+    /** Trusted Pi SDK version. Omit to report `unknown` and use the baseline profile for any host. */
+    version?: string;
+    /** Open an owned host for the adapter to dispose. Defaults to the in-process Pi host. */
+    createHost?: PiHostFactory;
+    /** Override Pi's global configuration directory. Omit or pass an empty string to use the host default. */
+    agentDir?: string;
+    /** Override the directory for persisted session files. Omitting it or passing an empty string leaves selection to the host. */
+    sessionDir?: string;
+    /** Allow disk persistence when the version profile supports resume. Defaults to true. */
+    persistSessions?: boolean;
+    /** Literal secrets to redact in mapped message and tool content and history. Empty strings are ignored. */
+    secrets?: string[];
+    /** Number of most recent history items retained per snapshot. Defaults to 5000. Zero retains all. */
+    maxHistoryItems?: number;
+    /** Currently unused; the adapter does not invoke this callback. */
+    diagnostic?: (code: string) => void;
+}

package/src/profile.d.ts

@@ -0,0 +1,28 @@
+import type { Capabilities } from '@anureo/protocol';
+/** Exact Pi release strings verified for resume, fork and compaction. */
+export declare const VERIFIED_PI_VERSIONS: readonly ["1.5.2"];
+/** Capabilities selected from a trusted Pi version, before persistence settings are applied. */
+export interface PiProfile {
+    /** Minimum release for this capability set; `0.0.0` denotes the baseline. */
+    since: string;
+    /** Allows the adapter to open a previously persisted session. */
+    resume: boolean;
+    /** Allows the adapter to branch from a verified turn boundary when persistence is enabled. */
+    fork: boolean;
+    /** Allows the adapter to request manual compaction. */
+    compact: boolean;
+    /** True only for an exact version in VERIFIED_PI_VERSIONS. */
+    verified: boolean;
+}
+/**
+ * Select capabilities using the first numeric release triple in the trusted Pi version string.
+ * Pi 1.5.2 and later major-1 releases enable resume, fork and compaction. Only exact entries in
+ * VERIFIED_PI_VERSIONS are marked verified. Omission or any other version selects the baseline.
+ */
+export declare function resolvePiProfile(version?: string): PiProfile;
+/**
+ * Derive the native capabilities that PiAdapter advertises during negotiation and passes to
+ * PiBackendSession. Resume and fork require persistence as well as version support. The SDK
+ * output wrapper can advertise structured output separately.
+ */
+export declare function capabilities(profile: PiProfile, persist: boolean): Capabilities;

package/src/profile.js

@@ -0,0 +1,43 @@
+import { PERMISSION_MODES } from "./mapping.js";
+/** Exact Pi release strings verified for resume, fork and compaction. */
+export const VERIFIED_PI_VERSIONS = ['1.5.2'];
+/**
+ * Select capabilities using the first numeric release triple in the trusted Pi version string.
+ * Pi 1.5.2 and later major-1 releases enable resume, fork and compaction. Only exact entries in
+ * VERIFIED_PI_VERSIONS are marked verified. Omission or any other version selects the baseline.
+ */
+export function resolvePiProfile(version) {
+    if (version && supportsResumeForkAndCompaction(version)) {
+        return { since: '1.5.2', resume: true, fork: true, compact: true, verified: VERIFIED_PI_VERSIONS.includes(version) };
+    }
+    return { since: '0.0.0', resume: false, fork: false, compact: false, verified: false };
+}
+/**
+ * Derive the native capabilities that PiAdapter advertises during negotiation and passes to
+ * PiBackendSession. Resume and fork require persistence as well as version support. The SDK
+ * output wrapper can advertise structured output separately.
+ */
+export function capabilities(profile, persist) {
+    const stored = persist && profile.resume;
+    return {
+        session: { resume: stored, fork: stored && profile.fork ? ['before', 'through'] : [], history: true },
+        input: { delivery: ['native', 'afterTurn'], interrupt: { targets: ['session'], reportsPendingInputs: false } },
+        turn: { outputSchema: false, overrides: [], inputModalities: ['text', 'image'] },
+        ...(profile.compact ? { compact: true } : {}),
+        config: { options: [
+                { id: 'model', title: 'Model', scope: 'session', schema: { type: 'string', minLength: 1 } },
+                { id: 'thinkingLevel', title: 'Thinking level', scope: 'session', schema: { type: 'string', enum: [...THINKING_LEVELS] } },
+                { id: 'permissionMode', title: 'Permissions', scope: 'session', schema: { type: 'string', enum: [...PERMISSION_MODES], default: 'agent-full-access' } },
+            ] },
+    };
+}
+const THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+/** Check the first numeric release triple, ignoring surrounding text and suffixes. */
+function supportsResumeForkAndCompaction(version) {
+    const match = /(\d+)\.(\d+)\.(\d+)/.exec(version);
+    if (!match)
+        return false;
+    const [, major, minor, patch] = match;
+    const minorVersion = Number(minor);
+    return Number(major) === 1 && (minorVersion > 5 || (minorVersion === 5 && Number(patch) >= 2));
+}