@levelcode/sdk 0.0.5 → 0.1.0

package/dist/packages/agent-runtime/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const globalStopSequence: string;

package/dist/packages/agent-runtime/src/fast-rewrite.d.ts

@@ -0,0 +1,45 @@
+import { promptFlashWithFallbacks } from './llm-api/gemini-with-fallbacks';
+import { promptRelaceAI } from './llm-api/relace-api';
+import type { PromptAiSdkFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { Message } from '@levelcode/common/types/messages/levelcode-message';
+/**
+ * Rewrites file content using Relace AI with fallback to OpenAI.
+ *
+ * @throws {Error} When the request is aborted by user. Check with `isAbortError()`.
+ */
+export declare function fastRewrite(params: {
+    initialContent: string;
+    editSnippet: string;
+    filePath: string;
+    userMessage: string | undefined;
+    logger: Logger;
+} & ParamsExcluding<typeof promptRelaceAI, 'initialCode'> & ParamsExcluding<typeof rewriteWithOpenAI, 'oldContent'>): Promise<string>;
+/**
+ * Rewrites file content using OpenAI's o3-mini model when Gemini Flash output limit is exceeded.
+ * Gemini flash can only output 8k tokens, openai models can do at least 16k tokens.
+ *
+ * @throws {Error} When the request is aborted by user. Check with `isAbortError()`.
+ */
+export declare function rewriteWithOpenAI(params: {
+    oldContent: string;
+    editSnippet: string;
+    promptAiSdk: PromptAiSdkFn;
+} & ParamsExcluding<PromptAiSdkFn, 'messages' | 'model'>): Promise<string>;
+/**
+ * Checks if Claude forgot to add "... existing code ..." placeholders.
+ *
+ * This handles a specific case where Claude sketches an update to a single function,
+ * but forgets to add ... existing code ... above and below the function.
+ *
+ * @throws {Error} When the request is aborted by user. Check with `isAbortError()`.
+ */
+export declare const shouldAddFilePlaceholders: (params: {
+    filePath: string;
+    oldContent: string;
+    rewrittenNewContent: string;
+    messageHistory: Message[];
+    fullResponse: string;
+    logger: Logger;
+} & ParamsExcluding<typeof promptFlashWithFallbacks, "messages" | "model">) => Promise<boolean>;

package/dist/packages/agent-runtime/src/find-files/request-files-prompt.d.ts

@@ -0,0 +1,71 @@
+import { type FinetunedVertexModel } from '@levelcode/common/old-constants';
+import { promptFlashWithFallbacks } from '../llm-api/gemini-with-fallbacks';
+import type { TextBlock } from '../llm-api/claude';
+import type { PromptAiSdkFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { Message } from '@levelcode/common/types/messages/levelcode-message';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+export declare function requestRelevantFiles(params: {
+    messages: Message[];
+    system: string | Array<TextBlock>;
+    fileContext: ProjectFileContext;
+    assistantPrompt: string | null;
+    agentStepId: string;
+    clientSessionId: string;
+    fingerprintId: string;
+    userInputId: string;
+    userId: string | undefined;
+    repoId: string | undefined;
+    logger: Logger;
+} & ParamsExcluding<typeof getRelevantFiles, 'messages' | 'userPrompt' | 'requestType' | 'modelId'>): Promise<string[]>;
+export declare function requestRelevantFilesForTraining(params: {
+    messages: Message[];
+    fileContext: ProjectFileContext;
+    assistantPrompt: string | null;
+    logger: Logger;
+} & ParamsExcluding<typeof getRelevantFilesForTraining, 'messages' | 'userPrompt' | 'requestType'>): Promise<string[]>;
+declare function getRelevantFiles(params: {
+    messages: Message[];
+    system: string | Array<TextBlock>;
+    userPrompt: string;
+    requestType: string;
+    agentStepId: string;
+    clientSessionId: string;
+    fingerprintId: string;
+    userInputId: string;
+    userId: string | undefined;
+    repoId: string | undefined;
+    modelId?: FinetunedVertexModel;
+    logger: Logger;
+} & ParamsExcluding<typeof promptFlashWithFallbacks, 'messages' | 'model' | 'useFinetunedModel'>): Promise<{
+    files: string[];
+    duration: number;
+    requestType: string;
+    response: string;
+}>;
+/**
+ * Gets relevant files for training using Claude Sonnet.
+ *
+ * @throws {Error} When the request is aborted by user. Check with `isAbortError()`.
+ */
+declare function getRelevantFilesForTraining(params: {
+    messages: Message[];
+    system: string | Array<TextBlock>;
+    userPrompt: string;
+    requestType: string;
+    agentStepId: string;
+    clientSessionId: string;
+    fingerprintId: string;
+    userInputId: string;
+    userId: string | undefined;
+    repoId: string | undefined;
+    promptAiSdk: PromptAiSdkFn;
+    logger: Logger;
+} & ParamsExcluding<PromptAiSdkFn, 'messages' | 'model' | 'chargeUser'>): Promise<{
+    files: string[];
+    duration: number;
+    requestType: string;
+    response: string;
+}>;
+export {};

package/dist/packages/agent-runtime/src/generate-diffs-prompt.d.ts

@@ -0,0 +1,53 @@
+import type { PromptAiSdkFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+export declare const parseAndGetDiffBlocksSingleFile: (params: {
+    newContent: string;
+    oldFileContent: string;
+    logger: Logger;
+}) => {
+    diffBlocks: {
+        searchContent: string;
+        replaceContent: string;
+    }[];
+    diffBlocksThatDidntMatch: {
+        searchContent: string;
+        replaceContent: string;
+    }[];
+};
+export declare const tryToDoStringReplacementWithExtraIndentation: (params: {
+    oldFileContent: string;
+    searchContent: string;
+    replaceContent: string;
+}) => {
+    searchContent: string;
+    replaceContent: string;
+} | null;
+/**
+ * Retries generating diff blocks when initial blocks failed to match the old file content.
+ *
+ * @throws {Error} When the request is aborted by user. Check with `isAbortError()`.
+ */
+export declare function retryDiffBlocksPrompt(params: {
+    filePath: string;
+    oldContent: string;
+    clientSessionId: string;
+    fingerprintId: string;
+    userInputId: string;
+    userId: string | undefined;
+    diffBlocksThatDidntMatch: {
+        searchContent: string;
+        replaceContent: string;
+    }[];
+    promptAiSdk: PromptAiSdkFn;
+    logger: Logger;
+} & ParamsExcluding<PromptAiSdkFn, 'messages' | 'model'>): Promise<{
+    newDiffBlocks: {
+        searchContent: string;
+        replaceContent: string;
+    }[];
+    newDiffBlocksThatDidntMatch: {
+        searchContent: string;
+        replaceContent: string;
+    }[];
+}>;

package/dist/packages/agent-runtime/src/get-file-reading-updates.d.ts

@@ -0,0 +1,8 @@
+import type { RequestFilesFn } from '@levelcode/common/types/contracts/client';
+export declare function getFileReadingUpdates(params: {
+    requestFiles: RequestFilesFn;
+    requestedFiles: string[];
+}): Promise<{
+    path: string;
+    content: string;
+}[]>;

package/dist/packages/agent-runtime/src/llm-api/claude.d.ts

@@ -0,0 +1,5 @@
+export type TextBlock = {
+    text: string;
+    type: 'text';
+};
+export type System = string | Array<TextBlock>;

package/dist/packages/agent-runtime/src/llm-api/context7-api.d.ts

@@ -0,0 +1,55 @@
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsOf } from '@levelcode/common/types/function-params';
+export interface SearchResponse {
+    results: Array<{
+        id: string;
+        title: string;
+        description: string;
+        branch: string;
+        lastUpdateDate: string;
+        state: DocumentState;
+        totalTokens: number;
+        totalSnippets: number;
+        totalPages: number;
+        stars?: number;
+        trustScore?: number;
+    }>;
+}
+type DocumentState = 'initial' | 'finalized' | 'error' | 'delete';
+export interface SearchResult {
+    id: string;
+    title: string;
+    description: string;
+    branch: string;
+    lastUpdateDate: string;
+    state: DocumentState;
+    totalTokens: number;
+    totalSnippets: number;
+    totalPages: number;
+    stars?: number;
+    trustScore?: number;
+}
+/**
+ * Lists all available documentation projects from Context7
+ * @returns Array of projects with their metadata, or null if the request fails
+ */
+export declare function searchLibraries(params: {
+    query: string;
+    logger: Logger;
+    fetch: typeof globalThis.fetch;
+}): Promise<SearchResult[] | null>;
+/**
+ * Fetches documentation context for a specific library
+ * @param libraryId The library ID to fetch documentation for
+ * @param options Options for the request
+ * @returns The documentation text or null if the request fails
+ */
+export declare function fetchContext7LibraryDocumentation(params: {
+    query: string;
+    tokens?: number;
+    topic?: string;
+    folders?: string;
+    logger: Logger;
+    fetch: typeof globalThis.fetch;
+} & ParamsOf<typeof searchLibraries>): Promise<string | null>;
+export {};

package/dist/packages/agent-runtime/src/llm-api/gemini-with-fallbacks.d.ts

@@ -0,0 +1,40 @@
+import type { FinetunedVertexModel } from '@levelcode/common/old-constants';
+import type { PromptAiSdkFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { Message } from '@levelcode/common/types/messages/levelcode-message';
+/**
+ * Prompts a Gemini model with fallback logic.
+ *
+ * Attempts to call the specified Gemini model via the standard Gemini API.
+ * If that fails, it falls back to using the Vertex AI Gemini endpoint.
+ * If Vertex AI also fails, it falls back to either GPT-4o (if `useGPT4oInsteadOfClaude` is true)
+ * or a Claude model (Sonnet for 'max' costMode, Haiku otherwise).
+ *
+ * This function handles non-streaming requests and returns the complete response string.
+ *
+ * @param messages - The array of messages forming the conversation history.
+ * @param system - An optional system prompt string or array of text blocks.
+ * @param options - Configuration options for the API call.
+ * @param options.clientSessionId - Unique ID for the client session.
+ * @param options.fingerprintId - Unique ID for the user's device/fingerprint.
+ * @param options.userInputId - Unique ID for the specific user input triggering this call.
+ * @param options.model - The primary Gemini model to attempt.
+ * @param options.userId - The ID of the user making the request.
+ * @param options.maxTokens - Optional maximum number of tokens for the response.
+ * @param options.temperature - Optional temperature setting for generation (0-1).
+ * @param options.costMode - Optional cost mode ('free', 'normal', 'max') influencing fallback model choice.
+ * @param options.useGPT4oInsteadOfClaude - Optional flag to use GPT-4o instead of Claude as the final fallback.
+ * @returns A promise that resolves to the complete response string from the successful API call.
+ * @throws {Error} If all API calls (primary and fallbacks) fail.
+ * @throws {Error} When the request is aborted by user. Check with `isAbortError()`. Aborts are not retried.
+ */
+export declare function promptFlashWithFallbacks(params: {
+    messages: Message[];
+    costMode?: string;
+    useGPT4oInsteadOfClaude?: boolean;
+    thinkingBudget?: number;
+    useFinetunedModel?: FinetunedVertexModel | undefined;
+    promptAiSdk: PromptAiSdkFn;
+    logger: Logger;
+} & ParamsExcluding<PromptAiSdkFn, 'messages'>): Promise<string>;

package/dist/packages/agent-runtime/src/llm-api/levelcode-web-api.d.ts

@@ -0,0 +1,49 @@
+import type { ClientEnv, CiEnv } from '@levelcode/common/types/contracts/env';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+interface LevelCodeWebApiEnv {
+    clientEnv: ClientEnv;
+    ciEnv: CiEnv;
+}
+export declare function callWebSearchAPI(params: {
+    query: string;
+    depth?: 'standard' | 'deep';
+    repoUrl?: string | null;
+    fetch: typeof globalThis.fetch;
+    logger: Logger;
+    env: LevelCodeWebApiEnv;
+    baseUrl?: string;
+    apiKey?: string;
+}): Promise<{
+    result?: string;
+    error?: string;
+    creditsUsed?: number;
+}>;
+export declare function callDocsSearchAPI(params: {
+    libraryTitle: string;
+    topic?: string;
+    maxTokens?: number;
+    repoUrl?: string | null;
+    fetch: typeof globalThis.fetch;
+    logger: Logger;
+    env: LevelCodeWebApiEnv;
+    baseUrl?: string;
+    apiKey?: string;
+}): Promise<{
+    documentation?: string;
+    error?: string;
+    creditsUsed?: number;
+}>;
+export declare function callTokenCountAPI(params: {
+    messages: unknown[];
+    system?: string;
+    model?: string;
+    fetch: typeof globalThis.fetch;
+    logger: Logger;
+    env: LevelCodeWebApiEnv;
+    baseUrl?: string;
+    apiKey?: string;
+}): Promise<{
+    inputTokens?: number;
+    error?: string;
+}>;
+export {};

package/dist/packages/agent-runtime/src/llm-api/relace-api.d.ts

@@ -0,0 +1,16 @@
+import type { PromptAiSdkFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+/**
+ * Applies code edits using Relace AI, with fallback to o3-mini on failure.
+ *
+ * @returns The updated code with edits applied.
+ * @throws {Error} When the request is aborted by user. Check with `isAbortError()`. Aborts are not retried.
+ */
+export declare function promptRelaceAI(params: {
+    initialCode: string;
+    editSnippet: string;
+    instructions: string | undefined;
+    promptAiSdk: PromptAiSdkFn;
+    logger: Logger;
+} & ParamsExcluding<PromptAiSdkFn, 'messages' | 'model'>): Promise<string>;

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

@@ -0,0 +1,29 @@
+import { loopAgentSteps } from './run-agent-step';
+import { getAgentTemplate } from './templates/agent-registry';
+import type { AgentTemplate } from './templates/types';
+import type { ClientAction } from '@levelcode/common/actions';
+import type { RequestToolCallFn, SendActionFn } 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 { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { SessionState, AgentOutput } from '@levelcode/common/types/session-state';
+export declare function mainPrompt(params: {
+    action: ClientAction<'prompt'>;
+    onResponseChunk: (chunk: string | PrintModeEvent) => void;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    requestToolCall: RequestToolCallFn;
+    logger: Logger;
+} & ParamsExcluding<typeof loopAgentSteps, 'userInputId' | 'spawnParams' | 'agentState' | 'prompt' | 'content' | 'agentType' | 'fingerprintId' | 'fileContext' | 'ancestorRunIds'> & ParamsExcluding<typeof getAgentTemplate, 'agentId'>): Promise<{
+    sessionState: SessionState;
+    output: AgentOutput;
+}>;
+export declare function callMainPrompt(params: {
+    action: ClientAction<'prompt'>;
+    promptId: string;
+    sendAction: SendActionFn;
+    logger: Logger;
+    signal: AbortSignal;
+} & ParamsExcluding<typeof mainPrompt, 'localAgentTemplates' | 'onResponseChunk'>): Promise<{
+    sessionState: SessionState;
+    output: AgentOutput;
+}>;

package/dist/packages/agent-runtime/src/mcp-constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Separator used between MCP server name and tool name.
+ *
+ * LLM APIs (OpenRouter/Anthropic) only allow tool names matching the pattern
+ * ^[a-zA-Z0-9_-]{1,128}$, which doesn't include forward slashes.
+ *
+ * We use double underscore as the separator since it's:
+ * - Allowed by the LLM API pattern
+ * - Unlikely to conflict with existing tool names
+ * - Clearly identifiable as a separator
+ */
+export declare const MCP_TOOL_SEPARATOR = "__";

package/dist/packages/agent-runtime/src/mcp.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTemplate } from './templates/types';
+import type { RequestMcpToolDataFn } from '@levelcode/common/types/contracts/client';
+import type { OptionalFields } from '@levelcode/common/types/function-params';
+import type { CustomToolDefinitions, ProjectFileContext } from '@levelcode/common/util/file';
+export declare function getMCPToolData(params: OptionalFields<{
+    toolNames: AgentTemplate['toolNames'];
+    mcpServers: AgentTemplate['mcpServers'];
+    writeTo: ProjectFileContext['customToolDefinitions'];
+    requestMcpToolData: RequestMcpToolDataFn;
+}, 'writeTo'>): Promise<CustomToolDefinitions>;

package/dist/packages/agent-runtime/src/process-file-block.d.ts

@@ -0,0 +1,56 @@
+import { type PromptResult } from '@levelcode/common/util/error';
+import { fastRewrite, shouldAddFilePlaceholders } from './fast-rewrite';
+import { retryDiffBlocksPrompt } from './generate-diffs-prompt';
+import type { PromptAiSdkFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { Message } from '@levelcode/common/types/messages/levelcode-message';
+type WriteFileSuccess = {
+    tool: 'write_file';
+    path: string;
+    content: string;
+    patch: string | undefined;
+    messages: string[];
+};
+type WriteFileError = {
+    tool: 'write_file';
+    path: string;
+    error: string;
+};
+export type WriteFileResult = WriteFileSuccess | WriteFileError;
+/**
+ * Processes a file block from the LLM response, applying edits to create updated file content.
+ *
+ * Returns a PromptResult to explicitly handle the abort case:
+ * - `{ aborted: true }` when the user cancels the operation
+ * - `{ aborted: false, value: WriteFileResult }` on success or recoverable error
+ */
+export declare function processFileBlock(params: {
+    path: string;
+    initialContentPromise: Promise<string | null>;
+    newContent: string;
+    messages: Message[];
+    fullResponse: string;
+    lastUserPrompt: string | undefined;
+    clientSessionId: string;
+    fingerprintId: string;
+    userInputId: string;
+    userId: string | undefined;
+    logger: Logger;
+} & ParamsExcluding<typeof handleLargeFile, 'oldContent' | 'editSnippet' | 'filePath'> & ParamsExcluding<typeof fastRewrite, 'initialContent' | 'editSnippet' | 'filePath' | 'userMessage'> & ParamsExcluding<typeof shouldAddFilePlaceholders, 'filePath' | 'oldContent' | 'rewrittenNewContent' | 'messageHistory'>): Promise<PromptResult<WriteFileResult>>;
+/**
+ * Handles large file edits by generating SEARCH/REPLACE blocks.
+ *
+ * Returns a PromptResult to explicitly handle the abort case:
+ * - `{ aborted: true }` when the user cancels the operation
+ * - `{ aborted: false, value: string }` on success
+ * - `{ aborted: false, value: null }` if diff blocks failed to match after retry
+ */
+export declare function handleLargeFile(params: {
+    oldContent: string;
+    editSnippet: string;
+    filePath: string;
+    logger: Logger;
+    promptAiSdk: PromptAiSdkFn;
+} & ParamsExcluding<typeof retryDiffBlocksPrompt, 'oldContent' | 'diffBlocksThatDidntMatch'> & ParamsExcluding<PromptAiSdkFn, 'messages' | 'model'>): Promise<PromptResult<string | null>>;
+export {};

package/dist/packages/agent-runtime/src/process-str-replace.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+export declare function processStrReplace(params: {
+    path: string;
+    replacements: {
+        old: string;
+        new: string;
+        allowMultiple: boolean;
+    }[];
+    initialContentPromise: Promise<string | null>;
+    logger: Logger;
+}): Promise<{
+    tool: 'str_replace';
+    path: string;
+    content: string;
+    patch: string;
+    messages: string[];
+} | {
+    tool: 'str_replace';
+    path: string;
+    error: string;
+}>;

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

@@ -0,0 +1,28 @@
+import type { AgentTemplate } from './templates/types';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { SendActionFn } from '@levelcode/common/types/contracts/client';
+import type { PromptAiSdkStreamFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { Message } from '@levelcode/common/types/messages/levelcode-message';
+import type { ToolSet } from 'ai';
+export declare const getAgentStreamFromTemplate: (params: {
+    agentId?: string;
+    apiKey: string;
+    clientSessionId: string;
+    costMode?: string;
+    fingerprintId: string;
+    includeCacheControl?: boolean;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    messages: Message[];
+    runId: string;
+    signal: AbortSignal;
+    template: AgentTemplate;
+    tools: ToolSet;
+    userId: string | undefined;
+    userInputId: string;
+    onCostCalculated?: (credits: number) => Promise<void>;
+    promptAiSdkStream: PromptAiSdkStreamFn;
+    sendAction: SendActionFn;
+    trackEvent: TrackEventFn;
+}) => ReturnType<PromptAiSdkStreamFn>;

package/dist/packages/agent-runtime/src/run-agent-step.d.ts

@@ -0,0 +1,73 @@
+import { type ToolSet } from 'ai';
+import { getMCPToolData } from './mcp';
+import { getAgentStreamFromTemplate } from './prompt-agent-stream';
+import { runProgrammaticStep } from './run-programmatic-step';
+import { getAgentTemplate } from './templates/agent-registry';
+import { getAgentPrompt } from './templates/strings';
+import { processStream } from './tools/stream-parser';
+import type { AgentTemplate } from '@levelcode/common/types/agent-template';
+import type { TrackEventFn } from '@levelcode/common/types/contracts/analytics';
+import type { AddAgentStepFn, FinishAgentRunFn, StartAgentRunFn } from '@levelcode/common/types/contracts/database';
+import type { PromptAiSdkFn } from '@levelcode/common/types/contracts/llm';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ParamsExcluding } from '@levelcode/common/types/function-params';
+import type { TextPart, ImagePart } from '@levelcode/common/types/messages/content-part';
+import type { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { AgentTemplateType, AgentState, AgentOutput } from '@levelcode/common/types/session-state';
+import type { CustomToolDefinitions, ProjectFileContext } from '@levelcode/common/util/file';
+declare function additionalToolDefinitions(params: {
+    agentTemplate: AgentTemplate;
+    fileContext: ProjectFileContext;
+} & ParamsExcluding<typeof getMCPToolData, 'toolNames' | 'mcpServers' | 'writeTo'>): Promise<CustomToolDefinitions>;
+export declare const runAgentStep: (params: {
+    userId: string | undefined;
+    userInputId: string;
+    clientSessionId: string;
+    costMode?: string;
+    fingerprintId: string;
+    repoId: string | undefined;
+    onResponseChunk: (chunk: string | PrintModeEvent) => void;
+    agentType: AgentTemplateType;
+    agentTemplate: AgentTemplate;
+    fileContext: ProjectFileContext;
+    agentState: AgentState;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    prompt: string | undefined;
+    spawnParams: Record<string, any> | undefined;
+    system: string;
+    n?: number;
+    trackEvent: TrackEventFn;
+    promptAiSdk: PromptAiSdkFn;
+} & ParamsExcluding<typeof processStream, "agentContext" | "agentState" | "agentStepId" | "agentTemplate" | "fullResponse" | "messages" | "onCostCalculated" | "repoId" | "stream"> & ParamsExcluding<typeof getAgentStreamFromTemplate, "agentId" | "includeCacheControl" | "messages" | "onCostCalculated" | "template"> & ParamsExcluding<typeof getAgentTemplate, "agentId"> & ParamsExcluding<typeof getAgentPrompt, "agentTemplate" | "promptType" | "agentState" | "agentTemplates"> & ParamsExcluding<typeof getMCPToolData, "toolNames" | "mcpServers" | "writeTo"> & ParamsExcluding<PromptAiSdkFn, "messages" | "model" | "onCostCalculated" | "n">) => Promise<{
+    agentState: AgentState;
+    fullResponse: string;
+    shouldEndTurn: boolean;
+    messageId: string | null;
+    nResponses?: string[];
+}>;
+export declare function loopAgentSteps(params: {
+    addAgentStep: AddAgentStepFn;
+    agentState: AgentState;
+    agentType: AgentTemplateType;
+    clearUserPromptMessagesAfterResponse?: boolean;
+    clientSessionId: string;
+    content?: Array<TextPart | ImagePart>;
+    costMode?: string;
+    fileContext: ProjectFileContext;
+    finishAgentRun: FinishAgentRunFn;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    parentSystemPrompt?: string;
+    parentTools?: ToolSet;
+    prompt: string | undefined;
+    signal: AbortSignal;
+    spawnParams: Record<string, any> | undefined;
+    startAgentRun: StartAgentRunFn;
+    userId: string | undefined;
+    userInputId: string;
+    agentTemplate?: AgentTemplate;
+} & ParamsExcluding<typeof additionalToolDefinitions, 'agentTemplate'> & ParamsExcluding<typeof runProgrammaticStep, 'agentState' | 'onCostCalculated' | 'prompt' | 'runId' | 'stepNumber' | 'stepsComplete' | 'system' | 'template' | 'toolCallParams' | 'tools'> & ParamsExcluding<typeof getAgentTemplate, 'agentId'> & ParamsExcluding<typeof getAgentPrompt, 'agentTemplate' | 'promptType' | 'agentTemplates' | 'additionalToolDefinitions'> & ParamsExcluding<typeof getMCPToolData, 'toolNames' | 'mcpServers' | 'writeTo'> & ParamsExcluding<StartAgentRunFn, 'agentId' | 'ancestorRunIds'> & ParamsExcluding<FinishAgentRunFn, 'runId' | 'status' | 'totalSteps' | 'directCredits' | 'totalCredits'> & ParamsExcluding<typeof runAgentStep, 'additionalToolDefinitions' | 'agentState' | 'agentTemplate' | 'prompt' | 'runId' | 'spawnParams' | 'system' | 'tools'> & ParamsExcluding<AddAgentStepFn, 'agentRunId' | 'stepNumber' | 'credits' | 'childRunIds' | 'messageId' | 'status' | 'startTime'>): Promise<{
+    agentState: AgentState;
+    output: AgentOutput;
+}>;
+export {};

package/dist/packages/agent-runtime/src/run-programmatic-step.d.ts

@@ -0,0 +1,40 @@
+import type { ExecuteToolCallParams } from './tools/tool-executor';
+import type { AgentTemplate, PublicAgentState } from '@levelcode/common/types/agent-template';
+import type { HandleStepsLogChunkFn, SendActionFn } from '@levelcode/common/types/contracts/client';
+import type { AddAgentStepFn } 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 { PrintModeEvent } from '@levelcode/common/types/print-mode';
+import type { AgentState } from '@levelcode/common/types/session-state';
+export declare const runIdToStepAll: Set<string>;
+export declare function clearAgentGeneratorCache(params: {
+    logger: Logger;
+}): void;
+export declare function runProgrammaticStep(params: {
+    addAgentStep: AddAgentStepFn;
+    agentState: AgentState;
+    clientSessionId: string;
+    fingerprintId: string;
+    handleStepsLogChunk: HandleStepsLogChunkFn;
+    localAgentTemplates: Record<string, AgentTemplate>;
+    logger: Logger;
+    nResponses?: string[];
+    onResponseChunk: (chunk: string | PrintModeEvent) => void;
+    prompt: string | undefined;
+    repoId: string | undefined;
+    repoUrl: string | undefined;
+    stepNumber: number;
+    stepsComplete: boolean;
+    template: AgentTemplate;
+    toolCallParams: Record<string, any> | undefined;
+    sendAction: SendActionFn;
+    system: string | undefined;
+    userId: string | undefined;
+    userInputId: string;
+} & Omit<ExecuteToolCallParams, 'toolName' | 'input' | 'autoInsertEndStepParam' | 'excludeToolFromMessageHistory' | 'agentContext' | 'agentStepId' | 'agentTemplate' | 'fullResponse' | 'previousToolCallFinished' | 'fileProcessingState' | 'toolCallId' | 'toolCalls' | 'toolResults' | 'toolResultsToAddAfterStream'> & ParamsExcluding<AddAgentStepFn, 'agentRunId' | 'stepNumber' | 'credits' | 'childRunIds' | 'status' | 'startTime' | 'messageId'>): Promise<{
+    agentState: AgentState;
+    endTurn: boolean;
+    stepNumber: number;
+    generateN?: number;
+}>;
+export declare const getPublicAgentState: (agentState: AgentState & Required<Pick<AgentState, "runId">>) => PublicAgentState;

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

@@ -0,0 +1,19 @@
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+import type { ProjectFileContext } from '@levelcode/common/util/file';
+export declare const knowledgeFilesPrompt: string;
+export declare const additionalSystemPrompts: {
+    readonly '/init': string;
+    readonly init: string;
+    readonly '/export': string;
+    readonly export: string;
+    readonly '/compact': string;
+    readonly compact: string;
+};
+export declare const getProjectFileTreePrompt: (params: {
+    fileContext: ProjectFileContext;
+    fileTreeTokenBudget: number;
+    mode: "search" | "agent";
+    logger: Logger;
+}) => string;
+export declare const getSystemInfoPrompt: (fileContext: ProjectFileContext) => string;
+export declare const getGitChangesPrompt: (fileContext: ProjectFileContext) => string;