@levelcode/sdk 0.0.4 → 0.1.0

package/dist/packages/agent-runtime/src/system-prompt/search-system-prompt.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+export declare function getSearchSystemPrompt(params: {
+    fileContext: ProjectFileContext;
+    messagesTokens: number;
+    logger: Logger;
+    options: {
+        agentStepId: string;
+        clientSessionId: string;
+        fingerprintId: string;
+        userInputId: string;
+        userId: string | undefined;
+    };
+}): string;

package/dist/packages/agent-runtime/src/system-prompt/truncate-file-tree.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+type TruncationLevel = 'none' | 'unimportant-files' | 'tokens' | 'depth-based';
+export declare const truncateFileTreeBasedOnTokenBudget: (params: {
+    fileContext: ProjectFileContext;
+    tokenBudget: number;
+    logger: Logger;
+}) => {
+    printedTree: string;
+    tokenCount: number;
+    truncationLevel: TruncationLevel;
+};
+export {};

package/dist/packages/agent-runtime/src/templates/agent-registry.d.ts

@@ -0,0 +1,35 @@
+import type { DynamicAgentValidationError } from '@levelcode/common/templates/agent-validation';
+import type { AgentTemplate } from '@levelcode/common/types/agent-template';
+import type { FetchAgentFromDatabaseFn } from '@levelcode/common/types/contracts/database';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+/**
+ * Single function to look up an agent template with clear priority order:
+ * 1. localAgentTemplates (dynamic agents + static templates)
+ * 2. Database cache
+ * 3. Database query
+ */
+export declare function getAgentTemplate(params: {
+    agentId: string;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    fetchAgentFromDatabase: FetchAgentFromDatabaseFn;
+    databaseAgentCache: Map<string, AgentTemplate | null>;
+    logger: Logger;
+} & ParamsExcluding<FetchAgentFromDatabaseFn, 'parsedAgentId'>): Promise<AgentTemplate | null>;
+/**
+ * Assemble local agent templates from fileContext + static templates
+ */
+export declare function assembleLocalAgentTemplates(params: {
+    fileContext: ProjectFileContext;
+    logger: Logger;
+}): {
+    agentTemplates: Record<string, AgentTemplate>;
+    validationErrors: DynamicAgentValidationError[];
+};
+/**
+ * Clear the database agent cache (useful for testing)
+ */
+export declare function clearDatabaseCache(params: {
+    databaseAgentCache: Map<string, AgentTemplate | null>;
+}): void;

package/dist/packages/agent-runtime/src/templates/prompts.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod/v4';
+import { getAgentTemplate } from './agent-registry';
+import type { AgentTemplate } from '@levelcode/common/types/agent-template';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { AgentTemplateType } from '@levelcode/common/types/session-state';
+import type { ToolSet } from 'ai';
+/**
+ * Gets the short agent name from a fully qualified agent ID.
+ * E.g., 'levelcode/file-picker@1.0.0' -> 'file-picker'
+ */
+export declare function getAgentShortName(agentType: AgentTemplateType): string;
+/**
+ * Builds an input schema for an agent tool with prompt and params as top-level fields.
+ * This matches the spawn_agents schema structure: { prompt?: string, params?: object }
+ */
+export declare function buildAgentToolInputSchema(agentTemplate: AgentTemplate): z.ZodType;
+/**
+ * Builds AI SDK tool definitions for spawnable agents.
+ * These tools allow the model to call agents directly as tool calls.
+ */
+export declare function buildAgentToolSet(params: {
+    spawnableAgents: AgentTemplateType[];
+    agentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+} & ParamsExcluding<typeof getAgentTemplate, 'agentId' | 'localAgentTemplates'>): Promise<ToolSet>;
+/**
+ * Builds the full spawnable agents specification for subagent instructions.
+ * This is used when inheritSystemPrompt is true to tell subagents which agents they can spawn.
+ */
+export declare function buildFullSpawnableAgentsSpec(params: {
+    spawnableAgents: AgentTemplateType[];
+    agentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+} & ParamsExcluding<typeof getAgentTemplate, 'agentId' | 'localAgentTemplates'>): Promise<string>;

package/dist/packages/agent-runtime/src/templates/strings.d.ts

