@schlenkr/ragents 0.1.5 → 0.1.6

package/packages/agent/dist/core/tools/output-accumulator.d.ts

@@ -0,0 +1,58 @@
+import { type TruncationResult } from "./truncate.ts";
+export interface OutputAccumulatorOptions {
+    maxLines?: number;
+    maxBytes?: number;
+    /** Lines longer than this are shortened in snapshots and marked; the temp file keeps them whole. */
+    maxLineChars?: number;
+    tempFilePrefix?: string;
+}
+export interface OutputSnapshot {
+    content: string;
+    truncation: TruncationResult;
+    fullOutputPath?: string;
+}
+/**
+ * Incrementally tracks streaming output with bounded memory.
+ *
+ * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded
+ * tail for display snapshots, and opens a temp file when the full output needs
+ * to be preserved.
+ */
+export declare class OutputAccumulator {
+    private readonly maxLines;
+    private readonly maxBytes;
+    private readonly maxLineChars;
+    private readonly maxRollingBytes;
+    private readonly tempFilePrefix;
+    private readonly decoder;
+    private rawChunks;
+    private tailText;
+    private tailBytes;
+    private tailStartsAtLineBoundary;
+    private totalRawBytes;
+    private totalDecodedBytes;
+    private completedLines;
+    private totalLines;
+    private currentLineBytes;
+    private currentLineChars;
+    private longestLineChars;
+    private hasOpenLine;
+    private finished;
+    private tempFilePath;
+    private tempFileStream;
+    constructor(options?: OutputAccumulatorOptions);
+    append(data: Buffer): void;
+    finish(): void;
+    snapshot(options?: {
+        persistIfTruncated?: boolean;
+    }): OutputSnapshot;
+    closeTempFile(): Promise<void>;
+    getLastLineBytes(): number;
+    hasShortenedLines(): boolean;
+    private appendDecodedText;
+    private trimTail;
+    private getSnapshotText;
+    private shouldUseTempFile;
+    private ensureTempFile;
+}
+//# sourceMappingURL=output-accumulator.d.ts.map

package/packages/agent/dist/core/tools/path-utils.d.ts

@@ -0,0 +1,8 @@
+export declare function pathExists(filePath: string): Promise<boolean>;
+/**
+ * Resolve a path relative to the given cwd.
+ * Handles ~ expansion and absolute paths.
+ */
+export declare function resolveToCwd(filePath: string, cwd: string): string;
+export declare function resolveReadPathAsync(filePath: string, cwd: string): Promise<string>;
+//# sourceMappingURL=path-utils.d.ts.map

package/packages/agent/dist/core/tools/read.d.ts

@@ -0,0 +1,33 @@
+import { Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type TruncationResult } from "./truncate.ts";
+declare const readSchema: Type.TObject<{
+    path: Type.TString;
+    offset: Type.TOptional<Type.TNumber>;
+    limit: Type.TOptional<Type.TNumber>;
+}>;
+export interface ReadToolDetails {
+    truncation?: TruncationResult;
+    contentHash?: string;
+}
+/**
+ * Pluggable operations for the read tool.
+ * Override these to delegate file reading to remote systems (for example SSH).
+ */
+export interface ReadOperations {
+    /** Read file contents as a Buffer */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Check if file is readable (throw if not) */
+    access: (absolutePath: string) => Promise<void>;
+    /** Detect image MIME type, return null or undefined for non-images */
+    detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
+}
+export interface ReadToolOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+    /** Custom operations for file reading. Default: local filesystem */
+    operations?: ReadOperations;
+}
+export declare function createReadToolDefinition(cwd: string, options?: ReadToolOptions): ToolDefinition<typeof readSchema, ReadToolDetails | undefined>;
+export {};
+//# sourceMappingURL=read.d.ts.map

