@levelcode/sdk 0.2.3 → 0.2.5

package/dist/common/src/testing/mocks/database.d.ts

@@ -1,197 +0,0 @@
-/**
- * Typed database mock factory for testing.
- *
- * Provides type-safe mocks for Drizzle database operations used throughout the codebase.
- * Replaces the need for `as any` casts when setting up database spies.
- *
- * @example
- * ```typescript
- * import { createMockDbOperations, setupDbSpies } from '@levelcode/common/testing/mocks/database'
- *
- * // Option 1: Create mock operations object
- * const dbOps = createMockDbOperations()
- *
- * // Option 2: Setup spies on actual db module
- * const spies = setupDbSpies(db)
- * await runTest()
- * spies.restore()
- * ```
- */
-import { spyOn } from 'bun:test';
-import type { Mock } from 'bun:test';
-/**
- * Type for the chainable insert result.
- */
-export interface MockInsertResult<T = unknown> {
-    values: Mock<(data: T | T[]) => Promise<{
-        id: string;
-    }>>;
-    returning: Mock<() => Promise<T[]>>;
-    onConflictDoNothing: Mock<() => MockInsertResult<T>>;
-    onConflictDoUpdate: Mock<(config: {
-        target: unknown;
-        set: unknown;
-    }) => MockInsertResult<T>>;
-}
-/**
- * Type for the chainable update result.
- */
-export interface MockUpdateResult<T = unknown> {
-    set: Mock<(data: Partial<T>) => MockUpdateSetResult>;
-}
-/**
- * Type for the update.set result.
- */
-export interface MockUpdateSetResult {
-    where: Mock<(condition: unknown) => Promise<void>>;
-    returning: Mock<() => Promise<unknown[]>>;
-}
-/**
- * Type for the chainable select result.
- */
-export interface MockSelectResult<T = unknown> {
-    from: Mock<(table: unknown) => MockSelectFromResult<T>>;
-}
-/**
- * Type for the select.from result.
- */
-export interface MockSelectFromResult<T = unknown> {
-    where: Mock<(condition: unknown) => MockSelectWhereResult<T>>;
-    leftJoin: Mock<(table: unknown, condition: unknown) => MockSelectFromResult<T>>;
-    innerJoin: Mock<(table: unknown, condition: unknown) => MockSelectFromResult<T>>;
-    orderBy: Mock<(...columns: unknown[]) => MockSelectFromResult<T>>;
-    limit: Mock<(n: number) => MockSelectFromResult<T>>;
-    offset: Mock<(n: number) => MockSelectFromResult<T>>;
-    then: Mock<(resolve: (value: T[]) => void) => Promise<T[]>>;
-}
-/**
- * Type for the select.from.where result.
- */
-export interface MockSelectWhereResult<T = unknown> {
-    then: Mock<(resolve: (value: T[]) => void) => Promise<T[]>>;
-    leftJoin: Mock<(table: unknown, condition: unknown) => MockSelectWhereResult<T>>;
-    innerJoin: Mock<(table: unknown, condition: unknown) => MockSelectWhereResult<T>>;
-    orderBy: Mock<(...columns: unknown[]) => MockSelectWhereResult<T>>;
-    limit: Mock<(n: number) => MockSelectWhereResult<T>>;
-    offset: Mock<(n: number) => MockSelectWhereResult<T>>;
-}
-/**
- * Type for the chainable delete result.
- */
-export interface MockDeleteResult {
-    where: Mock<(condition: unknown) => Promise<void>>;
-}
-/**
- * Interface for the complete mock database operations.
- */
-export interface MockDbOperations {
-    insert: Mock<(table: unknown) => MockInsertResult>;
-    update: Mock<(table: unknown) => MockUpdateResult>;
-    select: Mock<(columns?: unknown) => MockSelectResult>;
-    delete: Mock<(table: unknown) => MockDeleteResult>;
-    transaction: Mock<(<T>(fn: (tx: MockDbOperations) => Promise<T>) => Promise<T>)>;
-}
-/**
- * Options for creating mock database operations.
- */
-export interface CreateMockDbOptions {
-    /**
-     * Default data to return from select queries.
-     */
-    defaultSelectData?: unknown[];
-    /**
-     * Default ID to return from insert operations.
-     */
-    defaultInsertId?: string;
-}
-/**
- * Creates type-safe mock database operations for testing.
- *
- * @param options - Configuration options for the mock
- * @returns A mock database operations object
- *
- * @example
- * ```typescript
- * const dbOps = createMockDbOperations({
- *   defaultSelectData: [{ id: '1', name: 'Test' }],
- *   defaultInsertId: 'new-id',
- * })
- *
- * // The mocks are chainable just like real Drizzle
- * await dbOps.insert(users).values({ name: 'Test' })
- * await dbOps.select().from(users).where(eq(users.id, '1'))
- * ```
- */
-export declare function createMockDbOperations(options?: CreateMockDbOptions): MockDbOperations;
-/**
- * Result of setting up database spies.
- */
-export interface DbSpies {
-    /** Spy on insert operations */
-    insert: ReturnType<typeof spyOn>;
-    /** Spy on update operations */
-    update: ReturnType<typeof spyOn>;
-    /** Restore all spies */
-    restore: () => void;
-    /** Clear all spy call history */
-    clear: () => void;
-}
-/**
- * Sets up spies on a database module for insert and update operations.
- * This is the most common pattern used in tests.
- *
- * @param db - The database module to spy on
- * @param options - Configuration options
- * @returns Object containing the spies and cleanup utilities
- *
- * @example
- * ```typescript
- * import db from '@levelcode/internal/db'
- *
- * describe('my test', () => {
- *   let dbSpies: DbSpies
- *
- *   beforeEach(() => {
- *     dbSpies = setupDbSpies(db)
- *   })
- *
- *   afterEach(() => {
- *     dbSpies.restore()
- *   })
- *
- *   it('inserts data', async () => {
- *     await createUser({ name: 'Test' })
- *     expect(dbSpies.insert).toHaveBeenCalled()
- *   })
- * })
- * ```
- */
-/**
- * Sets up spies on a database module for insert and update operations.
- * Accepts any object with insert and update methods.
- */
-export declare function setupDbSpies(db: {
-    insert: unknown;
-    update: unknown;
-}, options?: CreateMockDbOptions): DbSpies;
-/**
- * Creates a mock for a database query builder chain that returns specific data.
- *
- * @param data - The data to return from the query
- * @returns A thenable mock that resolves to the data
- *
- * @example
- * ```typescript
- * const mockQuery = createMockQueryResult([
- *   { id: '1', name: 'User 1' },
- *   { id: '2', name: 'User 2' },
- * ])
- *
- * spyOn(userService, 'findAll').mockReturnValue(mockQuery)
- * ```
- */
-export declare function createMockQueryResult<T>(data: T[]): Promise<T[]> & {
-    where: Mock<() => Promise<T[]>>;
-    orderBy: Mock<() => Promise<T[]>>;
-    limit: Mock<() => Promise<T[]>>;
-};

