@intella/sdk 0.0.7 → 0.0.9

package/dist/types.d.ts

@@ -1,8 +1,17 @@
-import type { LanguageModel, TextStreamPart } from 'ai';
+import type { LanguageModel, TextStreamPart, ModelMessage as BaseModelMessage, FilePart as BaseFilePart, ImagePart as BaseImagePart } from 'ai';
 /**
  * Supported agent types
  */
-export type AgentType = 'intella-lite' | 'claude' | 'codex' | 'opencode';
+export declare enum AgentType {
+    INTELLA_LITE = "intella-lite",
+    CLAUDE = "claude",
+    CODEX = "codex",
+    OPENCODE = "opencode"
+}
+/**
+ * Parse a string to AgentType. Returns CLAUDE for invalid/undefined input.
+ */
+export declare function parseAgentType(value: string | AgentType | undefined | null): AgentType;
 /**
  * Agent configuration interface
  */
@@ -39,16 +48,35 @@ export interface TextPart {
 /**
  * File part for message content (attachments)
  */
-export interface FilePart {
+export interface FilePart extends BaseFilePart {
     type: 'file';
-    data: string | Uint8Array | ArrayBuffer | Buffer | URL;
-    filename?: string;
-    mediaType: string;
+    size?: number;
+}
+export interface ImagePart extends BaseImagePart {
+    type: 'image';
+    size?: number;
+}
+export interface DataAnnotationPart {
+    type: 'data-annotation';
+    annotation: {
+        type: string;
+        provider?: string;
+        data: any;
+    };
 }
 /**
- * Message content can be a string or array of parts (text and/or files)
+ * Message content can be a string or array of parts (text, files, and/or data annotations)
+ */
+export type MessageContent = string | BaseModelMessage['content'] | Array<TextPart | FilePart | ImagePart | DataAnnotationPart | BaseModelMessage['content']>;
+export type ModelMessage = BaseModelMessage | {
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: MessageContent;
+    providerOptions?: Record<string, any>;
+};
+/**
+ * Data annotation part for message content (forward declaration for MessageContent)
+ * Full interface is defined in the Data Annotation Types section below
  */
-export type MessageContent = string | Array<TextPart | FilePart>;
 /**
  * Task execution request
  */
@@ -57,17 +85,18 @@ export interface TaskRequest {
     prompt: string;
     /** System prompt (optional) */
     systemPrompt?: string;
-    /** Additional messages for context */
-    messages?: Array<{
-        role: 'user' | 'assistant' | 'system';
-        content: MessageContent;
-    }>;
+    /** Additional messages for context (user (attachments), assistant, system, tool) */
+    messages?: Array<ModelMessage>;
     agentType?: AgentType;
     model?: string;
+    agentConfig?: Partial<AgentConfig>;
     /** Generation parameters */
     temperature?: number;
     maxTokens?: number;
     mode?: 'default' | 'plan';
+    skills?: string[];
+    /** Session ID (used by SDK to format paths for attachments, tool_responses, etc.) */
+    sessionId?: string;
     /** Additional options */
     [key: string]: unknown;
 }
@@ -154,6 +183,8 @@ export interface OrchestrationResponse {
  * Base agent interface
  */
 export interface IAgent {
+    /** Build messages */
+    buildMessages(request: TaskRequest): Promise<ModelMessage[]>;
     /** Agent type */
     readonly type: AgentType;
     /** Execute a task and return the response */
@@ -329,6 +360,18 @@ export interface SandboxConfig {
     installDependencies?: boolean;
     /** API keys for agent authentication */
     apiKeys?: Record<string, string>;
+    /** Commands to run on sandbox initialization */
+    runCmd?: RunCmdEntry[];
+    /** NPM packages to install on sandbox initialization */
+    npmInstall?: NpmInstallEntry[];
+    /** Bun packages to install on sandbox initialization (ensures bun is installed first) */
+    bunInstall?: BunInstallEntry[];
+    /** APT packages to install on sandbox initialization */
+    aptInstall?: AptInstallEntry[];
+    /** Pip packages to install on sandbox initialization */
+    pipInstall?: PipInstallEntry[];
+    /** Git repositories to clone on sandbox initialization */
+    gitClone?: GitCloneEntry[];
     /** Additional provider-specific options */
     [key: string]: unknown;
 }
@@ -419,10 +462,255 @@ export interface SandboxInfo {
     /** Sandbox raw info from the provider*/
     info?: any;
 }
+/**
+ * Content types supported for sandbox writeFile
+ */
+export type WriteFileContent = string | ArrayBuffer | Blob | ReadableStream<Uint8Array> | Uint8Array | Buffer;
+/**
+ * Return format for sandbox readFile
+ */
+export type ReadFileFormat = 'text' | 'bytes' | 'blob' | 'stream';
+/**
+ * Options for sandbox readFile
+ */
+export interface ReadFileOptions {
+    /** Return format: text (default), bytes, blob, or stream */
+    format?: ReadFileFormat;
+}
+/**
+ * Entry for batch writeFile
+ */
+export interface WriteFileEntry {
+    path: string;
+    content: WriteFileContent;
+}
+/**
+ * Entry for batch uploadFile (source = local path or http(s)/file URL)
+ */
+export interface UploadFileEntry {
+    source: string;
+    remotePath: string;
+}
+/**
+ * Git file status (minimal; staging/worktree optional for CLI-based impl)
+ */
+export interface GitFileStatus {
+    name: string;
+    staging?: string;
+    worktree?: string;
+    extra?: string;
+}
+/**
+ * Git repository status
+ */
+export interface GitStatus {
+    currentBranch: string;
+    ahead?: number;
+    behind?: number;
+    branchPublished?: boolean;
+    fileStatus: GitFileStatus[];
+}
+/**
+ * Git branches list response
+ */
+export interface GitBranchesResponse {
+    branches: string[];
+}
+/**
+ * Git commit result
+ */
+export interface GitCommitResult {
+    sha: string;
+}
+/**
+ * Options for git clone
+ */
+export interface GitCloneOptions {
+    branch?: string;
+    commitId?: string;
+    username?: string;
+    password?: string;
+    pullOnExists?: boolean;
+    role?: string;
+    [key: string]: any;
+}
+/**
+ * When to run a config setup step
+ * - 'creation': Run only when creating a new sandbox
+ * - 'resume': Run only when reconnecting to an existing sandbox
+ * - 'default': Run on both creation and resume (default behavior)
+ */
+export type RunWhen = 'creation' | 'resume' | 'default';
+/**
+ * Common execution options for all setup config entries
+ */
+export interface SetupExecutionOptions {
+    /** When to run this step */
+    run?: RunWhen;
+    /** Run in background without waiting for completion (fire-and-forget) */
+    background?: boolean;
+    /** Timeout in milliseconds (only applies when not running in background) */
+    timeout?: number;
+    /** Working directory to execute the command in */
+    path?: string;
+    /** Run detached using nohup, output piped to {command_name}.log file */
+    detach?: boolean;
+}
+/**
+ * Options for runCmd config entry
+ */
+export interface RunCmdOptions extends SetupExecutionOptions {
+    /** Run command as root using sudo */
+    user?: 'root';
+}
+/**
+ * Config entry for running commands on sandbox init
+ */
+export interface RunCmdEntry {
+    /** Command to run (string or array of args) */
+    command: string | string[];
+    /** Command options */
+    options?: RunCmdOptions;
+}
+/**
+ * Options for npm install config entry
+ */
+export interface NpmInstallOptions extends SetupExecutionOptions {
+    /** Install globally (-g flag) */
+    g?: boolean;
+    /** Install as dev dependency (--save-dev flag) */
+    dev?: boolean;
+}
+/**
+ * Config entry for npm package installation
+ */
+export interface NpmInstallEntry {
+    /** Package(s) to install */
+    packages: string | string[];
+    /** Install options */
+    options?: NpmInstallOptions;
+}
+/**
+ * Options for bun install config entry
+ */
+export interface BunInstallOptions extends SetupExecutionOptions {
+    /** Install globally (-g flag) */
+    g?: boolean;
+    /** Install as dev dependency (--dev flag) */
+    dev?: boolean;
+}
+/**
+ * Config entry for bun package installation
+ */
+export interface BunInstallEntry {
+    /** Package(s) to install */
+    packages: string | string[];
+    /** Install options */
+    options?: BunInstallOptions;
+}
+/**
+ * Options for apt install config entry
+ */
+export interface AptInstallOptions extends SetupExecutionOptions {
+    /** Skip recommended packages (--no-install-recommends flag) */
+    noInstallRecommends?: boolean;
+}
+/**
+ * Config entry for apt package installation
+ */
+export interface AptInstallEntry {
+    /** Package(s) to install */
+    packages: string | string[];
+    /** Install options */
+    options?: AptInstallOptions;
+}
+/**
+ * Options for pip install config entry
+ */
+export interface PipInstallOptions extends SetupExecutionOptions {
+    /** Install globally (system-wide, no --user flag) */
+    g?: boolean;
+    /** Use virtual environment (.venv). Creates one if not exists and updates .gitignore */
+    venv?: boolean;
+}
+/**
+ * Config entry for pip package installation
+ */
+export interface PipInstallEntry {
+    /** Package(s) to install. If empty array/string, uses -r requirements.txt */
+    packages: string | string[];
+    /** Install options */
+    options?: PipInstallOptions;
+}
+/**
+ * Options for git clone config entry (extends GitCloneOptions with execution options)
+ */
+export interface GitCloneConfigOptions extends GitCloneOptions, SetupExecutionOptions {
+    /** Auto-detect and install dependencies after clone (detects package.json, requirements.txt, lockfiles) */
+    autoInstall?: boolean;
+    /** Use venv for Python projects during autoInstall */
+    useVenv?: boolean;
+}
+/**
+ * Post-clone success actions
+ */
+export interface GitCloneOnSuccess {
+    /** Commands to run after successful clone */
+    runCmd?: RunCmdEntry[];
+    /** NPM packages to install after clone */
+    npmInstall?: NpmInstallEntry[];
+    /** Bun packages to install after clone */
+    bunInstall?: BunInstallEntry[];
+    /** Pip packages to install after clone */
+    pipInstall?: PipInstallEntry[];
+}
+/**
+ * Config entry for git clone
+ * Note: Use options.path from SetupExecutionOptions for target directory
+ */
+export interface GitCloneEntry {
+    /** Repository URL */
+    url: string;
+    /** Clone options (use options.path for target directory) */
+    options?: GitCloneConfigOptions;
+    /** Actions to execute after successful clone */
+    onSuccess?: GitCloneOnSuccess;
+}
+/**
+ * Git operations interface (unified across sandbox providers)
+ */
+export interface IGitOperations {
+    clone(url: string, path: string, options?: GitCloneOptions): Promise<void>;
+    status(path: string): Promise<GitStatus>;
+    branches(path: string): Promise<GitBranchesResponse>;
+    createBranch(path: string, name: string): Promise<void>;
+    checkoutBranch(path: string, branch: string): Promise<void>;
+    deleteBranch(path: string, name: string): Promise<void>;
+    add(path: string, files: string[]): Promise<void>;
+    commit(path: string, message: string, author: string, email: string, allowEmpty?: boolean): Promise<GitCommitResult>;
+    push(path: string, username?: string, password?: string): Promise<void>;
+    pull(path: string, username?: string, password?: string): Promise<void>;
+}
+/**
+ * Chunk yielded by sandbox.executeAgent (matches SessionStreamChunk from redis-stream)
+ */
+export interface SandboxAgentStreamChunk {
+    chunkId?: string;
+    chunk?: string;
+    segmentId?: string | null;
+    parentSegmentId?: string | null;
+    isDone?: boolean;
+    type?: string;
+    senderType?: string;
+    timestamp?: number;
+    data?: unknown;
+}
 /**
  * Sandbox provider interface
  */
 export interface ISandboxProvider {
+    /** Git operations (unified API; Daytona uses native, others use executeCommand + raw git) */
+    readonly git: IGitOperations;
     /** Provider type */
     readonly type: SandboxProviderType;
     /** Get the client */
@@ -442,6 +730,8 @@ export interface ISandboxProvider {
         cwd?: string;
         env?: Record<string, string>;
         timeout?: number;
+        /** Run detached using nohup, output piped to {command_name}.log file */
+        detach?: boolean;
     }): Promise<CommandResult>;
     /** Run code (e.g., Python, JavaScript) in the sandbox */
     runCode(code: string, options?: {
@@ -451,20 +741,28 @@ export interface ISandboxProvider {
         onStdout?: (data: string) => void;
         onStderr?: (data: string) => void;
     }): Promise<CodeExecutionResult>;
-    /** Upload a file to the sandbox */
-    uploadFile(localPath: string, remotePath: string): Promise<void>;
+    /** Upload file(s) to the sandbox (source = local path or http(s)/file URL) */
+    uploadFile(source: string, remotePath: string): Promise<void>;
+    uploadFile(entries: UploadFileEntry[]): Promise<void>;
     /** Download a file from the sandbox */
     downloadFile(remotePath: string, localPath: string): Promise<void>;
-    /** Read a file from the sandbox */
-    readFile(path: string): Promise<string>;
-    /** Write a file to the sandbox */
-    writeFile(path: string, content: string): Promise<void>;
+    /** Read a file from the sandbox (default format: text) */
+    readFile(path: string, options?: ReadFileOptions): Promise<string | Uint8Array | Blob | ReadableStream<Uint8Array>>;
+    /** Write file(s) to the sandbox */
+    writeFile(path: string, content: WriteFileContent): Promise<void>;
+    writeFile(entries: WriteFileEntry[]): Promise<void>;
+    /** Create a directory (recursive by default) */
+    createDirectory(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     /** List files in a directory */
     listFiles(path: string): Promise<string[]>;
     /** Check if a file exists */
     fileExists(path: string): Promise<boolean>;
     /** Delete a file */
     deleteFile(path: string): Promise<void>;
+    /** Get host URL for a port (e.g., localhost:3000 for local, or public URL for cloud providers) */
+    getHost(port: number, timeout?: number): Promise<string>;
     /** Get sandbox status */
     getStatus(): Promise<{
         isRunning: boolean;
@@ -473,5 +771,310 @@ export interface ISandboxProvider {
     }>;
     /** Get detailed sandbox information */
     getInfo(sandboxId?: string): Promise<SandboxInfo>;
+    /** Run a command (or batch of commands) */
+    runCmd(entryOrEntries: RunCmdEntry | RunCmdEntry[]): Promise<CommandResult | CommandResult[]>;
+    /** Install npm package(s) */
+    npmInstall(entryOrEntries: NpmInstallEntry | NpmInstallEntry[]): Promise<CommandResult | CommandResult[]>;
+    /** Install bun package(s) - ensures bun is installed first */
+    bunInstall(entryOrEntries: BunInstallEntry | BunInstallEntry[]): Promise<CommandResult | CommandResult[]>;
+    /** Install apt package(s) */
+    aptInstall(entryOrEntries: AptInstallEntry | AptInstallEntry[]): Promise<CommandResult | CommandResult[]>;
+    /** Install pip package(s) */
+    pipInstall(entryOrEntries: PipInstallEntry | PipInstallEntry[]): Promise<CommandResult | CommandResult[]>;
+    /** Clone git repository(ies) */
+    gitCloneRepo(entryOrEntries: GitCloneEntry | GitCloneEntry[]): Promise<void>;
+    /** Check if CLI daemon is running in the sandbox */
+    checkDaemonStatus(): Promise<boolean>;
+    /** Ensure CLI daemon is running (starts if not running) */
+    ensureDaemonRunning(options?: {
+        startTimeout?: number;
+        setSandboxId?: boolean;
+    }): Promise<void>;
+    /** Publish a command to the sandbox's stream (uses this sandbox instance's ID) */
+    publishCommand(command: SandboxCommand, redisUrl?: string): Promise<string>;
+    /** Stream events from Session or Sandbox Redis stream (Sandbox uses this instance's ID) */
+    streamEvents(eventType: StreamEventType, options?: StreamEventsOptions): AsyncIterable<SandboxAgentStreamChunk | SandboxCommandResult>;
+    /** Create a session in the sandbox by running intella CLI */
+    createSession(options: {
+        sessionId?: string;
+        agentType: AgentType;
+        model?: string;
+        metadata?: Record<string, unknown>;
+        setup?: SessionInitSetup;
+    }): Promise<SessionMetadataCallable>;
+    /** Run setup steps for a session (git clone, npm install, etc.) */
+    runSessionSetup(sessionId: string, setup: SessionInitSetup): Promise<void>;
+    /** End a session in the sandbox */
+    endSession(sessionId: string): Promise<SessionMetadata | null>;
+    /** Get a session from the sandbox */
+    getSession(sessionId: string): Promise<SessionMetadata | null>;
+    /** Publish agent:execute command and stream response from session (requires taskRequest.sessionId) */
+    executeAgent(taskRequest: TaskRequest, agentType?: AgentType, options?: {
+        redisUrl?: string;
+        apiKeys?: Record<string, string>;
+    }): AsyncIterable<SandboxAgentStreamChunk>;
+}
+/**
+ * Session metadata
+ */
+export interface SessionMetadata {
+    /** Unique session identifier */
+    id: string;
+    /** Sandbox ID if session is running in a sandbox */
+    sandboxId?: string;
+    /** Sandbox provider type */
+    sandboxProvider?: SandboxProviderType | 'local';
+    /** Agent type for this session */
+    agentType?: AgentType;
+    /** Model used for this session */
+    model?: string;
+    /** Session status */
+    status: 'active' | 'ended' | 'pending';
+    /** Session start timestamp */
+    startedAt: number;
+    /** Session end timestamp */
+    endedAt?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface SessionMetadataCallable extends SessionMetadata {
+    close: () => Promise<void>;
+}
+/**
+ * Session creation mode
+ */
+export type SessionMode = 'local' | 'sandbox';
+/**
+ * Session init setup - steps to run after session creation
+ */
+export interface SessionInitSetup {
+    /** Commands to run after session creation */
+    runCmd?: RunCmdEntry[];
+    /** Git repositories to clone */
+    gitClone?: GitCloneEntry[];
+    /** NPM packages to install */
+    npmInstall?: NpmInstallEntry[];
+    /** Pip packages to install */
+    pipInstall?: PipInstallEntry[];
+}
+/**
+ * Session init payload (for type: 'session:init')
+ */
+export interface SessionInit {
+    sessionId?: string;
+    agentType: AgentType | string;
+    model?: string;
+    skills?: string[];
+    agentConfig?: Partial<AgentConfig>;
+    setup?: SessionInitSetup;
+}
+/**
+ * Command type discriminator
+ */
+export type SandboxCommandType = 'session:init' | 'session:end' | 'agent:execute' | 'ping' | 'command:execute';
+/**
+ * Command to publish to sandbox stream.
+ * Use cmdId to avoid conflict with Redis message id.
+ * type + data differentiate the kind of command.
+ */
+export interface SandboxCommand {
+    cmdId?: string;
+    type: SandboxCommandType;
+    sessionId?: string;
+    data: Record<string, string> | TaskRequest | SessionInit | {
+        cmd: RunCmdEntry;
+    };
+    metadata: Record<string, string>;
+    apiKeys: Record<string, string>;
+    env?: Record<string, string>;
+    timestamp?: number;
+}
+/**
+ * Result from sandbox stream (response to a SandboxCommand).
+ * commandId correlates to the command's cmdId.
+ */
+export interface SandboxCommandResult {
+    commandId: string;
+    type: 'success' | 'error' | 'chunk' | 'done';
+    sessionId?: string;
+    data?: unknown;
+    error?: string;
+    timestamp: number;
+}
+/**
+ * Event type for streamEvents - Session streams session chunks, Sandbox streams command results
+ */
+export declare enum StreamEventType {
+    SESSION = "session",
+    SANDBOX = "sandbox"
+}
+/**
+ * Options for streaming events from Session or Sandbox Redis streams
+ */
+export interface StreamEventsOptions {
+    /** Redis URL (defaults to REDIS_URL env var) */
+    redisUrl?: string;
+    /** Maximum time to wait in milliseconds (default: 10 minutes) */
+    timeout?: number;
+    /** Consumer group name (auto-generated if not provided) */
+    groupName?: string;
+    /** Consumer name (auto-generated if not provided) */
+    consumerName?: string;
+    /** Filter by commandId (for sandbox streams) */
+    commandId?: string;
+    /** Session ID (for session streams) */
+    sessionId?: string;
+    /** Filter function to determine if message should be processed */
+    filter?: (message: Record<string, string>) => boolean;
+    /** Transform function to convert message to result type */
+    transform?: (message: Record<string, string>) => any;
+    /** Whether to stop on 'done' or 'error' type messages (default: true for Sandbox, false for Session) */
+    stopOnDone?: boolean;
+    /** Block time in milliseconds for XREADGROUP (default: 1000) */
+    blockTime?: number;
+    /** Count of messages to read per batch (default: 100) */
+    count?: number;
+}
+/**
+ * Chunk data to publish
+ */
+export interface ChunkData {
+    id?: string;
+    chunkId?: string;
+    chunk?: string;
+    segmentId?: string;
+    parentSegmentId?: string;
+    isDone?: boolean;
+    type?: string;
+    senderType?: string;
+    timestamp?: number;
+    data?: Record<string, any>;
+    /** Command ID for correlation when publishing to sandbox results stream */
+    commandId?: string;
+}
+/**
+ * Options for creating a session
+ */
+export interface CreateSessionOptions {
+    /** Session creation mode: 'local' or 'sandbox' */
+    mode: SessionMode;
+    /** Sandbox ID (required when mode is 'sandbox') */
+    sandboxId?: string;
+    /** Custom session ID (optional, auto-generated if not provided) */
+    sessionId?: string;
+    /** Agent type for this session */
+    agentType: AgentType;
+    /** Model to use */
+    model?: string;
+    /** API keys for the session */
+    apiKeys?: Record<string, string>;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Setup steps to run after session creation */
+    setup?: SessionInitSetup;
+}
+/**
+ * Result of session creation
+ */
+export interface CreateSessionResult {
+    /** The created session */
+    session: SessionMetadata;
+    /** Command ID (only for sandbox mode) */
+    commandId?: string;
+}
+/**
+ * Record of a single execution (task request and response)
+ */
+export interface ExecutionRecord {
+    /** Unique execution identifier */
+    id: string;
+    /** Session ID this execution belongs to */
+    sessionId: string;
+    /** The task request that was executed */
+    taskRequest: {
+        prompt?: string;
+        systemPrompt?: string;
+        agentType?: AgentType;
+        model?: string;
+    };
+    /** The full response text */
+    response: string;
+    /** Response chunks (optional) */
+    chunks?: Array<{
+        text: string;
+        timestamp: number;
+    }>;
+    /** Execution start timestamp */
+    startedAt: number;
+    /** Execution completion timestamp */
+    completedAt: number;
+    /** Command ID if executed via Redis */
+    commandId?: string;
+    /** Segment ID for correlation with app */
+    segmentId?: string;
+}
+/**
+ * Git hosting provider types
+ */
+export type GitProvider = 'github' | 'gitlab' | 'bitbucket' | 'custom';
+/**
+ * Result for a single repo setup operation
+ * Used for session-level repo annotations
+ */
+export interface RepoPath {
+    /** Repository name (extracted from URL) */
+    repoName: string;
+    /** Absolute path in sandbox where repo is cloned */
+    path: string;
+    /** Branch name */
+    branch: string;
+    /** Role of the repo (source, target, or all) */
+    role?: 'source' | 'target' | 'all';
+    /** Git provider (github, gitlab, etc.) */
+    provider?: GitProvider;
+    /** Whether clone/pull succeeded */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Branch strategy for TARGET repos: new = create branch this session; follow-on = reuse branch */
+    branchStrategy?: 'new' | 'follow-on';
+    /** When branch was created (timestamp) */
+    branchCreatedAt?: number;
+}
+/**
+ * Result of repo setup operation
+ */
+export interface RepoSetupResult {
+    /** Array of repo paths with status */
+    repoPaths: RepoPath[];
+    /** Number of successfully cloned/pulled repos */
+    successCount: number;
+    /** Number of failed repos */
+    failureCount: number;
+}
+/**
+ * Data for tool_response annotation (from agent tool calls).
+ * When output is too large, only id (and optional summary) is included
+ * so the agent can retrieve the full response by id.
+ */
+export interface ToolResponseData {
+    /** Unique id to retrieve full response when output is omitted (e.g. segment id) */
+    id?: string;
+    /** Tool call id from the stream */
+    toolCallId?: string;
+    /** Tool name */
+    toolName?: string;
+    /** Tool call input (arguments passed to the tool) */
+    input?: string | Record<string, unknown>;
+    /** Full tool response output (omitted when too large) */
+    output?: string;
+    /** Whether the tool call succeeded or failed */
+    status?: 'completed' | 'failed';
+    /** Error message when status is 'failed' */
+    error?: string;
+    /** Short summary when output is truncated (optional) */
+    summary?: string;
+    /** Character length when output was truncated */
+    truncatedAt?: number;
 }
 //# sourceMappingURL=types.d.ts.map