@levelcode/sdk 0.2.2 → 0.2.4

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

@@ -0,0 +1,370 @@
+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;
+        trackEvent: import("@levelcode/common/types/contracts/analytics").TrackEventFn;
+        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, trackEvent, userId, logger, agentTemplate, }: {
+        previousToolCallFinished: Promise<any>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_completed">;
+        trackEvent: import("@levelcode/common/types/contracts/analytics").TrackEventFn;
+        userId: string | undefined;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+        agentTemplate: {
+            name: string;
+        };
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_completed">;
+    }>;
+    task_create: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_create">;
+        agentStepId: string;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_create">;
+    }>;
+    task_get: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_get">;
+        agentStepId: string;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_get">;
+    }>;
+    task_list: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_list">;
+        agentStepId: string;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_list">;
+    }>;
+    task_update: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"task_update">;
+        agentStepId: string;
+        trackEvent: import("@levelcode/common/types/contracts/analytics").TrackEventFn;
+        userId: string | undefined;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"task_update">;
+    }>;
+    send_message: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"send_message">;
+        agentStepId: string;
+        trackEvent: import("@levelcode/common/types/contracts/analytics").TrackEventFn;
+        userId: string | undefined;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"send_message">;
+    }>;
+    team_create: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"team_create">;
+        agentStepId: string;
+        trackEvent: import("@levelcode/common/types/contracts/analytics").TrackEventFn;
+        userId: string | undefined;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+    }) => Promise<{
+        output: import("src").LevelCodeToolOutput<"team_create">;
+    }>;
+    team_delete: (params: {
+        previousToolCallFinished: Promise<void>;
+        toolCall: import("@levelcode/common/tools/list").LevelCodeToolCall<"team_delete">;
+        agentStepId: string;
+        trackEvent: import("@levelcode/common/types/contracts/analytics").TrackEventFn;
+        userId: string | undefined;
+        logger: import("@levelcode/common/types/contracts/logger").Logger;
+    }) => 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">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/create-plan.d.ts