@@ -0,0 +1,32 @@
+import { getAgentTemplate } from './agent-registry';
+import { buildFullSpawnableAgentsSpec } from './prompts';
+import type { AgentTemplate } from './types';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { AgentState, AgentTemplateType } from '@levelcode/common/types/session-state';
+import type { CustomToolDefinitions, ProjectFileContext } from '@levelcode/common/util/file';
+export declare function formatPrompt(params: {
+    prompt: string;
+    fileContext: ProjectFileContext;
+    agentState: AgentState;
+    tools: readonly string[];
+    spawnableAgents: AgentTemplateType[];
+    agentTemplates: Record<string, AgentTemplate>;
+    intitialAgentPrompt?: string;
+    additionalToolDefinitions: () => Promise<ProjectFileContext['customToolDefinitions']>;
+    logger: Logger;
+} & ParamsExcluding<typeof getAgentTemplate, 'agentId' | 'localAgentTemplates'>): Promise<string>;
+type StringField = 'systemPrompt' | 'instructionsPrompt' | 'stepPrompt';
+export declare function getAgentPrompt<T extends StringField>(params: {
+    agentTemplate: AgentTemplate;
+    promptType: {
+        type: T;
+    };
+    fileContext: ProjectFileContext;
+    agentState: AgentState;
+    agentTemplates: Record<string, AgentTemplate>;
+    additionalToolDefinitions: () => Promise<CustomToolDefinitions>;
+    logger: Logger;
+    useParentTools?: boolean;
+} & ParamsExcluding<typeof formatPrompt, 'prompt' | 'tools' | 'spawnableAgents'> & ParamsExcluding<typeof buildFullSpawnableAgentsSpec, 'spawnableAgents' | 'agentTemplates'>): Promise<string | undefined>;
+export {};

package/dist/packages/agent-runtime/src/templates/types.d.ts

@@ -0,0 +1,13 @@
+import type { ToolName } from '@levelcode/common/tools/constants';
+import type { AgentTemplate, StepGenerator, StepHandler } from '@levelcode/common/types/agent-template';
+import type { AgentTemplateType } from '@levelcode/common/types/session-state';
+export type { AgentTemplate, StepGenerator, StepHandler };
+declare const placeholderNames: readonly ["AGENT_NAME", "FILE_TREE_PROMPT_SMALL", "FILE_TREE_PROMPT", "FILE_TREE_PROMPT_LARGE", "GIT_CHANGES_PROMPT", "INITIAL_AGENT_PROMPT", "KNOWLEDGE_FILES_CONTENTS", "PROJECT_ROOT", "REMAINING_STEPS", "SYSTEM_INFO_PROMPT", "USER_CWD", "USER_INPUT_PROMPT"];
+type PlaceholderType<T extends typeof placeholderNames> = {
+    [K in T[number]]: `{LEVELCODE_${K}}`;
+};
+export declare const PLACEHOLDER: PlaceholderType<typeof placeholderNames>;
+export type PlaceholderValue = (typeof PLACEHOLDER)[keyof typeof PLACEHOLDER];
+export declare const placeholderValues: ("{LEVELCODE_AGENT_NAME}" | "{LEVELCODE_FILE_TREE_PROMPT_SMALL}" | "{LEVELCODE_FILE_TREE_PROMPT}" | "{LEVELCODE_FILE_TREE_PROMPT_LARGE}" | "{LEVELCODE_GIT_CHANGES_PROMPT}" | "{LEVELCODE_INITIAL_AGENT_PROMPT}" | "{LEVELCODE_KNOWLEDGE_FILES_CONTENTS}" | "{LEVELCODE_PROJECT_ROOT}" | "{LEVELCODE_REMAINING_STEPS}" | "{LEVELCODE_SYSTEM_INFO_PROMPT}" | "{LEVELCODE_USER_CWD}" | "{LEVELCODE_USER_INPUT_PROMPT}")[];
+export declare const baseAgentToolNames: ToolName[];
+export declare const baseAgentSubagents: AgentTemplateType[];

package/dist/packages/agent-runtime/src/tool-stream-parser.d.ts