package/packages/agent/dist/core/tools/truncate.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Truncation is based on two independent limits - whichever is hit first wins:
+ * - Line limit (default: 2000 lines)
+ * - Byte limit (default: 50KB)
+ *
+ * Never returns partial lines (except bash tail truncation edge case).
+ */
+export declare const DEFAULT_MAX_LINES = 2000;
+export declare const DEFAULT_MAX_BYTES: number;
+export interface TruncationResult {
+    /** The truncated content */
+    content: string;
+    /** Whether truncation occurred */
+    truncated: boolean;
+    /** Which limit was hit: "lines", "bytes", or null if not truncated */
+    truncatedBy: "lines" | "bytes" | null;
+    /** Total number of lines in the original content */
+    totalLines: number;
+    /** Total number of bytes in the original content */
+    totalBytes: number;
+    /** Number of complete lines in the truncated output */
+    outputLines: number;
+    /** Number of bytes in the truncated output */
+    outputBytes: number;
+    /** Whether the last line was partially truncated (only for tail truncation edge case) */
+    lastLinePartial: boolean;
+    /** Whether the first line exceeded the byte limit (for head truncation) */
+    firstLineExceedsLimit: boolean;
+    /** The max lines limit that was applied */
+    maxLines: number;
+    /** The max bytes limit that was applied */
+    maxBytes: number;
+}
+export interface TruncationOptions {
+    /** Maximum number of lines (default: 2000) */
+    maxLines?: number;
+    /** Maximum number of bytes (default: 50KB) */
+    maxBytes?: number;
+}
+/**
+ * Format bytes as human-readable size.
+ */
+export declare function formatSize(bytes: number): string;
+/**
+ * Truncate content from the head (keep first N lines/bytes).
+ * Suitable for file reads where you want to see the beginning.
+ *
+ * Never returns partial lines. If first line exceeds byte limit,
+ * returns empty content with firstLineExceedsLimit=true.
+ */
+export declare function truncateHead(content: string, options?: TruncationOptions): TruncationResult;
+/**
+ * Truncate content from the tail (keep last N lines/bytes).
+ * Suitable for bash output where you want to see the end (errors, final results).
+ *
+ * May return partial first line if the last line of original content exceeds byte limit.
+ */
+export declare function truncateTail(content: string, options?: TruncationOptions): TruncationResult;
+//# sourceMappingURL=truncate.d.ts.map

package/packages/agent/dist/core/tools/write.d.ts

@@ -0,0 +1,23 @@
+import { Type } from "typebox";
+import type { ToolDefinition } from "../extensions/types.ts";
+declare const writeSchema: Type.TObject<{
+    path: Type.TString;
+    content: Type.TString;
+}>;
+/**
+ * Pluggable operations for the write tool.
+ * Override these to delegate file writing to remote systems (for example SSH).
+ */
+export interface WriteOperations {
+    /** Write content to a file */
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    /** Create directory recursively */
+    mkdir: (dir: string) => Promise<void>;
+}
+export interface WriteToolOptions {
+    /** Custom operations for file writing. Default: local filesystem */
+    operations?: WriteOperations;
+}
+export declare function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition<typeof writeSchema, undefined>;
+export {};
+//# sourceMappingURL=write.d.ts.map

