@levelcode/sdk 0.2.2 → 0.2.3

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/inbox-poller.d.ts

@@ -0,0 +1,81 @@
+import type { TeamProtocolMessage } from '@levelcode/common/types/team-protocol';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+export interface InboxPollerConfig {
+    teamName: string;
+    agentName: string;
+    pollIntervalMs?: number;
+    logger: Logger;
+}
+export interface InboxPollResult {
+    messages: TeamProtocolMessage[];
+    formattedContent: string | null;
+}
+/**
+ * InboxPoller continuously polls an agent's inbox file for new messages
+ * and provides them in a format suitable for injection into the agent's
+ * next prompt turn.
+ *
+ * Usage:
+ *   const poller = new InboxPoller({ teamName, agentName, logger })
+ *   poller.start()
+ *   // Between agent turns:
+ *   const result = poller.drain()
+ *   if (result.formattedContent) {
+ *     // inject into message history
+ *   }
+ *   // When agent shuts down:
+ *   poller.stop()
+ */
+export declare class InboxPoller {
+    private teamName;
+    private agentName;
+    private pollIntervalMs;
+    private logger;
+    private timer;
+    private pendingMessages;
+    private running;
+    constructor(config: InboxPollerConfig);
+    /**
+     * Start polling the inbox file at the configured interval.
+     */
+    start(): void;
+    /**
+     * Stop polling.
+     */
+    stop(): void;
+    /**
+     * Poll the inbox once and accumulate any new messages.
+     * Messages are read from the filesystem and the inbox is cleared
+     * after reading to prevent duplicate delivery.
+     */
+    private poll;
+    /**
+     * Drain all accumulated pending messages and return them.
+     * After calling drain(), the internal buffer is cleared.
+     * Returns both the raw messages and a formatted string suitable
+     * for injection into the agent's message history.
+     */
+    drain(): InboxPollResult;
+    /**
+     * Check if there are any pending messages without draining them.
+     */
+    hasPendingMessages(): boolean;
+    /**
+     * Force an immediate poll (useful before draining between turns).
+     */
+    pollNow(): void;
+    /**
+     * Returns whether the poller is currently running.
+     */
+    isRunning(): boolean;
+}
+/**
+ * One-shot convenience function: reads the inbox, formats messages,
+ * clears the inbox, and returns the result. Useful when you don't need
+ * continuous background polling and just want to check between turns.
+ */
+export declare function drainInbox(params: {
+    teamName: string;
+    agentName: string;
+    logger: Logger;
+}): InboxPollResult;

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/message-formatter.d.ts

@@ -0,0 +1,12 @@
+import type { TeamProtocolMessage } from '@levelcode/common/types/team-protocol';
+/**
+ * Formats a single TeamProtocolMessage into a human-readable string
+ * suitable for injection into an agent's message history.
+ */
+export declare function formatTeamMessage(message: TeamProtocolMessage): string;
+/**
+ * Formats an array of TeamProtocolMessages into a single string block
+ * wrapped in a system-level container tag, ready for injection into
+ * the agent's message history.
+ */
+export declare function formatInboxMessages(messages: TeamProtocolMessage[]): string | null;

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>;