@@ -0,0 +1,31 @@
+import type { Model } from '@levelcode/common/old-constants';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { StreamChunk } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { PrintModeError, PrintModeText } from '@levelcode/common/types/print-mode';
+import type { PromptResult } from '@levelcode/common/util/error';
+export declare function processStreamWithTools(params: {
+    stream: AsyncGenerator<StreamChunk, PromptResult<string | null>>;
+    processors: Record<string, {
+        onTagStart: (tagName: string, attributes: Record<string, string>) => void;
+        onTagEnd: (tagName: string, params: Record<string, any>) => void;
+    }>;
+    defaultProcessor: (toolName: string) => {
+        onTagStart: (tagName: string, attributes: Record<string, string>) => void;
+        onTagEnd: (tagName: string, params: Record<string, any>) => void;
+    };
+    onError: (tagName: string, errorMessage: string) => void;
+    onResponseChunk: (chunk: PrintModeText | PrintModeError) => void;
+    logger: Logger;
+    loggerOptions?: {
+        userId?: string;
+        model?: Model;
+        agentName?: string;
+    };
+    trackEvent: TrackEventFn;
+    executeXmlToolCall: (params: {
+        toolCallId: string;
+        toolName: string;
+        input: Record<string, unknown>;
+    }) => Promise<void>;
+}): AsyncGenerator<StreamChunk, PromptResult<string | null>>;

package/dist/packages/agent-runtime/src/tools/handlers/handler-function-type.d.ts

@@ -0,0 +1,51 @@
+import type { FileProcessingState } from './tool/write-file';
+import type { ToolName } from '@levelcode/common/tools/constants';
+import type { ClientToolCall, ClientToolName, LevelCodeToolCall, LevelCodeToolMessage, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { AgentTemplate } from '@levelcode/common/types/agent-template';
+import type { AgentRuntimeDeps, AgentRuntimeScopedDeps } from '@levelcode/common/types/contracts/agent-runtime';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { SendSubagentChunkFn } from '@levelcode/common/types/contracts/client';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { AgentState, Subgoal } from '@levelcode/common/types/session-state';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+import type { ToolSet } from 'ai';
+type PresentOrAbsent<K extends PropertyKey, V> = {
+    [P in K]: V;
+} | {
+    [P in K]: never;
+};
+export type LevelCodeToolHandlerFunction<T extends ToolName = ToolName> = (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<T>;
+    agentContext: Record<string, Subgoal>;
+    agentState: AgentState;
+    agentStepId: string;
+    agentTemplate: AgentTemplate;
+    ancestorRunIds: string[];
+    apiKey: string;
+    clientSessionId: string;
+    fetch: typeof globalThis.fetch;
+    fileContext: ProjectFileContext;
+    fileProcessingState: FileProcessingState;
+    fingerprintId: string;
+    fullResponse: string;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    prompt: string | undefined;
+    repoId: string | undefined;
+    repoUrl: string | undefined;
+    runId: string;
+    sendSubagentChunk: SendSubagentChunkFn;
+    signal: AbortSignal;
+    system: string;
+    tools: ToolSet;
+    trackEvent: TrackEventFn;
+    userId: string | undefined;
+    userInputId: string;
+    writeToClient: (chunk: string | PrintModeEvent) => void;
+} & PresentOrAbsent<'requestClientToolCall', (toolCall: ClientToolCall<T extends ClientToolName ? T : never>) => Promise<LevelCodeToolOutput<T extends ClientToolName ? T : never>>> & AgentRuntimeDeps & AgentRuntimeScopedDeps) => Promise<{
+    output: LevelCodeToolMessage<T>['content'];
+    creditsUsed?: number;
+}>;
+export {};

package/dist/packages/agent-runtime/src/tools/handlers/list.d.ts