package/dist/common/src/testing/mocks/fetch.d.ts

@@ -1,35 +0,0 @@
-/** Typed fetch mock utilities for testing. */
-import type { Mock } from 'bun:test';
-export interface MockResponseOptions {
-    status?: number;
-    statusText?: string;
-    headers?: HeadersInit;
-}
-export type MockFetch = Mock<typeof globalThis.fetch>;
-export interface InstallMockFetchResult {
-    mockFetch: MockFetch;
-    restore: () => void;
-    getCalls: () => MockFetchCall[];
-    clear: () => void;
-}
-export interface MockFetchCall {
-    url: string | URL | Request;
-    init?: RequestInit;
-    jsonBody?: unknown;
-}
-export interface CreateMockFetchOptions {
-    defaultImpl?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-}
-/** Creates a Response with JSON body. */
-export declare function mockJsonResponse(data: unknown, options?: MockResponseOptions): Response;
-/** Creates a Response with text body. */
-export declare function mockTextResponse(text: string, options?: MockResponseOptions): Response;
-/** Creates an error Response with default status text. */
-export declare function mockErrorResponse(status: number, body?: string | object, options?: Omit<MockResponseOptions, 'status'>): Response;
-/** Creates a mock fetch function. */
-export declare function createMockFetch(options?: CreateMockFetchOptions): MockFetch;
-/**
- * Installs mock fetch globally. Returns mockFetch for configuration -
- * the wrapper always captures calls before delegating to mockFetch.
- */
-export declare function installMockFetch(options?: CreateMockFetchOptions): InstallMockFetchResult;

package/dist/common/src/testing/mocks/filesystem.d.ts

