@levelcode/sdk 0.2.2 → 0.2.3

package/dist/packages/agent-runtime/src/tools/handlers/tool/run-terminal-command.d.ts

@@ -0,0 +1,10 @@
+import type { ClientToolCall, LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+type ToolName = 'run_terminal_command';
+export declare const handleRunTerminalCommand: ({ previousToolCallFinished, toolCall, requestClientToolCall, }: {
+    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/send-message.d.ts

@@ -0,0 +1,15 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+type ToolName = 'send_message';
+export declare const handleSendMessage: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    agentStepId: string;
+    trackEvent: TrackEventFn;
+    userId: string | undefined;
+    logger: Logger;
+}) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

package/dist/packages/agent-runtime/src/tools/handlers/tool/set-messages.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 handleSetMessages: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"set_messages">;
+    agentState: AgentState;
+}) => Promise<{
+    output: LevelCodeToolOutput<"set_messages">;
+}>;

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

@@ -0,0 +1,18 @@
+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';
+import type { AgentState } from '@levelcode/common/types/session-state';
+type ToolName = 'set_output';
+export declare const handleSetOutput: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    agentState: AgentState;
+    apiKey: string;
+    databaseAgentCache: Map<string, AgentTemplate | null>;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    fetchAgentFromDatabase: FetchAgentFromDatabaseFn;
+}) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

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

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

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

@@ -0,0 +1,29 @@
+import { executeSubagent } from './spawn-agent-utils';
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+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 { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { AgentState } from '@levelcode/common/types/session-state';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+import type { ToolSet } from 'ai';
+type ToolName = 'spawn_agent_inline';
+export declare const handleSpawnAgentInline: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    agentState: AgentState;
+    agentTemplate: AgentTemplate;
+    clientSessionId: string;
+    fileContext: ProjectFileContext;
+    fingerprintId: string;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    system: string;
+    tools: ToolSet;
+    userId: string | undefined;
+    userInputId: string;
+    writeToClient: (chunk: string | PrintModeEvent) => void;
+} & ParamsExcluding<typeof executeSubagent, "userInputId" | "prompt" | "spawnParams" | "agentTemplate" | "parentAgentState" | "agentState" | "parentSystemPrompt" | "parentTools" | "onResponseChunk" | "clearUserPromptMessagesAfterResponse" | "fingerprintId">) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

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