@@ -0,0 +1,347 @@
+import type { LevelCodeToolHandlerFunction } from './handler-function-type';
+/**
+ * Each value in this record that:
+ * - Will be called immediately once it is parsed out of the stream.
+ * - Takes as argument
+ *   - The previous tool call (to await)
+ *   - The LevelCodeToolCall for the current tool
+ *   - Any additional arguments for the tool
+ * - Returns a promise that will be awaited
+ */
+export declare const levelcodeToolHandlers: {
+    add_message: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"add_message">;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"add_message">;
+    }>;
+    add_subgoal: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"add_subgoal">;
+        agentContext: Record<string, import("@levelcode/common/types/session-state").Subgoal>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"add_subgoal">;
+    }>;
+    ask_user: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"ask_user">;
+        requestClientToolCall: (toolCall: any) => Promise<any>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"ask_user">;
+    }>;
+    browser_logs: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"browser_logs">;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"browser_logs">) => Promise<import("src").LevelCodeToolOutput<"browser_logs">>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"browser_logs">;
+    }>;
+    code_search: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"code_search">;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"code_search">) => Promise<import("src").LevelCodeToolOutput<"code_search">>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"code_search">;
+    }>;
+    create_plan: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"create_plan">;
+        fileProcessingState: import("./tool/write-file").FileProcessingState;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"create_plan">) => Promise<import("src").LevelCodeToolOutput<"create_plan">>;
+        writeToClient: (chunk: string) => void;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"create_plan">;
+    }>;
+    end_turn: (params: {
+        previousToolCallFinished: Promise<any>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"end_turn">;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"end_turn">;
+    }>;
+    find_files: (params: {
+        previousToolCallFinished: Promise<any>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"find_files">;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+        agentStepId: string;
+        clientSessionId: string;
+        fileContext: import("@levelcode/common/util/file").ProjectFileContext;
+        fingerprintId: string;
+        repoId: string | undefined;
+        userId: string | undefined;
+        userInputId: string;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("../../find-files/request-files-prompt").requestRelevantFiles, "messages" | "system" | "assistantPrompt"> & import("@levelcode/common/types/function-params").ParamsExcluding<(params: {
+        requestFiles: import("@levelcode/common/types/contracts/client").RequestFilesFn;
+    } & import("@levelcode/common/types/function-params").ParamsOf<typeof import("../../find-files/request-files-prompt").requestRelevantFilesForTraining>) => Promise<void>, "messages" | "system" | "assistantPrompt"> & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("../../get-file-reading-updates").getFileReadingUpdates, "requestedFiles">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"find_files">;
+    }>;
+    glob: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"glob">;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"glob">) => Promise<import("src").LevelCodeToolOutput<"glob">>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"glob">;
+    }>;
+    list_directory: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"list_directory">;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"list_directory">) => Promise<import("src").LevelCodeToolOutput<"list_directory">>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"list_directory">;
+    }>;
+    lookup_agent_info: (params: {
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"lookup_agent_info">;
+        previousToolCallFinished: Promise<void>;
+        apiKey: string;
+        databaseAgentCache: Map<string, import("@levelcode/common/types/agent-template").AgentTemplate | null>;
+        localAgentTemplates: Record<string, import("@levelcode/common/types/agent-template").AgentTemplate>;
+        logger: import("@levelcode/common/types/agent-template").Logger;
+        fetchAgentFromDatabase: import("@levelcode/common/types/contracts/database").FetchAgentFromDatabaseFn;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"lookup_agent_info">;
+    }>;
+    propose_str_replace: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"propose_str_replace">;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+        runId: string;
+        requestOptionalFile: import("@levelcode/common/types/contracts/client").RequestOptionalFileFn;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<import("@levelcode/common/types/contracts/client").RequestOptionalFileFn, "filePath">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"propose_str_replace">;
+    }>;
+    propose_write_file: LevelCodeToolHandlerFunction<"propose_write_file">;
+    read_docs: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"read_docs">;
+        agentStepId: string;
+        clientSessionId: string;
+        fingerprintId: string;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        repoId: string | undefined;
+        userId: string | undefined;
+        userInputId: string;
+        clientEnv: import("@levelcode/common/env-schema").ClientEnv;
+        ciEnv: import("@levelcode/common/types/contracts/env").CiEnv;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("../../llm-api/context7-api").fetchContext7LibraryDocumentation, "query" | "topic" | "tokens">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"read_docs">;
+        creditsUsed: number;
+    }>;
+    read_files: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"read_files">;
+        fileContext: import("@levelcode/common/util/file").ProjectFileContext;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("../../get-file-reading-updates").getFileReadingUpdates, "requestedFiles">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"read_files">;
+    }>;
+    read_subtree: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"read_subtree">;
+        fileContext: import("@levelcode/common/util/file").ProjectFileContext;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"read_subtree">;
+    }>;
+    run_file_change_hooks: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"run_file_change_hooks">;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"run_file_change_hooks">) => Promise<import("src").LevelCodeToolOutput<"run_file_change_hooks">>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"run_file_change_hooks">;
+    }>;
+    run_terminal_command: ({ previousToolCallFinished, toolCall, requestClientToolCall, }: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"run_terminal_command">;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"run_terminal_command">) => Promise<import("src").LevelCodeToolOutput<"run_terminal_command">>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"run_terminal_command">;
+    }>;
+    set_messages: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"set_messages">;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"set_messages">;
+    }>;
+    set_output: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"set_output">;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+        apiKey: string;
+        databaseAgentCache: Map<string, import("@levelcode/common/types/agent-template").AgentTemplate | null>;
+        localAgentTemplates: Record<string, import("@levelcode/common/types/agent-template").AgentTemplate>;
+        logger: import("@levelcode/common/types/agent-template").Logger;
+        fetchAgentFromDatabase: import("@levelcode/common/types/contracts/database").FetchAgentFromDatabaseFn;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"set_output">;
+    }>;
+    skill: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"skill">;
+        fileContext: import("@levelcode/common/util/file").ProjectFileContext;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"skill">;
+    }>;
+    spawn_agents: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"spawn_agents">;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+        agentTemplate: import("@levelcode/common/types/agent-template").AgentTemplate;
+        fingerprintId: string;
+        localAgentTemplates: Record<string, import("@levelcode/common/types/agent-template").AgentTemplate>;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        system: string;
+        tools?: import("ai").ToolSet;
+        userId: string | undefined;
+        userInputId: string;
+        sendSubagentChunk: import("./tool/spawn-agents").SendSubagentChunk;
+        writeToClient: (chunk: string | import("src").PrintModeEvent) => void;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("./tool/spawn-agent-utils").validateAndGetAgentTemplate, "agentTypeStr" | "parentAgentTemplate"> & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("./tool/spawn-agent-utils").executeSubagent, "userInputId" | "prompt" | "spawnParams" | "agentTemplate" | "parentAgentState" | "agentState" | "fingerprintId" | "isOnlyChild" | "parentSystemPrompt" | "parentTools" | "onResponseChunk">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"spawn_agents">;
+    }>;
+    spawn_agent_inline: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"spawn_agent_inline">;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+        agentTemplate: import("@levelcode/common/types/agent-template").AgentTemplate;
+        clientSessionId: string;
+        fileContext: import("@levelcode/common/util/file").ProjectFileContext;
+        fingerprintId: string;
+        localAgentTemplates: Record<string, import("@levelcode/common/types/agent-template").AgentTemplate>;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        system: string;
+        tools: import("ai").ToolSet;
+        userId: string | undefined;
+        userInputId: string;
+        writeToClient: (chunk: string | import("src").PrintModeEvent) => void;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("./tool/spawn-agent-utils").executeSubagent, "userInputId" | "prompt" | "spawnParams" | "agentTemplate" | "parentAgentState" | "agentState" | "parentSystemPrompt" | "parentTools" | "onResponseChunk" | "clearUserPromptMessagesAfterResponse" | "fingerprintId">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"spawn_agent_inline">;
+    }>;
+    str_replace: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"str_replace">;
+        fileProcessingState: import("./tool/write-file").FileProcessingState;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"str_replace">) => Promise<import("src").LevelCodeToolOutput<"str_replace">>;
+        writeToClient: (chunk: string) => void;
+        requestOptionalFile: import("@levelcode/common/types/contracts/client").RequestOptionalFileFn;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<import("@levelcode/common/types/contracts/client").RequestOptionalFileFn, "filePath">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"str_replace">;
+    }>;
+    suggest_followups: (params: {
+        previousToolCallFinished: Promise<unknown>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"suggest_followups">;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"suggest_followups">;
+    }>;
+    task_completed: ({ previousToolCallFinished, }: {
+        previousToolCallFinished: Promise<any>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_completed">;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_completed">;
+    }>;
+    task_create: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_create">;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_create">;
+    }>;
+    task_get: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_get">;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_get">;
+    }>;
+    task_list: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_list">;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_list">;
+    }>;
+    task_update: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_update">;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_update">;
+    }>;
+    send_message: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"send_message">;
+        agentStepId: string;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"send_message">;
+    }>;
+    team_create: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"team_create">;
+        agentStepId: string;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"team_create">;
+    }>;
+    team_delete: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"team_delete">;
+        agentStepId: string;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"team_delete">;
+    }>;
+    think_deeply: (params: {
+        previousToolCallFinished: Promise<any>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"think_deeply">;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"think_deeply">;
+    }>;
+    update_subgoal: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"update_subgoal">;
+        agentContext: Record<string, import("@levelcode/common/types/session-state").Subgoal>;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"update_subgoal">;
+    }>;
+    web_search: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"web_search">;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        apiKey: string;
+        agentStepId: string;
+        clientSessionId: string;
+        fingerprintId: string;
+        repoId: string | undefined;
+        repoUrl: string | undefined;
+        userInputId: string;
+        userId: string | undefined;
+        fetch: typeof globalThis.fetch;
+        clientEnv: import("@levelcode/common/env-schema").ClientEnv;
+        ciEnv: import("@levelcode/common/types/contracts/env").CiEnv;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"web_search">;
+        creditsUsed: number;
+    }>;
+    write_file: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"write_file">;
+        agentState: import("@levelcode/common/types/session-state").AgentState;
+        clientSessionId: string;
+        fileProcessingState: import("./tool/write-file").FileProcessingState;
+        fingerprintId: string;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        prompt: string | undefined;
+        userId: string | undefined;
+        userInputId: string;
+        requestClientToolCall: (toolCall: import("src").ClientToolCall<"write_file">) => Promise<import("src").LevelCodeToolOutput<"write_file">>;
+        requestOptionalFile: import("@levelcode/common/types/contracts/client").RequestOptionalFileFn;
+        writeToClient: (chunk: string) => void;
+    } & import("@levelcode/common/types/function-params").ParamsExcluding<typeof import("../../process-file-block").processFileBlock, "path" | "instructions" | "fingerprintId" | "initialContentPromise" | "newContent" | "messages" | "lastUserPrompt"> & import("@levelcode/common/types/function-params").ParamsExcluding<import("@levelcode/common/types/contracts/client").RequestOptionalFileFn, "filePath">) => Promise<{
+        output: import("src").LevelCodeToolOutput<"write_file">;
+    }>;
+    write_todos: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"write_todos">;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"write_todos">;
+    }>;
+};