@@ -1,31 +0,0 @@
-import type { LevelCodeFileSystem } from '../../types/filesystem';
-import type { Mock } from 'bun:test';
-import type { PathLike, Stats } from 'node:fs';
-export interface CreateMockFsOptions {
-    files?: Record<string, string>;
-    directories?: Record<string, string[]>;
-    readFileImpl?: (path: string) => Promise<string>;
-    readdirImpl?: (path: string) => Promise<string[]>;
-    writeFileImpl?: (path: string, content: string) => Promise<void>;
-    mkdirImpl?: (path: string, options?: {
-        recursive?: boolean;
-    }) => Promise<string | undefined>;
-    statImpl?: (path: string) => Promise<Stats>;
-}
-export interface MockFs extends LevelCodeFileSystem {
-}
-export interface MockFsWithMocks {
-    readFile: Mock<(path: PathLike, options?: {
-        encoding?: BufferEncoding;
-    }) => Promise<string>>;
-    readdir: Mock<(path: PathLike) => Promise<string[]>>;
-    writeFile: Mock<(path: PathLike, data: string) => Promise<void>>;
-    mkdir: Mock<(path: PathLike, options?: {
-        recursive?: boolean;
-    }) => Promise<string | undefined>>;
-    stat: Mock<(path: PathLike) => Promise<Stats>>;
-}
-/** Creates a mock filesystem compatible with LevelCodeFileSystem. */
-export declare function createMockFs(options?: CreateMockFsOptions): MockFs;
-export declare function restoreMockFs(mockFs: MockFs): void;
-export declare function clearMockFs(mockFs: MockFs): void;

package/dist/common/src/testing/mocks/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * Mock utilities index.
- *
- * Re-exports all mock factories for convenient importing.
- */
-export { createMockLogger, createMockLoggerWithCapture, restoreMockLogger, clearMockLogger, } from './logger';
-export type { LogLevel, LogMethod, MockLogMethod, MockLogger, CreateMockLoggerOptions, CapturedLogEntry, MockLoggerWithCapture, } from './logger';
-export { createMockAnalytics, createMockAnalyticsWithCapture, setupAnalyticsMocks, restoreMockAnalytics, } from './analytics';
-export type { MockAnalytics, MockAnalyticsWithCapture, AnalyticsSpies, CreateMockAnalyticsOptions, TrackedEvent, EventProperties, } from './analytics';
-export { createMockDbOperations, setupDbSpies } from './database';
-export type { MockDbOperations, DbSpies, CreateMockDbOptions } from './database';
-export { setupCryptoMocks, createMockUuid, TEST_UUIDS } from './crypto';
-export type { CryptoMockSpies, UUID, SetupCryptoMocksOptions } from './crypto';
-export { createUuidGenerator, setupSequentialCryptoMocks } from './crypto';
-export { createToolCallChunk, createMockStream, createMockTextStream, } from './stream';
-export { createMockTimers, installMockTimers } from './timers';
-export type { PendingTimer, MockTimers } from './timers';
-export { createMockFs, restoreMockFs, clearMockFs } from './filesystem';
-export type { MockFs, MockFsWithMocks, CreateMockFsOptions } from './filesystem';
-export { createMockFetch, installMockFetch, mockJsonResponse, mockTextResponse, mockErrorResponse, } from './fetch';
-export type { MockFetch, MockFetchCall, MockResponseOptions, CreateMockFetchOptions, InstallMockFetchResult, } from './fetch';
-export { createMockCapture, createMockTreeSitterCaptures, createMockTree, createMockTreeSitterParser, createMockTreeSitterQuery, createMockLanguageConfig, } from './tree-sitter';
-export type { MockTreeNode, MockTree, MockCapture, MockParser, MockQuery, CreateMockParserOptions, CreateMockQueryOptions, CreateMockLanguageConfigOptions, } from './tree-sitter';
-export { createMockChildProcess, createMockSpawn, asCodeSearchResult, createRgJsonMatch, createRgJsonContext, } from './child-process';
-export type { MockChildProcess, CodeSearchResult, } from './child-process';

package/dist/common/src/testing/mocks/logger.d.ts