@@ -0,0 +1,130 @@
+import { loopAgentSteps } from '../../../run-agent-step';
+import { getAgentTemplate } from '../../../templates/agent-registry';
+import type { AgentTemplate } from '@levelcode/common/types/agent-template';
+import type { AgentRuntimeDeps, AgentRuntimeScopedDeps } from '@levelcode/common/types/contracts/agent-runtime';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding, OptionalFields } from '@levelcode/common/types/function-params';
+import type { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { AgentState, AgentTemplateType, Subgoal } from '@levelcode/common/types/session-state';
+import type { TeamConfig, TeamRole } from '@levelcode/common/types/team-config';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+import type { ToolSet } from 'ai';
+/**
+ * Common context params needed for spawning subagents.
+ * These are the params that don't change between different spawn calls
+ * and are passed through from the parent agent runtime.
+ */
+export type SubagentContextParams = AgentRuntimeDeps & AgentRuntimeScopedDeps & {
+    clientSessionId: string;
+    fileContext: ProjectFileContext;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    repoId: string | undefined;
+    repoUrl: string | undefined;
+    signal: AbortSignal;
+    userId: string | undefined;
+};
+/**
+ * Extracts the common context params needed for spawning subagents.
+ * This avoids bugs from spreading all params with `...params` which can
+ * accidentally pass through params that should be overridden.
+ */
+export declare function extractSubagentContextParams(params: SubagentContextParams): SubagentContextParams;
+/**
+ * Checks if a parent agent is allowed to spawn a child agent
+ */
+export declare function getMatchingSpawn(spawnableAgents: AgentTemplateType[], childFullAgentId: string): AgentTemplateType | null;
+/**
+ * Synchronously transforms spawn_agents input to use 'commander-lite' instead of 'commander'
+ * when the parent agent doesn't have access to 'commander' but does have access to 'commander-lite'.
+ * This should be called BEFORE the tool call is streamed to the UI.
+ */
+export declare function transformSpawnAgentsInput(input: Record<string, unknown>, spawnableAgents: AgentTemplateType[]): Record<string, unknown>;
+/**
+ * Validates agent template and permissions
+ */
+export declare function validateAndGetAgentTemplate(params: {
+    agentTypeStr: string;
+    parentAgentTemplate: AgentTemplate;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+} & ParamsExcluding<typeof getAgentTemplate, 'agentId'>): Promise<{
+    agentTemplate: AgentTemplate;
+    agentType: string;
+}>;
+/**
+ * Validates prompt and params against agent schema
+ */
+export declare function validateAgentInput(agentTemplate: AgentTemplate, agentType: string, prompt?: string, params?: any): void;
+/**
+ * Creates a new agent state for spawned agents
+ */
+export declare function createAgentState(agentType: string, agentTemplate: AgentTemplate, parentAgentState: AgentState, agentContext: Record<string, Subgoal>): AgentState;
+/**
+ * Logs agent spawn information
+ */
+export declare function logAgentSpawn(params: {
+    agentTemplate: AgentTemplate;
+    agentType: string;
+    agentId: string;
+    parentId: string | undefined;
+    prompt?: string;
+    spawnParams?: any;
+    inline?: boolean;
+    logger: Logger;
+}): void;
+/**
+ * Executes a subagent using loopAgentSteps
+ */
+export declare function executeSubagent(options: OptionalFields<{
+    agentTemplate: AgentTemplate;
+    parentAgentState: AgentState;
+    parentTools?: ToolSet;
+    onResponseChunk: (chunk: string | PrintModeEvent) => void;
+    isOnlyChild?: boolean;
+    ancestorRunIds: string[];
+} & ParamsExcluding<typeof loopAgentSteps, 'agentType' | 'ancestorRunIds'>, 'isOnlyChild' | 'clearUserPromptMessagesAfterResponse'>): Promise<{
+    agentState: AgentState;
+    output: import("@levelcode/common/types/session-state").AgentOutput;
+}>;
+/**
+ * Options for registering a spawned agent as a team member.
+ */
+export interface TeamSpawnOptions {
+    teamName: string;
+    teamRole?: string;
+}
+/**
+ * Resolves a team_role to the corresponding agent template ID from agents/team/.
+ * For example, 'coordinator' maps to the coordinator agent template,
+ * 'manager' maps to the manager agent template, etc.
+ *
+ * Returns the agent template ID (which is the same as the role string for
+ * roles that have a dedicated template), or null if no template exists for
+ * the given role.
+ */
+export declare function resolveTeamRoleAgentType(teamRole: string): string | null;
+/**
+ * Validates that the spawning agent has authority to spawn an agent
+ * with the requested team role.
+ *
+ * Uses canManage from role-hierarchy to check that the spawner's role
+ * has a strictly higher authority level than the target role.
+ * Also checks getSpawnableRoles to ensure the specific role combination
+ * is allowed.
+ *
+ * @param spawnerRole - The team role of the agent performing the spawn
+ * @param targetRole - The team role being requested for the new agent
+ * @throws Error if the spawner lacks authority
+ */
+export declare function validateSpawnAuthority(spawnerRole: TeamRole, targetRole: TeamRole): void;
+/**
+ * Sends a notification to the team lead when a new agent joins the team.
+ * This is a fire-and-forget operation; errors are logged but not thrown.
+ */
+export declare function notifyTeamLead(teamName: string, teamConfig: TeamConfig, memberName: string, role: TeamRole, logger: Logger): Promise<void>;
+/**
+ * Registers a spawned agent as a member of an existing team.
+ * Returns the team context string to prepend to the agent's prompt,
+ * or null if the team does not exist.
+ */
+export declare function registerAgentAsTeamMember(agentId: string, agentType: string, options: TeamSpawnOptions, logger: Logger): Promise<string | null>;

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

@@ -0,0 +1,37 @@
+import { validateAndGetAgentTemplate, executeSubagent } from './spawn-agent-utils';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+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 { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { AgentState } from '@levelcode/common/types/session-state';
+import type { ToolSet } from 'ai';
+export type SendSubagentChunk = (data: {
+    userInputId: string;
+    agentId: string;
+    agentType: string;
+    chunk: string;
+    prompt?: string;
+    forwardToPrompt?: boolean;
+}) => void;
+type ToolName = 'spawn_agents';
+export declare const handleSpawnAgents: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    agentState: AgentState;
+    agentTemplate: AgentTemplate;
+    fingerprintId: string;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    system: string;
+    tools?: ToolSet;
+    trackEvent: TrackEventFn;
+    userId: string | undefined;
+    userInputId: string;
+    sendSubagentChunk: SendSubagentChunk;
+    writeToClient: (chunk: string | PrintModeEvent) => void;
+} & ParamsExcluding<typeof validateAndGetAgentTemplate, "agentTypeStr" | "parentAgentTemplate"> & ParamsExcluding<typeof executeSubagent, "userInputId" | "prompt" | "spawnParams" | "agentTemplate" | "parentAgentState" | "agentState" | "fingerprintId" | "isOnlyChild" | "parentSystemPrompt" | "parentTools" | "onResponseChunk">) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

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

