@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/agent/harness/execution/tools.d.ts

@@ -0,0 +1,66 @@
+import { type ToolResultMessage } from "../../../ai/index.js";
+import type { AgentToolCall, AgentToolResult } from "../../types.js";
+import { type Context } from "../context.js";
+import type { JsonValue } from "../session/types.js";
+import type { AgentHarnessTool, AgentHarnessToolInvocation, AgentHarnessToolUpdateCallback } from "../types.js";
+import type { Gate } from "./effect-gate.js";
+/** A tool call whose tool exists and whose prepared arguments passed validation. */
+export interface PreparedToolCall<TContext extends object | undefined> {
+    toolCall: AgentToolCall;
+    tool: AgentHarnessTool<TContext>;
+    args: Record<string, JsonValue>;
+}
+/** Synthetic result produced without crossing the external tool-effect boundary. */
+export interface ImmediateToolOutcome {
+    kind: "immediate";
+    toolCall: AgentToolCall;
+    result: AgentToolResult<unknown>;
+    isError: true;
+    terminate: boolean;
+}
+/** Aggregated decision from the before-tool hook pipeline. */
+export interface BeforeToolDecision {
+    args?: Record<string, JsonValue>;
+    block?: {
+        reason: string;
+        terminate?: boolean;
+    };
+}
+/** A prepared call cleared for durable intent publication and execution. */
+export interface ClearedToolCall<TContext extends object | undefined> {
+    toolCall: AgentToolCall;
+    tool: AgentHarnessTool<TContext>;
+    args: Record<string, JsonValue>;
+}
+/** Raw phase-two tool output before after-tool patching. */
+export interface ExecutedToolCall {
+    result: AgentToolResult<unknown>;
+    isError: boolean;
+}
+/** Aggregated patch from the after-tool hook pipeline. */
+export interface AfterToolPatch {
+    content?: AgentToolResult<unknown>["content"];
+    details?: JsonValue;
+    isError?: boolean;
+    usage?: AgentToolResult<unknown>["usage"];
+    terminate?: boolean;
+}
+/** Final tool output ready to become a durable tool-result message. */
+export interface FinalizedToolCall {
+    toolCall: AgentToolCall;
+    result: AgentToolResult<unknown>;
+    isError: boolean;
+    terminate: boolean;
+}
+/** Resolve a tool, apply its deterministic argument preparation, and validate the result. */
+export declare function andorraPrepareToolCall<TContext extends object | undefined>(call: AgentToolCall, tools: AgentHarnessTool<TContext>[]): PreparedToolCall<TContext> | ImmediateToolOutcome;
+/** Apply an explicit hook decision and revalidate replacement arguments. */
+export declare function andorraApplyBeforeToolDecision<TContext extends object | undefined>(prepared: PreparedToolCall<TContext>, decision: BeforeToolDecision | undefined): ClearedToolCall<TContext> | ImmediateToolOutcome;
+/** Execute one cleared external tool effect, converting expected tool throws to error output. */
+export declare function andorraExecuteToolCall<TContext extends object | undefined>(call: ClearedToolCall<TContext>, gate: Gate, onUpdate: AgentHarnessToolUpdateCallback<unknown>, toolContext: TContext, invocation: AgentHarnessToolInvocation, context: Context): Promise<ExecutedToolCall>;
+/** Apply an after-tool patch field by field. */
+export declare function andorraFinalizeToolCall<TContext extends object | undefined>(call: ClearedToolCall<TContext>, executed: ExecutedToolCall, patch: AfterToolPatch | undefined): FinalizedToolCall;
+/** Reconstruct the canonical tool result represented by a staged transcript message. */
+export declare function andorraToolResultFromMessage(message: ToolResultMessage, terminate: boolean): AgentToolResult;
+/** Convert finalized tool output to the provider-facing transcript message. */
+export declare function andorraCreateToolResultMessage(call: FinalizedToolCall): ToolResultMessage;

package/dist/vendor/engine/runtime/agent/harness/execution/tools.js