@@ -1,35 +0,0 @@
-import type { Mock } from 'bun:test';
-export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
-export type LogMethod = (data: unknown, msg?: string, ...args: unknown[]) => unknown;
-export type MockLogMethod = Mock<LogMethod>;
-export interface MockLogger {
-    trace: MockLogMethod;
-    debug: MockLogMethod;
-    info: MockLogMethod;
-    warn: MockLogMethod;
-    error: MockLogMethod;
-    fatal: MockLogMethod;
-    child: Mock<(bindings: Record<string, unknown>) => MockLogger>;
-}
-export interface CreateMockLoggerOptions {
-    captureOutput?: boolean;
-    customImplementations?: Partial<Record<LogLevel, LogMethod>>;
-}
-export interface CapturedLogEntry {
-    level: LogLevel;
-    message: string;
-    meta?: Record<string, unknown>;
-    timestamp: Date;
-}
-export declare function createMockLogger(options?: CreateMockLoggerOptions): MockLogger;
-export interface MockLoggerWithCapture {
-    logger: MockLogger;
-    captured: CapturedLogEntry[];
-    clearCaptured: () => void;
-    getByLevel: (level: LogLevel) => CapturedLogEntry[];
-    getByMessage: (pattern: string | RegExp) => CapturedLogEntry[];
-}
-/** Creates a mock logger that captures all output for inspection. */
-export declare function createMockLoggerWithCapture(): MockLoggerWithCapture;
-export declare function restoreMockLogger(logger: MockLogger): void;
-export declare function clearMockLogger(logger: MockLogger): void;

package/dist/common/src/testing/mocks/stream.d.ts

@@ -1,203 +0,0 @@
-/**
- * Typed stream mock factory for testing LLM streaming.
- *
- * Provides type-safe utilities for creating mock LLM streams
- * and testing streaming behavior.
- *
- * @example
- * ```typescript
- * import { createMockStream, createToolCallChunk } from '@levelcode/common/testing/mocks/stream'
- *
- * // Create a mock stream with text and tool calls
- * const stream = createMockStream([
- *   { type: 'text', text: 'Hello ' },
- *   { type: 'text', text: 'world!' },
- *   createToolCallChunk('end_turn', {}),
- * ])
- *
- * // Use in tests
- * for await (const chunk of stream) {
- *   console.log(chunk)
- * }
- * ```
- */
-import type { Mock } from 'bun:test';
-/**
- * A text chunk from an LLM stream.
- */
-export interface TextChunk {
-    type: 'text';
-    text: string;
-    agentId?: string;
-}
-/**
- * A tool call chunk from an LLM stream.
- */
-export interface ToolCallChunk {
-    type: 'tool-call';
-    toolName: string;
-    toolCallId: string;
-    input: Record<string, unknown>;
-}
-/**
- * A reasoning chunk from an LLM stream.
- */
-export interface ReasoningChunk {
-    type: 'reasoning';
-    text: string;
-}
-/**
- * Union of all stream chunk types.
- */
-export type StreamChunk = TextChunk | ToolCallChunk | ReasoningChunk;
-/**
- * Options for creating a tool call chunk.
- */
-export interface CreateToolCallOptions {
-    /**
-     * Custom tool call ID. If not provided, a random one is generated.
-     */
-    toolCallId?: string;
-}
-/**
- * Creates a tool call chunk for testing.
- *
- * @param toolName - The name of the tool being called
- * @param input - The input parameters for the tool
- * @param options - Additional options
- * @returns A properly typed tool call chunk
- *
- * @example
- * ```typescript
- * const chunk = createToolCallChunk('read_files', { paths: ['file.ts'] })
- * // { type: 'tool-call', toolName: 'read_files', toolCallId: 'tool-call-1', input: { paths: ['file.ts'] } }
- * ```
- */
-export declare function createToolCallChunk(toolName: string, input: Record<string, unknown>, options?: CreateToolCallOptions): ToolCallChunk;
-/**
- * Creates a text chunk for testing.
- *
- * @param text - The text content
- * @param agentId - Optional agent ID for subagent chunks
- * @returns A text chunk
- *
- * @example
- * ```typescript
- * const chunk = createTextChunk('Hello world!')
- * // { type: 'text', text: 'Hello world!' }
- * ```
- */
-export declare function createTextChunk(text: string, agentId?: string): TextChunk;
-/**
- * Creates a reasoning chunk for testing.
- *
- * @param text - The reasoning text
- * @returns A reasoning chunk
- */
-export declare function createReasoningChunk(text: string): ReasoningChunk;
-/**
- * Creates a mock async generator that yields the provided chunks.
- *
- * @param chunks - The chunks to yield
- * @param returnValue - The value to return when the generator completes
- * @returns An async generator that yields the chunks
- *
- * @example
- * ```typescript
- * const stream = createMockStream([
- *   createTextChunk('Processing...'),
- *   createToolCallChunk('read_files', { paths: ['test.ts'] }),
- *   createTextChunk('Done!'),
- *   createToolCallChunk('end_turn', {}),
- * ])
- *
- * // Consume the stream
- * const chunks = []
- * for await (const chunk of stream) {
- *   chunks.push(chunk)
- * }
- * ```
- */
-export declare function createMockStream(chunks: StreamChunk[], returnValue?: string | null): AsyncGenerator<StreamChunk, string | null, undefined>;
-/**
- * Creates a mock stream that yields text in multiple chunks.
- * Useful for testing streaming text display.
- *
- * @param text - The complete text to stream
- * @param chunkSize - Size of each chunk
- * @param endWithTool - Whether to end with an end_turn tool call
- * @returns A mock stream
- *
- * @example
- * ```typescript
- * const stream = createMockTextStream('Hello world!', 3)
- * // Yields: 'Hel', 'lo ', 'wor', 'ld!'
- * ```
- */
-export declare function createMockTextStream(text: string, chunkSize?: number, endWithTool?: boolean): AsyncGenerator<StreamChunk, string | null, undefined>;
-/**
- * Options for creating a mock prompt function.
- */
-export interface MockPromptOptions {
-    /**
-     * Default response text.
-     */
-    defaultResponse?: string;
-    /**
-     * Whether to include an end_turn tool call.
-     */
-    includeEndTurn?: boolean;
-    /**
-     * Custom chunks to yield.
-     */
-    chunks?: StreamChunk[];
-}
-/**
- * Mock prompt function result type.
- */
-export type MockPromptFn = Mock<(params: Record<string, unknown>) => AsyncGenerator<StreamChunk, string | null>>;
-/**
- * Creates a mock promptAiSdkStream function for testing.
- *
- * @param options - Configuration options
- * @returns A mock function that returns streams
- *
- * @example
- * ```typescript
- * const mockPrompt = createMockPromptAiSdkStream({
- *   defaultResponse: 'I understand your request.',
- * })
- *
- * loopAgentStepsBaseParams.promptAiSdkStream = mockPrompt
- *
- * await loopAgentSteps({ ...params })
- *
- * expect(mockPrompt).toHaveBeenCalledTimes(1)
- * ```
- */
-export declare function createMockPromptAiSdkStream(options?: MockPromptOptions): MockPromptFn;
-/**
- * Collects all chunks from a stream into an array.
- * Useful for testing stream content.
- *
- * @param stream - The stream to collect from
- * @returns An array of all chunks and the return value
- *
- * @example
- * ```typescript
- * const stream = createMockStream([...])
- * const { chunks, returnValue } = await collectStreamChunks(stream)
- *
- * expect(chunks).toHaveLength(3)
- * expect(returnValue).toBe('mock-message-id')
- * ```
- */
-export declare function collectStreamChunks<T, R>(stream: AsyncGenerator<T, R, undefined>): Promise<{
-    chunks: T[];
-    returnValue: R;
-}>;
-/**
- * Resets the tool call ID counter.
- * Call this in beforeEach to ensure deterministic IDs.
- */
-export declare function resetToolCallIdCounter(): void;