@@ -0,0 +1,16 @@
+import type { FileProcessingState } from './write-file';
+import type { ClientToolCall, 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';
+export declare const handleStrReplace: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"str_replace">;
+    fileProcessingState: FileProcessingState;
+    logger: Logger;
+    requestClientToolCall: (toolCall: ClientToolCall<"str_replace">) => Promise<LevelCodeToolOutput<"str_replace">>;
+    writeToClient: (chunk: string) => void;
+    requestOptionalFile: RequestOptionalFileFn;
+} & ParamsExcluding<RequestOptionalFileFn, "filePath">) => Promise<{
+    output: LevelCodeToolOutput<"str_replace">;
+}>;

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

@@ -0,0 +1,9 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+export declare const handleSuggestFollowups: (params: {
+    previousToolCallFinished: Promise<unknown>;
+    toolCall: LevelCodeToolCall<"suggest_followups">;
+    logger: Logger;
+}) => Promise<{
+    output: LevelCodeToolOutput<"suggest_followups">;
+}>;

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

@@ -0,0 +1,15 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+export declare const handleTaskCompleted: ({ previousToolCallFinished, trackEvent, userId, logger, agentTemplate, }: {
+    previousToolCallFinished: Promise<any>;
+    toolCall: LevelCodeToolCall<"task_completed">;
+    trackEvent: TrackEventFn;
+    userId: string | undefined;
+    logger: Logger;
+    agentTemplate: {
+        name: string;
+    };
+}) => Promise<{
+    output: LevelCodeToolOutput<"task_completed">;
+}>;

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+type ToolName = 'task_update';
+export declare const handleTaskUpdate: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    agentStepId: string;
+    trackEvent: TrackEventFn;
+    userId: string | undefined;
+    logger: Logger;
+}) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

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

@@ -0,0 +1,15 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+type ToolName = 'team_create';
+export declare const handleTeamCreate: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    agentStepId: string;
+    trackEvent: TrackEventFn;
+    userId: string | undefined;
+    logger: Logger;
+}) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

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

@@ -0,0 +1,15 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+type ToolName = 'team_delete';
+export declare const handleTeamDelete: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<ToolName>;
+    agentStepId: string;
+    trackEvent: TrackEventFn;
+    userId: string | undefined;
+    logger: Logger;
+}) => Promise<{
+    output: LevelCodeToolOutput<ToolName>;
+}>;
+export {};

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

@@ -0,0 +1,9 @@
+import type { LevelCodeToolCall, LevelCodeToolOutput } from '@levelcode/common/tools/list';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+export declare const handleThinkDeeply: (params: {
+    previousToolCallFinished: Promise<any>;
+    toolCall: LevelCodeToolCall<"think_deeply">;
+    logger: Logger;
+}) => Promise<{
+    output: LevelCodeToolOutput<"think_deeply">;
+}>;

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

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

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

@@ -0,0 +1,22 @@
+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';
+export declare const handleWebSearch: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"web_search">;
+    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: ClientEnv;
+    ciEnv: CiEnv;
+}) => Promise<{
+    output: LevelCodeToolOutput<"web_search">;
+    creditsUsed: number;
+}>;

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