package/packages/agent/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { AgentSession } from "./core/agent-session.ts";
+export type { ExtensionAPI, ExtensionContext, ExtensionError, InlineExtension, ToolDefinition } from "./core/extensions/index.ts";
+export { defineTool } from "./core/extensions/index.ts";
+export { aliasedModel, type ModelAlias, ModelRuntime } from "./core/model-runtime.ts";
+export { DefaultResourceLoader } from "./core/resource-loader.ts";
+export { type AgentSessionRuntime, type CreateAgentSessionRuntimeFactory, createAgentSession, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, } from "./core/sdk.ts";
+export { CURRENT_SESSION_VERSION, type SessionEntry, SessionManager } from "./core/session-manager.ts";
+export type { AgentSettingsInput } from "./core/agent-settings.ts";
+export type { Skill } from "./core/skills.ts";
+export { type BashOperations, createBashToolDefinition, createEditToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "./core/tools/index.ts";
+export { parseFrontmatter, stripFrontmatter } from "./utils/frontmatter.ts";
+export { getShellConfig, killProcessTree, type ShellConfig } from "./utils/shell.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/dist/loop/agent-loop.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Agent loop that works with AgentMessage throughout.
+ * Transforms to Message[] only at the LLM call boundary.
+ */
+import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.ts";
+export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
+/** User message that follows a stop without text and without tool call, typically reasoning-only output. */
+export declare const EMPTY_RESPONSE_NUDGE = "Deine Antwort enthielt weder Text noch Werkzeugaufruf. Antworte jetzt mit dem n\u00E4chsten Werkzeugaufruf oder Deiner Antwort.";
+/** Error message of the assistant message that ends the loop after the nudge stayed unanswered. */
+export declare const EMPTY_RESPONSE_FAILURE = "Modell lieferte zweimal eine leere Antwort.";
+export declare function runAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;
+export declare function runAgentLoopContinue(context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;
+//# sourceMappingURL=agent-loop.d.ts.map

package/packages/agent/dist/loop/agent.d.ts

@@ -0,0 +1,103 @@
+import { type ImageContent, type Message, type ThinkingBudgets, type Transport } from "@ragents/ai";
+import type { AfterToolCallContext, AfterToolCallResult, AgentEvent, AgentLoopConfig, AgentLoopTurnUpdate, AgentMessage, AgentState, PrepareNextTurnContext, StreamFn, ToolExecutionMode } from "./types.ts";
+/** Options for constructing an {@link Agent}. */
+export interface AgentOptions {
+    initialState?: Partial<Omit<AgentState, "pendingToolCalls" | "isStreaming" | "streamingMessage" | "errorMessage">>;
+    convertToLlm?: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
+    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
+    streamFn?: StreamFn;
+    getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
+    formatUnknownToolError?: AgentLoopConfig["formatUnknownToolError"];
+    afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
+    prepareNextTurn?: (signal?: AbortSignal) => Promise<AgentLoopTurnUpdate | undefined> | AgentLoopTurnUpdate | undefined;
+    prepareNextTurnWithContext?: (context: PrepareNextTurnContext, signal?: AbortSignal) => Promise<AgentLoopTurnUpdate | undefined> | AgentLoopTurnUpdate | undefined;
+    steeringSource?: AgentLoopConfig["getSteeringMessages"];
+    sessionId?: string;
+    thinkingBudgets?: ThinkingBudgets;
+    transport?: Transport;
+    maxRetryDelayMs?: number;
+    toolExecution?: ToolExecutionMode;
+}
+/**
+ * Stateful wrapper around the low-level agent loop.
+ *
+ * `Agent` owns the current transcript, emits lifecycle events, executes tools,
+ * and polls its steering source before each model request.
+ */
+export declare class Agent {
+    private _state;
+    private readonly listeners;
+    convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
+    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
+    streamFn: StreamFn;
+    getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
+    formatUnknownToolError?: AgentLoopConfig["formatUnknownToolError"];
+    afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
+    prepareNextTurn?: (signal?: AbortSignal) => Promise<AgentLoopTurnUpdate | undefined> | AgentLoopTurnUpdate | undefined;
+    prepareNextTurnWithContext?: (context: PrepareNextTurnContext, signal?: AbortSignal) => Promise<AgentLoopTurnUpdate | undefined> | AgentLoopTurnUpdate | undefined;
+    private activeRun?;
+    /** Session identifier forwarded to providers for cache-aware backends. */
+    sessionId?: string;
+    /** Optional per-level thinking token budgets forwarded to the stream function. */
+    thinkingBudgets?: ThinkingBudgets;
+    /** Preferred transport forwarded to the stream function. */
+    transport: Transport;
+    /** Optional cap for provider-requested retry delays. */
+    maxRetryDelayMs?: number;
+    /** Tool execution strategy for assistant messages that contain multiple tool calls. */
+    toolExecution: ToolExecutionMode;
+    /** Messages to inject into the running prompt before its next model request. */
+    steeringSource?: AgentLoopConfig["getSteeringMessages"];
+    constructor(options?: AgentOptions);
+    /**
+     * Subscribe to agent lifecycle events.
+     *
+     * Listener promises are awaited in subscription order and are included in
+     * the current run's settlement. Listeners also receive the active abort
+     * signal for the current run.
+     *
+     * `agent_end` is the final emitted event for a run, but the agent does not
+     * become idle until all awaited listeners for that event have settled.
+     */
+    subscribe(listener: (event: AgentEvent, signal: AbortSignal) => Promise<void> | void): () => void;
+    /**
+     * Current agent state.
+     *
+     * Assigning `state.tools` or `state.messages` copies the provided top-level array.
+     */
+    get state(): AgentState;
+    /** Active abort signal for the current run, if any. */
+    get signal(): AbortSignal | undefined;
+    /** Abort the current run, if one is active. */
+    abort(): void;
+    /**
+     * Resolve when the current run and all awaited event listeners have finished.
+     *
+     * This resolves after `agent_end` listeners settle.
+     */
+    waitForIdle(): Promise<void>;
+    /** Clear transcript state and runtime state. */
+    reset(): void;
+    /** Start a new prompt from text, a single message, or a batch of messages. */
+    prompt(message: AgentMessage | AgentMessage[]): Promise<void>;
+    prompt(input: string, images?: ImageContent[]): Promise<void>;
+    /** Continue from the current transcript. The last message must be a user or tool-result message. */
+    continue(): Promise<void>;
+    private normalizePromptInput;
+    private runPromptMessages;
+    private runContinuation;
+    private createContextSnapshot;
+    private createLoopConfig;
+    private runWithLifecycle;
+    private handleRunFailure;
+    private finishRun;
+    /**
+     * Reduce internal state for a loop event, then await listeners.
+     *
+     * `agent_end` only means no further loop events will be emitted. The run is
+     * considered idle later, after all awaited listeners for `agent_end` finish
+     * and `finishRun()` clears runtime-owned state.
+     */
+    private processEvents;
+}
+//# sourceMappingURL=agent.d.ts.map

package/packages/agent/dist/loop/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./agent.ts";
+export * from "./agent-loop.ts";
+export * from "./types.ts";
+export { uuidv7 } from "./uuid.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/dist/loop/types.d.ts

@@ -0,0 +1,333 @@
+import type { Api, AssistantMessage, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Message, Model, SimpleStreamOptions, TextContent, Tool, ToolResultMessage } from "@ragents/ai";
+import type { Static, TSchema } from "typebox";
+/**
+ * Stream function used by the agent loop. `Models.streamSimple` satisfies
+ * this shape.
+ *
+ * Contract:
+ * - Must not throw or return a rejected promise for request/model/runtime failures.
+ * - Must return an AssistantMessageEventStream.
+ * - Failures must be encoded in the returned stream via protocol events and a
+ *   final AssistantMessage with stopReason "error" or "aborted" and errorMessage.
+ */
+export type StreamFn = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream | Promise<AssistantMessageEventStream>;
+/**
+ * Configuration for how tool calls from a single assistant message are executed.
+ *
+ * - "sequential": each tool call is prepared, executed, and finalized before the next one starts.
+ * - "parallel": tool calls are prepared sequentially, then allowed tools execute concurrently.
+ *   `tool_execution_end` is emitted in tool completion order after each tool is finalized,
+ *   while tool-result message artifacts are emitted later in assistant source order.
+ */
+export type ToolExecutionMode = "sequential" | "parallel";
+/** A single tool call content block emitted by an assistant message. */
+export type AgentToolCall = Extract<AssistantMessage["content"][number], {
+    type: "toolCall";
+}>;
+/**
+ * Partial override returned from `afterToolCall`.
+ *
+ * Merge semantics are field-by-field:
+ * - `content`: if provided, replaces the tool result content array in full
+ * - `details`: if provided, replaces the tool result details value in full
+ * - `isError`: if provided, replaces the tool result error flag
+ * - `terminate`: if provided, replaces the early-termination hint
+ *
+ * Omitted fields keep the original executed tool result values.
+ * There is no deep merge for `content` or `details`.
+ */
+export interface AfterToolCallResult {
+    content?: (TextContent | ImageContent)[];
+    details?: unknown;
+    isError?: boolean;
+    /**
+     * Hint that the agent should stop after the current tool batch.
+     * Early termination only happens when every finalized tool result in the batch sets this to true.
+     */
+    terminate?: boolean;
+}
+/** Context passed to `afterToolCall`. */
+export interface AfterToolCallContext {
+    /** The assistant message that requested the tool call. */
+    assistantMessage: AssistantMessage;
+    /** The raw tool call block from `assistantMessage.content`. */
+    toolCall: AgentToolCall;
+    /** Validated tool arguments for the target tool schema. */
+    args: unknown;
+    /** The executed tool result before any `afterToolCall` overrides are applied. */
+    result: AgentToolResult<any>;
+    /** Whether the executed tool result is currently treated as an error. */
+    isError: boolean;
+    /** Current agent context at the time the tool call is finalized. */
+    context: AgentContext;
+}
+/** Context passed to `shouldStopAfterTurn`. */
+export interface ShouldStopAfterTurnContext {
+    /** The assistant message that completed the turn. */
+    message: AssistantMessage;
+    /** Tool result messages passed to the preceding `turn_end` event. */
+    toolResults: ToolResultMessage[];
+    /** Current agent context after the turn's assistant message and tool results have been appended. */
+    context: AgentContext;
+    /** Messages that this loop invocation will return if it exits at this point. Prompt runs include the initial prompt messages; continuation runs do not include pre-existing context messages. */
+    newMessages: AgentMessage[];
+}
+/** Replacement runtime state used by the agent loop before starting another provider request. */
+export interface AgentLoopTurnUpdate {
+    /** Context for the next provider request. */
+    context?: AgentContext;
+    /** Model for the next provider request. */
+    model?: Model<any>;
+    /** Thinking level for the next provider request. */
+    thinkingLevel?: ThinkingLevel;
+}
+export interface PrepareNextTurnContext extends ShouldStopAfterTurnContext {
+}
+export interface AgentLoopConfig extends SimpleStreamOptions {
+    model: Model<any>;
+    /**
+     * Converts AgentMessage[] to LLM-compatible Message[] before each LLM call.
+     *
+     * Each AgentMessage must be converted to a UserMessage, AssistantMessage, or ToolResultMessage
+     * that the LLM can understand. AgentMessages that cannot be converted (e.g., UI-only notifications,
+     * status messages) should be filtered out.
+     *
+     * Contract: must not throw or reject. Return a safe fallback value instead.
+     * Throwing interrupts the low-level agent loop without producing a normal event sequence.
+     *
+     * @example
+     * ```typescript
+     * convertToLlm: (messages) => messages.flatMap(m => {
+     *   if (m.role === "custom") {
+     *     // Convert custom message to user message
+     *     return [{ role: "user", content: m.content, timestamp: m.timestamp }];
+     *   }
+     *   if (m.role === "notification") {
+     *     // Filter out UI-only messages
+     *     return [];
+     *   }
+     *   // Pass through standard LLM messages
+     *   return [m];
+     * })
+     * ```
+     */
+    convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
+    /**
+     * Optional transform applied to the context before `convertToLlm`.
+     *
+     * Use this for operations that work at the AgentMessage level:
+     * - Context window management (pruning old messages)
+     * - Injecting context from external sources
+     *
+     * Contract: must not throw or reject. Return the original messages or another
+     * safe fallback value instead.
+     *
+     * @example
+     * ```typescript
+     * transformContext: async (messages) => {
+     *   if (estimateTokens(messages) > MAX_TOKENS) {
+     *     return pruneOldMessages(messages);
+     *   }
+     *   return messages;
+     * }
+     * ```
+     */
+    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
+    /**
+     * Resolves an API key dynamically for each LLM call.
+     *
+     * Useful for short-lived OAuth tokens (e.g., GitHub Copilot) that may expire
+     * during long-running tool execution phases.
+     *
+     * Contract: must not throw or reject. Return undefined when no key is available.
+     */
+    getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
+    /**
+     * Called after each turn fully completes and `turn_end` has been emitted.
+     *
+     * If it returns true, the loop emits `agent_end` and exits before polling steering messages,
+     * without starting another LLM call. The current assistant response and any tool executions finish normally.
+     *
+     * Use this to request a graceful stop after the current turn, e.g. before context gets too full.
+     *
+     * Contract: must not throw or reject. Throwing interrupts the low-level agent loop without producing a normal event sequence.
+     */
+    shouldStopAfterTurn?: (context: ShouldStopAfterTurnContext) => boolean | Promise<boolean>;
+    /**
+     * Called after `turn_end` and before the loop decides whether another provider request should start.
+     * Return replacement context/model/thinking state to affect the next turn in this run.
+     * Return undefined to keep using the current context/config.
+     */
+    prepareNextTurn?: (context: PrepareNextTurnContext) => AgentLoopTurnUpdate | undefined | Promise<AgentLoopTurnUpdate | undefined>;
+    /** Steering polled before the first model request and after each assistant turn; messages join the context, a rejection ends the run. */
+    getSteeringMessages?: () => Promise<AgentMessage[]>;
+    /**
+     * Tool execution mode.
+     * - "sequential": execute tool calls one by one
+     * - "parallel": preflight tool calls sequentially, then execute allowed tools concurrently;
+     *   emit `tool_execution_end` in tool completion order after each tool is finalized,
+     *   then emit tool-result message artifacts later in assistant source order
+     *
+     * Default: "parallel"
+     */
+    toolExecution?: ToolExecutionMode;
+    /** Customize an unavailable tool's error text; undefined keeps the default and execution stays blocked. */
+    formatUnknownToolError?: (toolName: string) => string | undefined;
+    /**
+     * Called after a tool finishes executing, before `tool_execution_end` and tool-result message events are emitted.
+     *
+     * Return an `AfterToolCallResult` to override parts of the executed tool result:
+     * - `content` replaces the full content array
+     * - `details` replaces the full details payload
+     * - `isError` replaces the error flag
+     * - `terminate` replaces the early-termination hint
+     *
+     * Any omitted fields keep their original values. No deep merge is performed.
+     * The hook receives the agent abort signal and is responsible for honoring it.
+     */
+    afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
+}
+/**
+ * Thinking/reasoning level for models that support it.
+ * Note: "xhigh" and "max" are only supported by selected model families. Use model
+ * thinking-level metadata from @ragents/ai to detect support for a concrete model.
+ */
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** Custom message types; `core/messages.ts` adds them through declaration merging. */
+export interface CustomAgentMessages {
+}
+/**
+ * AgentMessage: Union of LLM messages + custom messages.
+ * This abstraction allows apps to add custom message types while maintaining
+ * type safety and compatibility with the base LLM messages.
+ */
+export type AgentMessage = Message | CustomAgentMessages[keyof CustomAgentMessages];
+/**
+ * Public agent state.
+ *
+ * `tools` and `messages` use accessor properties so implementations can copy
+ * assigned arrays before storing them.
+ */
+export interface AgentState {
+    /** System prompt sent with each model request. */
+    systemPrompt: string;
+    /** Active model used for future turns. */
+    model: Model<any>;
+    /** Requested reasoning level for future turns. */
+    thinkingLevel: ThinkingLevel;
+    /** Available tools. Assigning a new array copies the top-level array. */
+    set tools(tools: AgentTool<any>[]);
+    get tools(): AgentTool<any>[];
+    /** Conversation transcript. Assigning a new array copies the top-level array. */
+    set messages(messages: AgentMessage[]);
+    get messages(): AgentMessage[];
+    /**
+     * True while the agent is processing a prompt or continuation.
+     *
+     * This remains true until awaited `agent_end` listeners settle.
+     */
+    readonly isStreaming: boolean;
+    /** Partial assistant message for the current streamed response, if any. */
+    readonly streamingMessage?: AgentMessage;
+    /** Tool call ids currently executing. */
+    readonly pendingToolCalls: ReadonlySet<string>;
+    /** Error message from the most recent failed or aborted assistant turn, if any. */
+    readonly errorMessage?: string;
+}
+/** Final or partial result produced by a tool. */
+export interface AgentToolResult<T> {
+    /** Text or image content returned to the model. */
+    content: (TextContent | ImageContent)[];
+    /** Arbitrary structured details for logs or UI rendering. */
+    details: T;
+    /** Names of tools introduced by this result and available from this transcript point onward. */
+    addedToolNames?: string[];
+    /**
+     * Hint that the agent should stop after the current tool batch.
+     * Early termination only happens when every finalized tool result in the batch sets this to true.
+     */
+    terminate?: boolean;
+}
+/**
+ * Callback used by tools to stream partial execution updates.
+ *
+ * The callback is scoped to the current `execute()` invocation. Calls made after
+ * the tool promise settles are ignored.
+ */
+export type AgentToolUpdateCallback<T = any> = (partialResult: AgentToolResult<T>) => void;
+/** Tool definition used by the agent runtime. */
+export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any> extends Tool<TParameters> {
+    /** Human-readable label for UI display. */
+    label: string;
+    /**
+     * Optional compatibility shim for raw tool-call arguments before schema validation.
+     * Must return an object that matches `TParameters`.
+     */
+    prepareArguments?: (args: unknown) => Static<TParameters>;
+    /** Execute the tool call. Throw on failure instead of encoding errors in `content`. */
+    execute: (toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails>) => Promise<AgentToolResult<TDetails>>;
+    /**
+     * Per-tool execution mode override.
+     * - "sequential": this tool must execute one at a time with other tool calls.
+     * - "parallel": this tool can execute concurrently with other tool calls.
+     *
+     * If omitted, the default execution mode applies.
+     */
+    executionMode?: ToolExecutionMode;
+}
+/** Context snapshot passed into the low-level agent loop. */
+export interface AgentContext {
+    /** System prompt included with the request. */
+    systemPrompt: string;
+    /** Transcript visible to the model. */
+    messages: AgentMessage[];
+    /** Tools available for this run. */
+    tools?: AgentTool<any>[];
+}
+/**
+ * Events emitted by the Agent for UI updates.
+ *
+ * `agent_end` is the last event emitted for a run, but awaited `Agent.subscribe()`
+ * listeners for that event are still part of run settlement. The agent becomes
+ * idle only after those listeners finish.
+ */
+export type AgentEvent = {
+    type: "agent_start";
+} | {
+    type: "agent_end";
+    messages: AgentMessage[];
+} | {
+    type: "turn_start";
+} | {
+    type: "turn_end";
+    message: AgentMessage;
+    toolResults: ToolResultMessage[];
+} | {
+    type: "message_start";
+    message: AgentMessage;
+} | {
+    type: "message_update";
+    message: AgentMessage;
+    assistantMessageEvent: AssistantMessageEvent;
+} | {
+    type: "message_end";
+    message: AgentMessage;
+} | {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: any;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    args: any;
+    partialResult: any;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: any;
+    isError: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/packages/agent/dist/loop/uuid.d.ts

@@ -0,0 +1,2 @@
+export declare function uuidv7(): string;
+//# sourceMappingURL=uuid.d.ts.map