package/dist/packages/agent-runtime/src/tools/handlers/tool/add-message.d.ts

@@ -0,0 +1,9 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { AgentState } from '@levelcode/common/types/session-state';
+export declare const handleAddMessage: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"add_message">;
+    agentState: AgentState;
+}) => Promise<{
+    output: LevelCodeToolOutput<"add_message">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/add-subgoal.d.ts

@@ -0,0 +1,9 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { Subgoal } from '@levelcode/common/types/session-state';
+export declare const handleAddSubgoal: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"add_subgoal">;
+    agentContext: Record<string, Subgoal>;
+}) => Promise<{
+    output: LevelCodeToolOutput<"add_subgoal">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/ask-user.d.ts

@@ -0,0 +1,10 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+type ToolName = 'ask_user';
+export declare const handleAskUser: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    requestClientToolCall: (toolCall: any) => Promise<any>;
+}) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

package/dist/packages/agent-runtime/src/tools/handlers/tool/browser-logs.d.ts

@@ -0,0 +1,8 @@
+import type { ClientToolCall, LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+export declare const handleBrowserLogs: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"browser_logs">;
+    requestClientToolCall: (toolCall: ClientToolCall<"browser_logs">) => Promise<LevelCodeToolOutput<"browser_logs">>;
+}) => Promise<{
+    output: LevelCodeToolOutput<"browser_logs">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/code-search.d.ts

@@ -0,0 +1,8 @@
+import type { ClientToolCall, LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+export declare const handleCodeSearch: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"code_search">;
+    requestClientToolCall: (toolCall: ClientToolCall<"code_search">) => Promise<LevelCodeToolOutput<"code_search">>;
+}) => Promise<{
+    output: LevelCodeToolOutput<"code_search">;
+}>;