@@ -0,0 +1,49 @@
+import { processFileBlock } from '../../../process-file-block';
+import type { ClientToolCall, 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';
+type FileProcessingTools = 'write_file' | 'str_replace' | 'create_plan';
+export type FileProcessing<T extends FileProcessingTools = FileProcessingTools> = {
+    tool: T;
+    path: string;
+    toolCallId: string;
+} & ({
+    content: string;
+    patch?: string;
+    messages: string[];
+} | {
+    error: string;
+});
+export type FileProcessingState = {
+    promisesByPath: Record<string, Promise<FileProcessing>[]>;
+    allPromises: Promise<FileProcessing>[];
+    fileChangeErrors: Extract<FileProcessing, {
+        error: string;
+    }>[];
+    fileChanges: Exclude<FileProcessing, {
+        error: string;
+    }>[];
+    firstFileProcessed: boolean;
+};
+export declare function getFileProcessingValues(state: FileProcessingState): FileProcessingState;
+export declare const handleWriteFile: (params: {
+    previousToolCallFinished: Promise<void>;
+    toolCall: LevelCodeToolCall<"write_file">;
+    agentState: AgentState;
+    clientSessionId: string;
+    fileProcessingState: FileProcessingState;
+    fingerprintId: string;
+    logger: Logger;
+    prompt: string | undefined;
+    userId: string | undefined;
+    userInputId: string;
+    requestClientToolCall: (toolCall: ClientToolCall<"write_file">) => Promise<LevelCodeToolOutput<"write_file">>;
+    requestOptionalFile: RequestOptionalFileFn;
+    writeToClient: (chunk: string) => void;
+} & ParamsExcluding<typeof processFileBlock, "path" | "instructions" | "fingerprintId" | "initialContentPromise" | "newContent" | "messages" | "lastUserPrompt"> & ParamsExcluding<RequestOptionalFileFn, "filePath">) => Promise<{
+    output: LevelCodeToolOutput<"write_file">;
+}>;
+export declare function postStreamProcessing<T extends FileProcessingTools>(toolCall: FileProcessing<T>, fileProcessingState: FileProcessingState, writeToClient: (chunk: string) => void, requestClientToolCall: (toolCall: ClientToolCall<T>) => Promise<LevelCodeToolOutput<T>>): Promise<LevelCodeToolOutput<T>>;
+export {};

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

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

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

@@ -0,0 +1,31 @@
+import { toolParams } from '@levelcode/common/tools/list';
+import z from 'zod/v4';
+import type { SkillsMap } from '@levelcode/common/types/skill';
+import type { CustomToolDefinitions, customToolDefinitionsSchema } from '@levelcode/common/util/file';
+import type { ToolSet } from 'ai';
+/**
+ * Ensures the inputSchema is a Zod schema. If it's a JSON Schema object
+ * (from SDK custom tools that were serialized), converts it to Zod.
+ */
+export declare function ensureZodSchema(schema: z.ZodType | Record<string, unknown>): z.ZodType;
+export declare function buildToolDescription(params: {
+    toolName: string;
+    schema: z.ZodType;
+    description?: string;
+    endsAgentStep: boolean;
+    exampleInputs?: any[];
+}): string;
+export declare const toolDescriptions: Record<keyof typeof toolParams, string>;
+export declare const getToolsInstructions: (tools: readonly string[], additionalToolDefinitions: NonNullable<z.input<typeof customToolDefinitionsSchema>>, options?: {
+    availableSkillsXml?: string;
+}) => string;
+export declare const fullToolList: (toolNames: readonly string[], additionalToolDefinitions: CustomToolDefinitions, options?: {
+    availableSkillsXml?: string;
+}) => string;
+export declare const getShortToolInstructions: (toolNames: readonly string[], additionalToolDefinitions: CustomToolDefinitions) => string;
+export declare function getToolSet(params: {
+    toolNames: string[];
+    additionalToolDefinitions: () => Promise<CustomToolDefinitions>;
+    agentTools: ToolSet;
+    skills: SkillsMap;
+}): Promise<ToolSet>;

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

@@ -0,0 +1,33 @@
+import { processStreamWithTools } from '../tool-stream-parser';
+import type { CustomToolCall, ExecuteToolCallParams } from './tool-executor';
+import type { AgentTemplate } from '../templates/types';
+import type { LevelCodeToolCall } from '@levelcode/common/tools/list';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { Message, ToolMessage } from '@levelcode/common/types/messages/levelcode-message';
+import type { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { Subgoal } from '@levelcode/common/types/session-state';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+export declare function processStream(params: {
+    agentContext: Record<string, Subgoal>;
+    agentTemplate: AgentTemplate;
+    ancestorRunIds: string[];
+    fileContext: ProjectFileContext;
+    fingerprintId: string;
+    fullResponse: string;
+    logger: Logger;
+    messages: Message[];
+    repoId: string | undefined;
+    runId: string;
+    signal: AbortSignal;
+    userId: string | undefined;
+    onCostCalculated: (credits: number) => Promise<void>;
+    onResponseChunk: (chunk: string | PrintModeEvent) => void;
+} & Omit<ExecuteToolCallParams<any>, 'fileProcessingState' | 'fromHandleSteps' | 'fullResponse' | 'input' | 'previousToolCallFinished' | 'state' | 'toolCallId' | 'toolCalls' | 'toolName' | 'toolResults' | 'toolResultsToAddAfterStream'> & ParamsExcluding<typeof processStreamWithTools, 'processors' | 'defaultProcessor' | 'onError' | 'loggerOptions' | 'executeXmlToolCall'>): Promise<{
+    fullResponse: string;
+    fullResponseChunks: string[];
+    hadToolCallError: boolean;
+    messageId: string | null;
+    toolCalls: (CustomToolCall | LevelCodeToolCall)[];
+    toolResults: ToolMessage[];
+}>;