agent-worker 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,572 @@
+import * as ai0 from "ai";
+import { LanguageModel } from "ai";
+import { BashToolkit, CreateBashToolOptions, createBashTool } from "bash-tool";
+
+//#region src/types.d.ts
+/**
+ * Message status for streaming/response tracking
+ */
+type MessageStatus = 'responding' | 'complete';
+/**
+ * Extended message with status for tracking streaming state
+ */
+interface AgentMessage {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  /** Message status - 'responding' while streaming, 'complete' when done */
+  status?: MessageStatus;
+  /** Timestamp when message started */
+  timestamp?: string;
+}
+/**
+ * Tool definition with optional mock implementation
+ */
+interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+  /** Mock function - returns controlled response for testing */
+  execute?: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+  /** Static mock response (JSON-serializable, used when execute is not set) */
+  mockResponse?: unknown;
+  /** Require user approval before execution (default: false) */
+  needsApproval?: boolean | ((args: Record<string, unknown>) => boolean);
+}
+/**
+ * A pending tool call awaiting user approval
+ */
+interface PendingApproval {
+  /** Unique approval ID */
+  id: string;
+  /** Tool name */
+  toolName: string;
+  /** Tool call ID from the model */
+  toolCallId: string;
+  /** Arguments passed to the tool */
+  arguments: Record<string, unknown>;
+  /** When the approval was requested */
+  requestedAt: string;
+  /** Current status */
+  status: 'pending' | 'approved' | 'denied';
+  /** Denial reason if denied */
+  denyReason?: string;
+}
+/**
+ * A single tool call with its result
+ */
+interface ToolCall {
+  name: string;
+  arguments: Record<string, unknown>;
+  result: unknown;
+  timing: number;
+}
+/**
+ * Token usage statistics
+ */
+interface TokenUsage {
+  input: number;
+  output: number;
+  total: number;
+}
+/**
+ * Response from a single message exchange
+ */
+interface AgentResponse {
+  /** Final text content */
+  content: string;
+  /** All tool calls made during this turn */
+  toolCalls: ToolCall[];
+  /** Tool calls awaiting approval (response is incomplete until approved) */
+  pendingApprovals: PendingApproval[];
+  /** Token usage */
+  usage: TokenUsage;
+  /** Response latency in ms */
+  latency: number;
+}
+/**
+ * Session configuration
+ */
+interface SessionConfig {
+  /** Model identifier (e.g., 'openai/gpt-5.2' or 'anthropic:claude-sonnet-4-5') */
+  model: string;
+  /** System prompt */
+  system: string;
+  /** Tool definitions with mock implementations */
+  tools?: ToolDefinition[];
+  /** Maximum tokens for response (default: 4096) */
+  maxTokens?: number;
+  /** Maximum tool call steps per turn (default: 10) */
+  maxSteps?: number;
+}
+/**
+ * Persisted session state for restoration
+ */
+interface SessionState {
+  /** Session ID to restore */
+  id: string;
+  /** Creation timestamp */
+  createdAt: string;
+  /** Conversation messages with status */
+  messages: AgentMessage[];
+  /** Accumulated token usage */
+  totalUsage: TokenUsage;
+  /** Pending tool approvals */
+  pendingApprovals: PendingApproval[];
+}
+/**
+ * Exported transcript for analysis
+ */
+interface Transcript {
+  sessionId: string;
+  model: string;
+  system: string;
+  messages: AgentMessage[];
+  totalUsage: TokenUsage;
+  createdAt: string;
+}
+//#endregion
+//#region src/session.d.ts
+/**
+ * Step finish callback info
+ */
+interface StepInfo {
+  stepNumber: number;
+  toolCalls: ToolCall[];
+  usage: TokenUsage;
+}
+/**
+ * Options for send() method
+ */
+interface SendOptions {
+  /** Auto-approve all tool calls that require approval (default: true) */
+  autoApprove?: boolean;
+  /** Callback after each agent step */
+  onStepFinish?: (info: StepInfo) => void | Promise<void>;
+}
+/**
+ * AgentSession - Stateful session for controlled agent testing
+ *
+ * Uses ToolLoopAgent internally for multi-step reasoning loops.
+ * Maintains conversation state across multiple send() calls,
+ * enabling improvisational testing where you observe responses
+ * and decide next actions.
+ */
+declare class AgentSession {
+  readonly id: string;
+  readonly model: string;
+  readonly system: string;
+  readonly createdAt: string;
+  private tools;
+  private maxTokens;
+  private maxSteps;
+  private messages;
+  private totalUsage;
+  private pendingApprovals;
+  private cachedAgent;
+  private toolsChanged;
+  /**
+   * Convert AgentMessage[] to ModelMessage[] for AI SDK
+   */
+  private toModelMessages;
+  constructor(config: SessionConfig, restore?: SessionState);
+  /**
+   * Check if a tool needs approval for given arguments
+   */
+  private toolNeedsApproval;
+  /**
+   * Build tools with approval handling
+   */
+  private buildTools;
+  /**
+   * Get or create cached agent, rebuild if tools changed
+   */
+  private getAgent;
+  /**
+   * Send a message and get the agent's response
+   * Conversation state is maintained across calls
+   *
+   * @param content - The message to send
+   * @param options - Send options (autoApprove, onStepFinish, etc.)
+   */
+  send(content: string, options?: SendOptions): Promise<AgentResponse>;
+  /**
+   * Send a message and stream the response
+   * Returns an async iterable of text chunks
+   *
+   * @param content - The message to send
+   * @param options - Send options (autoApprove, onStepFinish, etc.)
+   */
+  sendStream(content: string, options?: SendOptions): AsyncGenerator<string, AgentResponse, unknown>;
+  /**
+   * Add a tool definition with mock implementation
+   */
+  addTool(tool: ToolDefinition): void;
+  /**
+   * Set mock response for an existing tool
+   */
+  mockTool(name: string, mockFn: (args: Record<string, unknown>) => unknown): void;
+  /**
+   * Get current tool definitions (without execute functions)
+   */
+  getTools(): ToolDefinition[];
+  /**
+   * Set a static mock response for an existing tool (JSON-serializable)
+   */
+  setMockResponse(name: string, response: unknown): void;
+  /**
+   * Get conversation history with status information
+   * Messages with status 'responding' are still being generated
+   */
+  history(): AgentMessage[];
+  /**
+   * Get session statistics
+   */
+  stats(): {
+    messageCount: number;
+    usage: TokenUsage;
+  };
+  /**
+   * Export full transcript for analysis
+   */
+  export(): Transcript;
+  /**
+   * Get session state for persistence
+   */
+  getState(): SessionState;
+  /**
+   * Get all pending approvals
+   */
+  getPendingApprovals(): PendingApproval[];
+  /**
+   * Approve a pending tool call and execute it
+   * @returns The tool execution result
+   */
+  approve(approvalId: string): Promise<unknown>;
+  /**
+   * Deny a pending tool call
+   * @param approvalId - The approval ID to deny
+   * @param reason - Optional reason for denial
+   */
+  deny(approvalId: string, reason?: string): void;
+  /**
+   * Clear conversation history (keep system prompt and tools)
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/models.d.ts
+/**
+ * Parse model identifier and return the appropriate provider model
+ *
+ * Supports three formats:
+ *
+ * 1. Provider-only format: provider
+ *    Uses first model from FRONTIER_MODELS via gateway
+ *    Examples: anthropic → anthropic/claude-sonnet-4-5, openai → openai/gpt-5.2
+ *
+ * 2. Gateway format: provider/model-name
+ *    Uses Vercel AI Gateway (requires AI_GATEWAY_API_KEY)
+ *    Examples: anthropic/claude-sonnet-4-5, openai/gpt-5.2, deepseek/deepseek-chat
+ *
+ * 3. Direct provider format: provider:model-name
+ *    Requires installing the specific @ai-sdk/provider package
+ *    Examples: anthropic:claude-sonnet-4-5, openai:gpt-5.2, deepseek:deepseek-chat
+ */
+declare function createModel(modelId: string): LanguageModel;
+/**
+ * Async version of createModel - supports lazy loading of direct providers
+ * Use this when you need direct provider access (provider:model format)
+ */
+declare function createModelAsync(modelId: string): Promise<LanguageModel>;
+/**
+ * List of supported providers for direct access
+ * Note: minimax uses Claude-compatible API via @ai-sdk/anthropic with custom baseURL
+ */
+declare const SUPPORTED_PROVIDERS: readonly ["anthropic", "openai", "deepseek", "google", "groq", "mistral", "xai", "minimax"];
+type SupportedProvider = (typeof SUPPORTED_PROVIDERS)[number];
+/**
+ * Frontier models for each provider (as of 2026-02)
+ * Only includes the latest/best models, no legacy versions
+ *
+ * Note: Some models may be placeholders for testing or future releases.
+ * Always verify model availability with the provider before production use.
+ */
+declare const FRONTIER_MODELS: {
+  readonly anthropic: readonly ["claude-sonnet-4-5", "claude-haiku-4-5", "claude-opus-4-5"];
+  readonly openai: readonly ["gpt-5.2", "gpt-5.2-codex"];
+  readonly google: readonly ["gemini-3-pro-preview", "gemini-2.5-flash", "gemini-2.5-pro"];
+  readonly deepseek: readonly ["deepseek-chat", "deepseek-reasoner"];
+  readonly groq: readonly ["meta-llama/llama-4-scout-17b-16e-instruct", "deepseek-r1-distill-llama-70b"];
+  readonly mistral: readonly ["mistral-large-latest", "pixtral-large-latest", "magistral-medium-2506"];
+  readonly xai: readonly ["grok-4", "grok-4-fast-reasoning"];
+  readonly minimax: readonly ["MiniMax-M2"];
+};
+//#endregion
+//#region src/tools.d.ts
+/**
+ * Convert ToolDefinition array to AI SDK tools object
+ * Uses tool() with jsonSchema() for runtime-defined mock tools
+ */
+declare function createTools(definitions: ToolDefinition[]): Record<string, ai0.Tool<never, never>>;
+//#endregion
+//#region src/bash-tools.d.ts
+/**
+ * Options for creating bash tools compatible with AgentSession
+ */
+interface BashToolsOptions extends CreateBashToolOptions {
+  /**
+   * Include readFile tool (default: true)
+   */
+  includeReadFile?: boolean;
+  /**
+   * Include writeFile tool (default: true)
+   */
+  includeWriteFile?: boolean;
+}
+/**
+ * Create bash tools as ToolDefinition array for use with AgentSession
+ *
+ * @example
+ * ```typescript
+ * const bashTools = await createBashTools({
+ *   files: { 'src/index.ts': 'console.log("hello")' }
+ * })
+ *
+ * const session = new AgentSession({
+ *   model: 'anthropic/claude-sonnet-4-5',
+ *   system: 'You are a coding assistant.',
+ *   tools: bashTools
+ * })
+ * ```
+ */
+declare function createBashTools(options?: BashToolsOptions): Promise<{
+  tools: ToolDefinition[];
+  toolkit: BashToolkit;
+}>;
+/**
+ * Quick helper to create bash tools with a directory
+ *
+ * @example
+ * ```typescript
+ * const { tools } = await createBashToolsFromDirectory('./src')
+ * ```
+ */
+declare function createBashToolsFromDirectory(source: string, options?: Omit<BashToolsOptions, 'uploadDirectory'>): Promise<{
+  tools: ToolDefinition[];
+  toolkit: BashToolkit;
+}>;
+/**
+ * Quick helper to create bash tools with inline files
+ *
+ * @example
+ * ```typescript
+ * const { tools } = await createBashToolsFromFiles({
+ *   'index.ts': 'console.log("hello")',
+ *   'package.json': '{"name": "test"}'
+ * })
+ * ```
+ */
+declare function createBashToolsFromFiles(files: Record<string, string>, options?: Omit<BashToolsOptions, 'files'>): Promise<{
+  tools: ToolDefinition[];
+  toolkit: BashToolkit;
+}>;
+//#endregion
+//#region src/backends/types.d.ts
+/**
+ * Backend types for different AI execution engines
+ */
+type BackendType = 'sdk' | 'claude' | 'codex' | 'cursor';
+interface BackendConfig {
+  type: BackendType;
+  /** Model identifier (interpretation depends on backend) */
+  model?: string;
+  /** Additional CLI flags or SDK options */
+  options?: Record<string, unknown>;
+}
+interface BackendResponse {
+  content: string;
+  /** Tool calls made during execution (if supported) */
+  toolCalls?: Array<{
+    name: string;
+    arguments: unknown;
+    result: unknown;
+  }>;
+  /** Usage statistics (if available) */
+  usage?: {
+    input: number;
+    output: number;
+    total: number;
+  };
+}
+interface Backend {
+  readonly type: BackendType;
+  /** Send a message and get a response */
+  send(message: string, options?: {
+    system?: string;
+  }): Promise<BackendResponse>;
+  /** Check if the backend is available (CLI installed, API key set, etc.) */
+  isAvailable(): Promise<boolean>;
+  /** Get backend info for display */
+  getInfo(): {
+    name: string;
+    version?: string;
+    model?: string;
+  };
+}
+//#endregion
+//#region src/backends/claude-cli.d.ts
+interface ClaudeCliOptions {
+  /** Model to use (e.g., 'opus', 'sonnet') */
+  model?: string;
+  /** Additional system prompt to append */
+  appendSystemPrompt?: string;
+  /** Allowed tools (permission rule syntax) */
+  allowedTools?: string[];
+  /** Output format: 'text' | 'json' | 'stream-json' */
+  outputFormat?: 'text' | 'json' | 'stream-json';
+  /** Continue most recent conversation */
+  continue?: boolean;
+  /** Resume specific session by ID */
+  resume?: string;
+  /** Working directory */
+  cwd?: string;
+}
+declare class ClaudeCliBackend implements Backend {
+  readonly type: "claude";
+  private options;
+  constructor(options?: ClaudeCliOptions);
+  send(message: string, options?: {
+    system?: string;
+  }): Promise<BackendResponse>;
+  isAvailable(): Promise<boolean>;
+  getInfo(): {
+    name: string;
+    version?: string;
+    model?: string;
+  };
+  private buildArgs;
+}
+//#endregion
+//#region src/backends/codex-cli.d.ts
+interface CodexCliOptions {
+  /** Model to use (e.g., 'gpt-5.2-codex') */
+  model?: string;
+  /** Output as JSON events */
+  json?: boolean;
+  /** Working directory */
+  cwd?: string;
+  /** Skip git repo check */
+  skipGitRepoCheck?: boolean;
+  /** Approval mode: 'suggest' | 'auto-edit' | 'full-auto' */
+  approvalMode?: 'suggest' | 'auto-edit' | 'full-auto';
+  /** Resume a previous session */
+  resume?: string;
+}
+declare class CodexCliBackend implements Backend {
+  readonly type: "codex";
+  private options;
+  constructor(options?: CodexCliOptions);
+  send(message: string, _options?: {
+    system?: string;
+  }): Promise<BackendResponse>;
+  isAvailable(): Promise<boolean>;
+  getInfo(): {
+    name: string;
+    version?: string;
+    model?: string;
+  };
+  private buildArgs;
+}
+//#endregion
+//#region src/backends/cursor-cli.d.ts
+interface CursorCliOptions {
+  /** Model to use */
+  model?: string;
+  /** Working directory */
+  cwd?: string;
+  /** Use 'agent' command instead of 'cursor-agent' */
+  useAgentCommand?: boolean;
+  /** Timeout in milliseconds (cursor CLI can hang) */
+  timeout?: number;
+}
+declare class CursorCliBackend implements Backend {
+  readonly type: "cursor";
+  private options;
+  constructor(options?: CursorCliOptions);
+  send(message: string, _options?: {
+    system?: string;
+  }): Promise<BackendResponse>;
+  isAvailable(): Promise<boolean>;
+  private checkCommand;
+  getInfo(): {
+    name: string;
+    version?: string;
+    model?: string;
+  };
+  private buildCommand;
+}
+//#endregion
+//#region src/backends/sdk.d.ts
+interface SdkBackendOptions {
+  /** Model identifier (e.g., 'openai/gpt-5.2' or 'anthropic:claude-sonnet-4-5') */
+  model: string;
+  /** Maximum tokens to generate */
+  maxTokens?: number;
+}
+declare class SdkBackend implements Backend {
+  readonly type: "sdk";
+  private modelId;
+  private model;
+  private maxTokens;
+  constructor(options: SdkBackendOptions);
+  send(message: string, options?: {
+    system?: string;
+  }): Promise<BackendResponse>;
+  isAvailable(): Promise<boolean>;
+  getInfo(): {
+    name: string;
+    version?: string;
+    model?: string;
+  };
+}
+//#endregion
+//#region src/backends/index.d.ts
+type BackendOptions = {
+  type: 'sdk';
+  model: string;
+  maxTokens?: number;
+} | {
+  type: 'claude';
+  model?: string;
+  options?: Omit<ClaudeCliOptions, 'model'>;
+} | {
+  type: 'codex';
+  model?: string;
+  options?: Omit<CodexCliOptions, 'model'>;
+} | {
+  type: 'cursor';
+  model?: string;
+  options?: Omit<CursorCliOptions, 'model'>;
+};
+/**
+ * Create a backend instance
+ */
+declare function createBackend(config: BackendOptions): Backend;
+/**
+ * Check which backends are available
+ */
+declare function checkBackends(): Promise<Record<BackendType, boolean>>;
+/**
+ * List available backends with info
+ */
+declare function listBackends(): Promise<Array<{
+  type: BackendType;
+  available: boolean;
+  name: string;
+}>>;
+//#endregion
+export { type AgentMessage, type AgentResponse, AgentSession, type Backend, type BackendConfig, type BackendOptions, type BackendResponse, type BackendType, type BashToolkit, type BashToolsOptions, ClaudeCliBackend, type ClaudeCliOptions, CodexCliBackend, type CodexCliOptions, type CreateBashToolOptions, CursorCliBackend, type CursorCliOptions, FRONTIER_MODELS, type MessageStatus, type PendingApproval, SUPPORTED_PROVIDERS, SdkBackend, type SdkBackendOptions, type SendOptions, type SessionConfig, type SessionState, type StepInfo, type SupportedProvider, type TokenUsage, type ToolCall, type ToolDefinition, type Transcript, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createModel, createModelAsync, createTools, listBackends };

package/dist/index.mjs

@@ -0,0 +1,121 @@
+import { i as createModelAsync, n as SUPPORTED_PROVIDERS, r as createModel, t as FRONTIER_MODELS } from "./models-FOOpWB91.mjs";
+import { n as createTools, t as AgentSession } from "./session-DQQAmPf-.mjs";
+import { a as CursorCliBackend, i as SdkBackend, n as createBackend, o as CodexCliBackend, r as listBackends, s as ClaudeCliBackend, t as checkBackends } from "./backends-BklSbwcH.mjs";
+import { createBashTool } from "bash-tool";
+
+//#region src/bash-tools.ts
+/**
+* Integration with Vercel's bash-tool for file system operations
+*
+* Provides bash, readFile, writeFile tools for AI agents in a sandboxed environment
+*/
+/**
+* Create bash tools as ToolDefinition array for use with AgentSession
+*
+* @example
+* ```typescript
+* const bashTools = await createBashTools({
+*   files: { 'src/index.ts': 'console.log("hello")' }
+* })
+*
+* const session = new AgentSession({
+*   model: 'anthropic/claude-sonnet-4-5',
+*   system: 'You are a coding assistant.',
+*   tools: bashTools
+* })
+* ```
+*/
+async function createBashTools(options = {}) {
+	const { includeReadFile = true, includeWriteFile = true, ...bashOptions } = options;
+	const toolkit = await createBashTool(bashOptions);
+	const tools = [];
+	tools.push({
+		name: "bash",
+		description: "Execute bash commands in a sandboxed environment. Returns stdout, stderr, and exit code.",
+		parameters: {
+			type: "object",
+			properties: { command: {
+				type: "string",
+				description: "The bash command to execute"
+			} },
+			required: ["command"]
+		},
+		execute: async (args) => {
+			return await toolkit.tools.bash.execute(args);
+		}
+	});
+	if (includeReadFile) tools.push({
+		name: "readFile",
+		description: "Read the contents of a file from the sandbox filesystem.",
+		parameters: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "The path to the file to read"
+			} },
+			required: ["path"]
+		},
+		execute: async (args) => {
+			return await toolkit.tools.readFile.execute(args);
+		}
+	});
+	if (includeWriteFile) tools.push({
+		name: "writeFile",
+		description: "Write content to a file in the sandbox filesystem. Creates parent directories if needed.",
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "The path to the file to write"
+				},
+				content: {
+					type: "string",
+					description: "The content to write to the file"
+				}
+			},
+			required: ["path", "content"]
+		},
+		execute: async (args) => {
+			return await toolkit.tools.writeFile.execute(args);
+		}
+	});
+	return {
+		tools,
+		toolkit
+	};
+}
+/**
+* Quick helper to create bash tools with a directory
+*
+* @example
+* ```typescript
+* const { tools } = await createBashToolsFromDirectory('./src')
+* ```
+*/
+async function createBashToolsFromDirectory(source, options = {}) {
+	return createBashTools({
+		...options,
+		uploadDirectory: { source }
+	});
+}
+/**
+* Quick helper to create bash tools with inline files
+*
+* @example
+* ```typescript
+* const { tools } = await createBashToolsFromFiles({
+*   'index.ts': 'console.log("hello")',
+*   'package.json': '{"name": "test"}'
+* })
+* ```
+*/
+async function createBashToolsFromFiles(files, options = {}) {
+	return createBashTools({
+		...options,
+		files
+	});
+}
+
+//#endregion
+export { AgentSession, ClaudeCliBackend, CodexCliBackend, CursorCliBackend, FRONTIER_MODELS, SUPPORTED_PROVIDERS, SdkBackend, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createModel, createModelAsync, createTools, listBackends };