@@ -0,0 +1,118 @@
+import { andorraValidateToolArguments } from "../../../ai/index.js";
+import { andorraWithAbortSignal } from "../context.js";
+function andorraCreateErrorToolResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        details: undefined,
+    };
+}
+function andorraImmediateError(toolCall, message, terminate = false) {
+    return {
+        kind: "immediate",
+        toolCall,
+        result: andorraCreateErrorToolResult(message),
+        isError: true,
+        terminate,
+    };
+}
+/** Resolve a tool, apply its deterministic argument preparation, and validate the result. */
+export function andorraPrepareToolCall(call, tools) {
+    const tool = tools.find((candidate) => candidate.name === call.name);
+    if (!tool) {
+        return andorraImmediateError(call, `Tool ${JSON.stringify(call.name)} is unavailable`);
+    }
+    try {
+        const preparedArguments = tool.prepareArguments ? tool.prepareArguments(call.arguments) : call.arguments;
+        const preparedCall = preparedArguments === call.arguments
+            ? call
+            : { ...call, arguments: preparedArguments };
+        const args = andorraValidateToolArguments(tool, preparedCall);
+        return { toolCall: call, tool, args };
+    }
+    catch (error) {
+        return andorraImmediateError(call, error instanceof Error ? error.message : String(error));
+    }
+}
+/** Apply an explicit hook decision and revalidate replacement arguments. */
+export function andorraApplyBeforeToolDecision(prepared, decision) {
+    if (decision?.block) {
+        return andorraImmediateError(prepared.toolCall, decision.block.reason, decision.block.terminate === true);
+    }
+    if (!decision?.args) {
+        return { toolCall: prepared.toolCall, tool: prepared.tool, args: prepared.args };
+    }
+    try {
+        const validatedArgs = andorraValidateToolArguments(prepared.tool, {
+            ...prepared.toolCall,
+            arguments: decision.args,
+        });
+        return { toolCall: prepared.toolCall, tool: prepared.tool, args: validatedArgs };
+    }
+    catch (error) {
+        return andorraImmediateError(prepared.toolCall, error instanceof Error ? error.message : String(error));
+    }
+}
+/** Execute one cleared external tool effect, converting expected tool throws to error output. */
+export function andorraExecuteToolCall(call, gate, onUpdate, toolContext, invocation, context) {
+    let acceptingUpdates = true;
+    return gate.admit(async () => {
+        const admittedContext = andorraWithAbortSignal(gate.signal, context);
+        admittedContext.abortSignal?.throwIfAborted();
+        try {
+            const result = await call.tool.execute(call.toolCall.id, call.args, (partial, options) => {
+                if (acceptingUpdates)
+                    onUpdate(partial, options);
+            }, toolContext, invocation, admittedContext);
+            return { result, isError: false };
+        }
+        catch (error) {
+            return {
+                result: andorraCreateErrorToolResult(error instanceof Error ? error.message : String(error)),
+                isError: true,
+            };
+        }
+        finally {
+            acceptingUpdates = false;
+        }
+    });
+}
+/** Apply an after-tool patch field by field. */
+export function andorraFinalizeToolCall(call, executed, patch) {
+    const result = patch
+        ? {
+            ...executed.result,
+            content: patch.content === undefined ? executed.result.content : patch.content,
+            details: patch.details === undefined ? executed.result.details : patch.details,
+            usage: patch.usage === undefined ? executed.result.usage : patch.usage,
+            terminate: patch.terminate === undefined ? executed.result.terminate : patch.terminate,
+        }
+        : executed.result;
+    return {
+        toolCall: call.toolCall,
+        result,
+        isError: patch?.isError ?? executed.isError,
+        terminate: result.terminate === true,
+    };
+}
+/** Reconstruct the canonical tool result represented by a staged transcript message. */
+export function andorraToolResultFromMessage(message, terminate) {
+    return {
+        content: message.content,
+        details: message.details,
+        ...(message.usage === undefined ? {} : { usage: message.usage }),
+        ...(terminate ? { terminate: true } : {}),
+    };
+}
+/** Convert finalized tool output to the provider-facing transcript message. */
+export function andorraCreateToolResultMessage(call) {
+    return {
+        role: "toolResult",
+        toolCallId: call.toolCall.id,
+        toolName: call.toolCall.name,
+        content: call.result.content ?? [],
+        ...(call.result.details === undefined ? {} : { details: call.result.details }),
+        ...(call.result.usage === undefined ? {} : { usage: call.result.usage }),
+        isError: call.isError,
+        timestamp: Date.now(),
+    };
+}

package/dist/vendor/engine/runtime/agent/harness/hooks.d.ts