package/dist/common/src/testing/mocks/timers.d.ts

@@ -1,27 +0,0 @@
-/**
- * @deprecated Use Bun's built-in mock.setSystemTime() instead.
- */
-export interface PendingTimer {
-    id: number;
-    ms: number;
-    fn: () => void;
-    active: boolean;
-    createdAt: number;
-}
-export interface MockTimers {
-    setTimeout: typeof globalThis.setTimeout;
-    clearTimeout: typeof globalThis.clearTimeout;
-    install: () => void;
-    restore: () => void;
-    runAll: () => void;
-    advanceBy: (ms: number) => void;
-    getPending: () => PendingTimer[];
-    getPendingCount: () => number;
-    clearAll: () => void;
-    isPending: (id: number) => boolean;
-    getNext: () => PendingTimer | undefined;
-}
-/** @deprecated Use Bun's built-in mock.setSystemTime() instead. */
-export declare function createMockTimers(): MockTimers;
-/** @deprecated Use Bun's built-in mock.setSystemTime() instead. */
-export declare function installMockTimers(): MockTimers;

package/dist/common/src/testing/mocks/tree-sitter.d.ts

@@ -1,58 +0,0 @@
-export interface MockTreeNode {
-    text: string;
-    type?: string;
-    startPosition?: {
-        row: number;
-        column: number;
-    };
-    endPosition?: {
-        row: number;
-        column: number;
-    };
-    children?: MockTreeNode[];
-}
-export interface MockTree {
-    rootNode: MockTreeNode;
-}
-export interface MockCapture {
-    name: string;
-    node: MockTreeNode;
-}
-export interface MockParser {
-    parse: (input: string) => MockTree | null;
-}
-export interface MockQuery {
-    captures: (node: MockTreeNode) => MockCapture[];
-}
-export interface CreateMockParserOptions {
-    tree?: MockTree | null;
-    parseImpl?: (input: string) => MockTree | null;
-}
-export interface CreateMockQueryOptions {
-    captures?: MockCapture[];
-    capturesImpl?: (node: MockTreeNode) => MockCapture[];
-}
-export declare function createMockCapture(name: string, text: string): MockCapture;
-export declare function createMockTreeSitterCaptures(items: Array<{
-    name: string;
-    text: string;
-}>): MockCapture[];
-export declare function createMockTree(rootNodeText?: string): MockTree;
-export declare function createMockTreeSitterParser(options?: CreateMockParserOptions): MockParser;
-export declare function createMockTreeSitterQuery(options?: CreateMockQueryOptions): MockQuery;
-export interface CreateMockLanguageConfigOptions {
-    extensions?: string[];
-    wasmFile?: string;
-    queryText?: string;
-    parser?: MockParser | null;
-    query?: MockQuery | null;
-    captures?: MockCapture[];
-    tree?: MockTree | null;
-}
-export declare function createMockLanguageConfig(options?: CreateMockLanguageConfigOptions): {
-    extensions: string[];
-    wasmFile: string;
-    queryText: string;
-    parser: MockParser | null;
-    query: MockQuery | null;
-};