@@ -0,0 +1,13 @@
+import type { FileProcessingState } from './write-file';
+import type { ClientToolCall, LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+export declare const handleCreatePlan: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"create_plan">;
+    fileProcessingState: FileProcessingState;
+    logger: Logger;
+    requestClientToolCall: (toolCall: ClientToolCall<"create_plan">) => Promise<LevelCodeToolOutput<"create_plan">>;
+    writeToClient: (chunk: string) => void;
+}) => Promise<{
+    output: LevelCodeToolOutput<"create_plan">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/end-turn.d.ts

@@ -0,0 +1,7 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+export declare const handleEndTurn: (params: {
+    previousToolCallFinished: Promise<any>;
+    toolCall: LevelCodeToolCall<"end_turn">;
+}) => Promise<{
+    output: LevelCodeToolOutput<"end_turn">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/find-files.d.ts

@@ -0,0 +1,27 @@
+import { requestRelevantFiles, requestRelevantFilesForTraining } from '../../../find-files/request-files-prompt';
+import { getFileReadingUpdates } from '../../../get-file-reading-updates';
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { RequestFilesFn } from '@levelcode/common/types/contracts/client';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding, ParamsOf } from '@levelcode/common/types/function-params';
+import type { AgentState } from '@levelcode/common/types/session-state';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+export declare const handleFindFiles: (params: {
+    previousToolCallFinished: Promise<any>;
+    toolCall: LevelCodeToolCall<"find_files">;
+    logger: Logger;
+    agentState: AgentState;
+    agentStepId: string;
+    clientSessionId: string;
+    fileContext: ProjectFileContext;
+    fingerprintId: string;
+    repoId: string | undefined;
+    userId: string | undefined;
+    userInputId: string;
+} & ParamsExcluding<typeof requestRelevantFiles, "messages" | "system" | "assistantPrompt"> & ParamsExcluding<typeof uploadExpandedFileContextForTraining, "messages" | "system" | "assistantPrompt"> & ParamsExcluding<typeof getFileReadingUpdates, "requestedFiles">) => Promise<{
+    output: LevelCodeToolOutput<"find_files">;
+}>;
+declare function uploadExpandedFileContextForTraining(params: {
+    requestFiles: RequestFilesFn;
+} & ParamsOf<typeof requestRelevantFilesForTraining>): Promise<void>;
+export {};

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

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

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

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

package/dist/packages/agent-runtime/src/tools/handlers/tool/lookup-agent-info.d.ts

@@ -0,0 +1,14 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { AgentTemplate, Logger } from '@levelcode/common/types/agent-template';
+import type { FetchAgentFromDatabaseFn } from '@levelcode/common/types/contracts/database';
+export declare const handleLookupAgentInfo: (params: {
+    toolCall: LevelCodeToolCall<"lookup_agent_info">;
+    previousToolCallFinished: Promise<void>;
+    apiKey: string;
+    databaseAgentCache: Map<string, AgentTemplate | null>;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    fetchAgentFromDatabase: FetchAgentFromDatabaseFn;
+}) => Promise<{
+    output: LevelCodeToolOutput<"lookup_agent_info">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/propose-str-replace.d.ts

@@ -0,0 +1,15 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { RequestOptionalFileFn } from '@levelcode/common/types/contracts/client';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { AgentState } from '@levelcode/common/types/session-state';
+export declare const handleProposeStrReplace: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"propose_str_replace">;
+    logger: Logger;
+    agentState: AgentState;
+    runId: string;
+    requestOptionalFile: RequestOptionalFileFn;
+} & ParamsExcluding<RequestOptionalFileFn, "filePath">) => Promise<{
+    output: LevelCodeToolOutput<"propose_str_replace">;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/propose-write-file.d.ts

@@ -0,0 +1,7 @@
+import type { LevelCodeToolHandlerFunction } from '../handler-function-type';
+/**
+ * Proposes writing a file without actually applying the changes.
+ * Simply overwrites the file exactly with the given content (creating if it doesn't exist).
+ * Returns a unified diff of the changes for review.
+ */
+export declare const handleProposeWriteFile: LevelCodeToolHandlerFunction<"propose_write_file">;

package/dist/packages/agent-runtime/src/tools/handlers/tool/proposed-content-store.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Store for proposed file content by runId.
+ * This allows propose_str_replace and propose_write_file tools to
+ * track proposed changes within an agent run, isolated by runId.
+ */
+/**
+ * Get the proposed content map for a specific runId.
+ * Creates an empty record if none exists.
+ */
+export declare function getProposedContentForRun(runId: string): Record<string, Promise<string | null>>;
+/**
+ * Get proposed content for a specific file in a run.
+ */
+export declare function getProposedContent(runId: string, path: string): Promise<string | null> | undefined;
+/**
+ * Set proposed content for a specific file in a run.
+ */
+export declare function setProposedContent(runId: string, path: string, content: Promise<string | null>): void;
+/**
+ * Clear all proposed content for a specific runId.
+ * Should be called when an agent run completes.
+ */
+export declare function clearProposedContentForRun(runId: string): void;
+/**
+ * Clear all proposed content (for testing purposes).
+ */
+export declare function clearAllProposedContent(): void;

package/dist/packages/agent-runtime/src/tools/handlers/tool/read-docs.d.ts

@@ -0,0 +1,21 @@
+import type { fetchContext7LibraryDocumentation } from '../../../llm-api/context7-api';
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { ClientEnv, CiEnv } from '@levelcode/common/types/contracts/env';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+export declare const handleReadDocs: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"read_docs">;
+    agentStepId: string;
+    clientSessionId: string;
+    fingerprintId: string;
+    logger: Logger;
+    repoId: string | undefined;
+    userId: string | undefined;
+    userInputId: string;
+    clientEnv: ClientEnv;
+    ciEnv: CiEnv;
+} & ParamsExcluding<typeof fetchContext7LibraryDocumentation, "query" | "topic" | "tokens">) => Promise<{
+    output: LevelCodeToolOutput<"read_docs">;
+    creditsUsed: number;
+}>;

package/dist/packages/agent-runtime/src/tools/handlers/tool/read-files.d.ts

@@ -0,0 +1,13 @@
+import { getFileReadingUpdates } from '../../../get-file-reading-updates';
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+type ToolName = 'read_files';
+export declare const handleReadFiles: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    fileContext: ProjectFileContext;
+} & ParamsExcluding<typeof getFileReadingUpdates, "requestedFiles">) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

package/dist/packages/agent-runtime/src/tools/handlers/tool/read-subtree.d.ts

@@ -0,0 +1,13 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+type ToolName = 'read_subtree';
+export declare const handleReadSubtree: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    fileContext: ProjectFileContext;
+    logger: Logger;
+}) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

package/dist/packages/agent-runtime/src/tools/handlers/tool/run-file-change-hooks.d.ts

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