@@ -0,0 +1,37 @@
+import type { HookHandler, HookInvocation, HookMap, HookName, Hooks } from "./agent-harness.js";
+import { type Context } from "./context.js";
+import type { Gate } from "./execution/effect-gate.js";
+import type { AgentHarnessStreamOptions, AgentHarnessStreamOptionsPatch } from "./types.js";
+type HookErrorReporter = (error: Error, hook: HookName, lane: string, context: Context) => void | Promise<void>;
+/** Ordered harness hook registry and aggregate runner. */
+export declare class AndorraHookRegistry implements Hooks {
+    private readonly registrations;
+    private readonly reportError;
+    private closedError;
+    constructor(reportError: HookErrorReporter);
+    on<TName extends HookName>(name: TName, handler: HookHandler<TName>, options?: {
+        id?: string;
+    }): () => void;
+    has(name: HookName): boolean;
+    /** Invoke one accepted-operation aggregate after synchronously passing its effect gate. */
+    runWithGate<TName extends HookName>(name: TName, event: HookInvocation<TName>, gate: Gate, context: Context): Promise<HookMap[TName]["result"]>;
+    /** Invoke a tool-hook aggregate with one telemetry span per registered handler. */
+    runToolWithGate<TName extends "before_tool" | "after_tool">(name: TName, event: HookInvocation<TName>, gate: Gate, context: Context): Promise<HookMap[TName]["result"]>;
+    close(error: Error): void;
+    private runAdmitted;
+    private aggregate;
+    private beforeRun;
+    private beforeTool;
+    private transformContext;
+    private beforeRequest;
+    private beforePayload;
+    private afterResponse;
+    private afterTool;
+    private firstStructural;
+    private invokeToolRegistration;
+    private registrationsFor;
+    private invokeAllFailClosed;
+    private invokeAll;
+}
+export declare function andorraApplyStreamOptionsPatch(base: AgentHarnessStreamOptions, patch: AgentHarnessStreamOptionsPatch): AgentHarnessStreamOptions;
+export {};

package/dist/vendor/engine/runtime/agent/harness/hooks.js