package/dist/common/src/testing-env-process.d.ts

@@ -1,7 +0,0 @@
-import type { BaseEnv, ProcessEnv } from './types/contracts/env';
-/**
- * Test-only helpers for process env snapshots.
- * Keep production code using `@levelcode/common/env-process`.
- */
-export declare const createTestBaseEnv: (overrides?: Partial<BaseEnv>) => BaseEnv;
-export declare const createTestProcessEnv: (overrides?: Partial<ProcessEnv>) => ProcessEnv;

package/dist/common/src/tools/constants.d.ts

@@ -1,17 +0,0 @@
-import type { ToolResultOutput } from '../types/messages/content-part';
-import type { Tool } from 'ai';
-export declare const toolNameParam = "cb_tool_name";
-export declare const endsAgentStepParam = "cb_easp";
-export declare const toolXmlName = "levelcode_tool_call";
-export declare const startToolTag = "<levelcode_tool_call>\n";
-export declare const endToolTag = "\n</levelcode_tool_call>";
-export declare const TOOLS_WHICH_WONT_FORCE_NEXT_STEP: string[];
-export declare const toolNames: readonly ["add_subgoal", "add_message", "ask_user", "browser_logs", "code_search", "create_plan", "end_turn", "find_files", "glob", "list_directory", "lookup_agent_info", "propose_str_replace", "propose_write_file", "read_docs", "read_files", "read_subtree", "run_file_change_hooks", "run_terminal_command", "send_message", "set_messages", "set_output", "skill", "spawn_agents", "spawn_agent_inline", "str_replace", "suggest_followups", "task_completed", "task_create", "task_get", "task_list", "task_update", "team_create", "team_delete", "think_deeply", "update_subgoal", "web_search", "write_file", "write_todos"];
-export declare const publishedTools: readonly ["add_message", "ask_user", "code_search", "end_turn", "find_files", "glob", "list_directory", "lookup_agent_info", "propose_str_replace", "propose_write_file", "read_docs", "read_files", "read_subtree", "run_file_change_hooks", "run_terminal_command", "set_messages", "set_output", "skill", "spawn_agents", "str_replace", "suggest_followups", "task_completed", "think_deeply", "web_search", "write_file", "write_todos"];
-export type ToolName = (typeof toolNames)[number];
-export type PublishedToolName = (typeof publishedTools)[number];
-/** Only used for validating tool definitions */
-export type $ToolParams<T extends ToolName = ToolName> = Required<Pick<Tool<any, ToolResultOutput[]>, 'description' | 'inputSchema' | 'outputSchema'>> & {
-    toolName: T;
-    endsAgentStep: boolean;
-};