@@ -0,0 +1,405 @@
+import { andorraWithAbortSignal } from "./context.js";
+import { andorraStartHarnessSpan } from "./telemetry.js";
+/** Ordered harness hook registry and aggregate runner. */
+export class AndorraHookRegistry {
+    registrations = new Map();
+    reportError;
+    closedError;
+    constructor(reportError) {
+        this.reportError = reportError;
+    }
+    on(name, handler, options = {}) {
+        if (this.closedError !== undefined)
+            throw this.closedError;
+        const registrations = this.registrations.get(name) ?? [];
+        const registration = {
+            ...(options.id === undefined ? {} : { id: options.id }),
+            handler: (event, context) => handler(event, context),
+        };
+        registrations.push(registration);
+        this.registrations.set(name, registrations);
+        return () => {
+            const index = registrations.indexOf(registration);
+            if (index !== -1)
+                registrations.splice(index, 1);
+        };
+    }
+    has(name) {
+        return (this.registrations.get(name)?.length ?? 0) !== 0;
+    }
+    /** Invoke one accepted-operation aggregate after synchronously passing its effect gate. */
+    runWithGate(name, event, gate, context) {
+        return gate.admit(() => {
+            const admittedContext = andorraWithAbortSignal(gate.signal, context);
+            admittedContext.abortSignal?.throwIfAborted();
+            return this.runAdmitted(name, event, admittedContext);
+        });
+    }
+    /** Invoke a tool-hook aggregate with one telemetry span per registered handler. */
+    runToolWithGate(name, event, gate, context) {
+        return gate.admit(() => {
+            const admittedContext = andorraWithAbortSignal(gate.signal, context);
+            admittedContext.abortSignal?.throwIfAborted();
+            return (name === "before_tool"
+                ? this.beforeTool(event, admittedContext)
+                : this.afterTool(event, admittedContext));
+        });
+    }
+    close(error) {
+        this.closedError ??= error;
+    }
+    async runAdmitted(name, event, context) {
+        if (this.closedError !== undefined)
+            throw this.closedError;
+        const result = await this.aggregate(name, event, context);
+        return result;
+    }
+    async aggregate(name, event, context) {
+        switch (name) {
+            case "before_run":
+                return this.beforeRun(event, context);
+            case "before_drive":
+                await this.invokeAllFailClosed(name, event, context);
+                return undefined;
+            case "before_run_end": {
+                let followUp;
+                await this.invokeAll(name, event, (value) => {
+                    const result = value;
+                    if (result?.followUp !== undefined)
+                        followUp = result.followUp;
+                }, context);
+                return followUp === undefined ? undefined : { followUp };
+            }
+            case "transform_context":
+                return this.transformContext(event, context);
+            case "before_request":
+                return this.beforeRequest(event, context);
+            case "before_payload":
+                return this.beforePayload(event, context);
+            case "after_response":
+                return this.afterResponse(event, context);
+            case "before_tool":
+                return this.beforeTool(event, context);
+            case "after_tool":
+                return this.afterTool(event, context);
+            case "before_compaction":
+                return this.firstStructural(name, event, "compaction", context);
+            case "before_navigation":
+                return this.firstStructural(name, event, "summary", context);
+        }
+    }
+    async beforeRun(event, context) {
+        let prompt = event.prompt;
+        let injected = [];
+        for (const registration of this.registrationsFor("before_run")) {
+            try {
+                const result = (await registration.handler({ ...event, prompt }, context));
+                if (result?.messages !== undefined) {
+                    injected = [...injected, ...result.messages];
+                    prompt = [...prompt, ...result.messages];
+                }
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), "before_run", event.lane, context);
+            }
+        }
+        return injected.length === 0 ? undefined : { messages: injected };
+    }
+    async beforeTool(event, context) {
+        let args = event.args;
+        let block;
+        for (const registration of this.registrationsFor("before_tool")) {
+            try {
+                const result = (await this.invokeToolRegistration("before_tool", registration, { ...event, args }, context));
+                if (result?.args !== undefined)
+                    args = result.args;
+                if (result?.block !== undefined) {
+                    block = result.block;
+                    break;
+                }
+            }
+            catch (error) {
+                const normalized = error instanceof Error ? error : new Error(String(error));
+                await this.reportError(normalized, "before_tool", event.lane, context);
+                block = { reason: normalized.message };
+                break;
+            }
+        }
+        return {
+            ...(args === event.args ? {} : { args }),
+            ...(block === undefined ? {} : { block }),
+        };
+    }
+    async transformContext(event, context) {
+        let messages = event.messages;
+        let systemPrompt = event.systemPrompt;
+        for (const registration of this.registrationsFor("transform_context")) {
+            try {
+                const result = (await registration.handler({
+                    ...event,
+                    messages,
+                    systemPrompt,
+                }, context));
+                if (result?.messages !== undefined)
+                    messages = result.messages;
+                if (result?.systemPrompt !== undefined)
+                    systemPrompt = result.systemPrompt;
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), "transform_context", event.lane, context);
+            }
+        }
+        return { messages, systemPrompt };
+    }
+    async beforeRequest(event, context) {
+        let streamOptions = event.streamOptions;
+        let changed = false;
+        for (const registration of this.registrationsFor("before_request")) {
+            try {
+                const result = (await registration.handler({ ...event, streamOptions }, context));
+                if (result?.streamOptions !== undefined) {
+                    streamOptions = andorraApplyStreamOptionsPatch(streamOptions, result.streamOptions);
+                    changed = true;
+                }
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), "before_request", event.lane, context);
+            }
+        }
+        return changed ? { streamOptions: andorraCreateStreamOptionsPatch(event.streamOptions, streamOptions) } : undefined;
+    }
+    async beforePayload(event, context) {
+        let payload = event.payload;
+        for (const registration of this.registrationsFor("before_payload")) {
+            try {
+                const result = (await registration.handler({ ...event, payload }, context));
+                if (result?.payload !== undefined)
+                    payload = result.payload;
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), "before_payload", event.lane, context);
+            }
+        }
+        return { payload };
+    }
+    async afterResponse(event, context) {
+        let message = event.message;
+        for (const registration of this.registrationsFor("after_response")) {
+            try {
+                const result = (await registration.handler({ ...event, message }, context));
+                if (result?.message !== undefined)
+                    message = result.message;
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), "after_response", event.lane, context);
+            }
+        }
+        return { message };
+    }
+    async afterTool(event, context) {
+        let current = {
+            content: event.content,
+            details: event.details,
+            isError: event.isError,
+            usage: event.usage,
+        };
+        const aggregate = {};
+        for (const registration of this.registrationsFor("after_tool")) {
+            try {
+                const result = (await this.invokeToolRegistration("after_tool", registration, { ...event, ...current }, context));
+                if (result === undefined)
+                    continue;
+                if (result.content !== undefined)
+                    aggregate.content = result.content;
+                if (result.details !== undefined)
+                    aggregate.details = result.details;
+                if (result.isError !== undefined)
+                    aggregate.isError = result.isError;
+                if (result.usage !== undefined)
+                    aggregate.usage = result.usage;
+                if (result.terminate !== undefined)
+                    aggregate.terminate = result.terminate;
+                current = {
+                    content: result.content === undefined ? current.content : result.content,
+                    details: result.details === undefined ? current.details : result.details,
+                    isError: result.isError === undefined ? current.isError : result.isError,
+                    usage: result.usage === undefined ? current.usage : result.usage,
+                };
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), "after_tool", event.lane, context);
+            }
+        }
+        return Object.keys(aggregate).length === 0 ? undefined : aggregate;
+    }
+    async firstStructural(name, event, resultField, context) {
+        for (const registration of this.registrationsFor(name)) {
+            try {
+                const value = await registration.handler(event, context);
+                if (value === undefined || value === null || typeof value !== "object")
+                    continue;
+                const result = value;
+                if (result.decline === true && result[resultField] !== undefined) {
+                    await this.reportError(new Error(`${name} hook cannot return both decline and ${resultField}`), name, event.lane, context);
+                    continue;
+                }
+                if (result.decline === true || result[resultField] !== undefined)
+                    return value;
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), name, event.lane, context);
+            }
+        }
+        return undefined;
+    }
+    invokeToolRegistration(name, registration, event, context) {
+        return andorraStartHarnessSpan("pi.harness.hook", {
+            "pi.lane.name": event.lane,
+            "pi.operation.id": event.runId,
+            "pi.hook.name": name,
+            ...(registration.id === undefined ? {} : { "pi.hook.registration_id": registration.id }),
+        }, async (span, spanContext) => {
+            try {
+                const result = await registration.handler(event, spanContext);
+                const blocked = name === "before_tool" &&
+                    result !== null &&
+                    typeof result === "object" &&
+                    "block" in result &&
+                    result.block !== undefined;
+                span.setAttributes({ "pi.hook.outcome": blocked ? "blocked" : "completed" });
+                return result;
+            }
+            catch (error) {
+                span.setAttributes({ "pi.hook.outcome": "failed" });
+                span.setStatus({ status: "error" });
+                throw error;
+            }
+        }, context);
+    }
+    registrationsFor(name) {
+        return [...(this.registrations.get(name) ?? [])];
+    }
+    async invokeAllFailClosed(name, event, context) {
+        for (const registration of this.registrationsFor(name)) {
+            try {
+                await registration.handler(event, context);
+            }
+            catch (error) {
+                const normalized = error instanceof Error ? error : new Error(String(error));
+                await this.reportError(normalized, name, event.lane, context);
+                throw normalized;
+            }
+        }
+    }
+    async invokeAll(name, event, apply, context) {
+        for (const registration of this.registrationsFor(name)) {
+            try {
+                apply(await registration.handler(event, context));
+            }
+            catch (error) {
+                await this.reportError(error instanceof Error ? error : new Error(String(error)), name, event.lane, context);
+            }
+        }
+    }
+}
+export function andorraApplyStreamOptionsPatch(base, patch) {
+    const next = { ...base };
+    for (const key of [
+        "transport",
+        "timeoutMs",
+        "maxRetries",
+        "maxRetryDelayMs",
+        "cacheRetention",
+        "deferred",
+    ]) {
+        if (!(key in patch))
+            continue;
+        const value = patch[key];
+        if (value === undefined)
+            delete next[key];
+        else
+            Object.assign(next, { [key]: value });
+    }
+    if ("headers" in patch) {
+        if (patch.headers === undefined)
+            delete next.headers;
+        else {
+            const headers = { ...next.headers };
+            for (const [key, value] of Object.entries(patch.headers)) {
+                if (value === undefined)
+                    delete headers[key];
+                else
+                    headers[key] = value;
+            }
+            next.headers = headers;
+        }
+    }
+    if ("metadata" in patch) {
+        if (patch.metadata === undefined)
+            delete next.metadata;
+        else {
+            const metadata = { ...next.metadata };
+            for (const [key, value] of Object.entries(patch.metadata)) {
+                if (value === undefined)
+                    delete metadata[key];
+                else
+                    metadata[key] = value;
+            }
+            next.metadata = metadata;
+        }
+    }
+    return next;
+}
+function andorraCreateStreamOptionsPatch(base, value) {
+    const patch = {};
+    for (const key of [
+        "transport",
+        "timeoutMs",
+        "maxRetries",
+        "maxRetryDelayMs",
+        "cacheRetention",
+        "deferred",
+    ]) {
+        if (base[key] !== value[key])
+            Object.assign(patch, { [key]: value[key] });
+    }
+    if (base.headers !== value.headers) {
+        if (value.headers === undefined)
+            patch.headers = undefined;
+        else {
+            const headers = {};
+            for (const key of Object.keys(base.headers ?? {})) {
+                if (!(key in value.headers))
+                    headers[key] = undefined;
+            }
+            for (const [key, header] of Object.entries(value.headers)) {
+                if (base.headers?.[key] !== header)
+                    headers[key] = header;
+            }
+            if (base.headers === undefined && Object.keys(headers).length === 0)
+                patch.headers = {};
+            else if (Object.keys(headers).length !== 0)
+                patch.headers = headers;
+        }
+    }
+    if (base.metadata !== value.metadata) {
+        if (value.metadata === undefined)
+            patch.metadata = undefined;
+        else {
+            const metadata = {};
+            for (const key of Object.keys(base.metadata ?? {})) {
+                if (!(key in value.metadata))
+                    metadata[key] = undefined;
+            }
+            for (const [key, metadataValue] of Object.entries(value.metadata)) {
+                if (base.metadata?.[key] !== metadataValue)
+                    metadata[key] = metadataValue;
+            }
+            if (base.metadata === undefined && Object.keys(metadata).length === 0)
+                patch.metadata = {};
+            else if (Object.keys(metadata).length !== 0)
+                patch.metadata = metadata;
+        }
+    }
+    return patch;
+}

package/dist/vendor/engine/runtime/agent/harness/messages.d.ts

@@ -0,0 +1,50 @@
+import type { ImageContent, Message, TextContent } from "../../ai/index.js";
+import type { AgentMessage } from "../types.js";
+export declare const COMPACTION_SUMMARY_PREFIX = "The conversation history before this point was compacted into the following summary:\n\n<summary>\n";
+export declare const COMPACTION_SUMMARY_SUFFIX = "\n</summary>";
+export declare const BRANCH_SUMMARY_PREFIX = "The following is a summary of a branch that this conversation came back from:\n\n<summary>\n";
+export declare const BRANCH_SUMMARY_SUFFIX = "</summary>";
+export interface BashExecutionMessage {
+    role: "bashExecution";
+    command: string;
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    fullOutputPath?: string;
+    timestamp: number;
+    excludeFromContext?: boolean;
+}
+export interface CustomMessage<T = unknown> {
+    role: "custom";
+    customType: string;
+    content: string | (TextContent | ImageContent)[];
+    display: boolean;
+    details?: T;
+    timestamp: number;
+}
+export interface BranchSummaryMessage {
+    role: "branchSummary";
+    summary: string;
+    fromId: string | null;
+    timestamp: number;
+}
+export interface CompactionSummaryMessage {
+    role: "compactionSummary";
+    summary: string;
+    tokensBefore: number;
+    timestamp: number;
+}
+declare module "../types.js" {
+    interface CustomAgentMessages {
+        bashExecution: BashExecutionMessage;
+        custom: CustomMessage;
+        branchSummary: BranchSummaryMessage;
+        compactionSummary: CompactionSummaryMessage;
+    }
+}
+export declare function andorraBashExecutionToText(msg: BashExecutionMessage): string;
+export declare function andorraCreateBranchSummaryMessage(summary: string, fromId: string | null, timestamp: string | number): BranchSummaryMessage;
+export declare function andorraCreateCompactionSummaryMessage(summary: string, tokensBefore: number, timestamp: string | number): CompactionSummaryMessage;
+export declare function andorraCreateCustomMessage(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details: unknown | undefined, timestamp: string | number): CustomMessage;
+export declare function andorraConvertToLlm(messages: AgentMessage[]): Message[];