@levelcode/sdk 0.1.0 → 0.2.0

package/README.md

@@ -261,6 +261,110 @@ The `RunState` object contains:
 - `sessionState`: Internal state to be passed to the next run
 - `output`: The agent's output (text, error, or other types)
 
+### Team Management
+
+The SDK provides programmatic team management for coordinating multiple agents.
+
+#### `client.createTeam(config)`
+
+Creates a new team from a `TeamConfig` object. If a team with the same name already exists it will be overwritten.
+
+```typescript
+import { LevelCodeClient } from '@levelcode/sdk'
+import type { TeamConfig } from '@levelcode/sdk'
+
+const client = new LevelCodeClient({ apiKey: process.env.LEVELCODE_API_KEY })
+
+const config: TeamConfig = {
+  name: 'my-team',
+  description: 'Backend refactor squad',
+  createdAt: Date.now(),
+  leadAgentId: 'lead-001',
+  phase: 'planning',
+  members: [
+    {
+      agentId: 'lead-001',
+      name: 'team-lead',
+      role: 'coordinator',
+      agentType: 'coordinator',
+      model: 'claude-opus-4-6',
+      joinedAt: Date.now(),
+      status: 'active',
+      cwd: process.cwd(),
+    },
+  ],
+  settings: { maxMembers: 10, autoAssign: true },
+}
+
+client.createTeam(config)
+```
+
+#### `client.deleteTeam(name)`
+
+Deletes a team by name, removing all associated data (config, tasks, inboxes). Safe to call on a team that does not exist.
+
+```typescript
+client.deleteTeam('my-team')
+```
+
+#### `client.getTeamStatus(name)`
+
+Returns summary information for a team, or `null` if the team does not exist or has a corrupted config.
+
+```typescript
+const status = client.getTeamStatus('my-team')
+if (status) {
+  console.log(status.name)        // 'my-team'
+  console.log(status.phase)       // 'planning'
+  console.log(status.memberCount) // 1
+}
+```
+
+Returns a `TeamSummary`:
+
+| Field         | Type       | Description                        |
+| ------------- | ---------- | ---------------------------------- |
+| `name`        | `string`   | Team name                          |
+| `phase`       | `DevPhase` | Current development phase          |
+| `memberCount` | `number`   | Number of members in the team      |
+
+#### `client.listTeams()`
+
+Returns an array of `TeamSummary` objects for every team. Teams with corrupted config files are silently skipped.
+
+```typescript
+const teams = client.listTeams()
+for (const team of teams) {
+  console.log(`${team.name} — ${team.phase} (${team.memberCount} members)`)
+}
+```
+
+#### Team Types
+
+The following types are exported from `@levelcode/sdk` for use with the team API:
+
+```typescript
+import type {
+  TeamConfig,
+  TeamMember,
+  TeamTask,
+  TeamRole,
+  DevPhase,
+  TeamSummary,
+  TeamProtocolMessage,
+} from '@levelcode/sdk'
+```
+
+| Type                    | Description                                                        |
+| ----------------------- | ------------------------------------------------------------------ |
+| `TeamConfig`            | Full team configuration (name, members, settings, phase)           |
+| `TeamMember`            | A single member entry (agentId, name, role, model, status)         |
+| `TeamTask`              | A task within a team (id, subject, status, priority, owner)        |
+| `TeamRole`              | Union of all role strings (`'coordinator'`, `'senior-engineer'`, etc.) |
+| `DevPhase`              | Development phase (`'planning'` \| `'pre-alpha'` \| `'alpha'` \| `'beta'` \| `'production'` \| `'mature'`) |
+| `TeamSummary`           | Lightweight summary returned by `getTeamStatus` and `listTeams`    |
+| `TeamProtocolMessage`   | Message type used for inter-agent communication                    |
+
 ## License
 
 MIT

package/dist/agents/constants.d.ts

@@ -0,0 +1 @@
+export declare const publisher = "levelcode";

package/dist/agents/team/apprentice.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const apprentice: AgentDefinition;
+export default apprentice;

package/dist/agents/team/coordinator.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const coordinator: AgentDefinition;
+export default coordinator;

package/dist/agents/team/cto.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const cto: AgentDefinition;
+export default cto;

package/dist/agents/team/designer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const designer: AgentDefinition;
+export default designer;

package/dist/agents/team/director.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const director: AgentDefinition;
+export default director;

package/dist/agents/team/distinguished-engineer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const distinguishedEngineer: AgentDefinition;
+export default distinguishedEngineer;

package/dist/agents/team/fellow.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const fellow: AgentDefinition;
+export default fellow;

package/dist/agents/team/index.d.ts

@@ -0,0 +1,27 @@
+import type { TeamRole } from '@levelcode/common/types/team-config';
+import type { AgentDefinition } from '../types/agent-definition';
+/**
+ * Map of TeamRole to its AgentDefinition.
+ *
+ * Roles that exist in the TeamRole type but have no dedicated template
+ * (e.g. 'super-senior', 'reviewer') are intentionally omitted.
+ */
+export declare const TEAM_AGENTS: Partial<Record<TeamRole, AgentDefinition>>;
+/**
+ * Human-readable descriptions for each team role.
+ */
+export declare const TEAM_ROLE_DESCRIPTIONS: Partial<Record<TeamRole, string>>;
+/**
+ * Look up the AgentDefinition for a given team role.
+ * Returns undefined if the role has no registered template.
+ */
+export declare function getTeamAgent(role: TeamRole): AgentDefinition | undefined;
+/**
+ * Get all registered team agent definitions.
+ */
+export declare function getAllTeamAgents(): AgentDefinition[];
+/**
+ * Get a map of agent ID to AgentDefinition for all team agents.
+ * Useful for registering team agents into the agent template system.
+ */
+export declare function getTeamAgentsByIds(): Record<string, AgentDefinition>;

package/dist/agents/team/intern.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const intern: AgentDefinition;
+export default intern;

package/dist/agents/team/junior-engineer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const juniorEngineer: AgentDefinition;
+export default juniorEngineer;

package/dist/agents/team/manager.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const manager: AgentDefinition;
+export default manager;

package/dist/agents/team/mid-level-engineer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const midLevelEngineer: AgentDefinition;
+export default midLevelEngineer;

package/dist/agents/team/principal-engineer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const principalEngineer: AgentDefinition;
+export default principalEngineer;

package/dist/agents/team/product-lead.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const productLead: AgentDefinition;
+export default productLead;

package/dist/agents/team/researcher.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const researcher: AgentDefinition;
+export default researcher;

package/dist/agents/team/role-hierarchy.d.ts

@@ -0,0 +1,24 @@
+import type { TeamRole } from '@levelcode/common/types/team-config';
+/**
+ * Team roles ordered from lowest to highest authority.
+ * Index 0 is the lowest level (intern), last element is the highest (cto).
+ *
+ * Specialist roles (researcher, scientist, designer, product-lead, tester)
+ * are placed alongside their equivalent IC/management level.
+ */
+export declare const ROLE_HIERARCHY: TeamRole[];
+/**
+ * Get the numeric authority level for a role.
+ * 0 = intern (lowest), 13 = CTO (highest).
+ */
+export declare function getRoleLevel(role: TeamRole): number;
+/**
+ * Returns true if the manager role has authority over the subordinate role.
+ * A role can manage any role with a strictly lower level.
+ */
+export declare function canManage(managerRole: TeamRole, subordinateRole: TeamRole): boolean;
+/**
+ * Get the team roles that a given role is allowed to spawn as sub-agents.
+ * Returns an empty array for roles that cannot spawn other team agents.
+ */
+export declare function getSpawnableRoles(role: TeamRole): TeamRole[];

package/dist/agents/team/scientist.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const scientist: AgentDefinition;
+export default scientist;

package/dist/agents/team/senior-engineer.d.ts

@@ -0,0 +1,3 @@
+import { type SecretAgentDefinition } from '../types/secret-agent-definition';
+declare const definition: SecretAgentDefinition;
+export default definition;

package/dist/agents/team/senior-staff-engineer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const seniorStaffEngineer: AgentDefinition;
+export default seniorStaffEngineer;

package/dist/agents/team/staff-engineer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const staffEngineer: AgentDefinition;
+export default staffEngineer;

package/dist/agents/team/sub-manager.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const subManager: AgentDefinition;
+export default subManager;

package/dist/agents/team/tester.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const tester: AgentDefinition;
+export default tester;

package/dist/agents/team/vp-engineering.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from '../types/agent-definition';
+declare const vpEngineering: AgentDefinition;
+export default vpEngineering;

package/dist/agents/types/agent-definition.d.ts

@@ -0,0 +1,296 @@
+/**
+ * LevelCode Agent Type Definitions
+ *
+ * This file provides TypeScript type definitions for creating custom LevelCode agents.
+ * Import these types in your agent files to get full type safety and IntelliSense.
+ *
+ * Usage in .agents/your-agent.ts:
+ *   import { AgentDefinition, ToolName, ModelName } from './types/agent-definition'
+ *
+ *   const definition: AgentDefinition = {
+ *     // ... your agent configuration with full type safety ...
+ *   }
+ *
+ *   export default definition
+ */
+export interface AgentDefinition {
+    /** Unique identifier for this agent. Must contain only lowercase letters, numbers, and hyphens, e.g. 'code-reviewer' */
+    id: string;
+    /** Version string (if not provided, will default to '0.0.1' and be bumped on each publish) */
+    version?: string;
+    /** Publisher ID for the agent. Must be provided if you want to publish the agent. */
+    publisher?: string;
+    /** Human-readable name for the agent */
+    displayName: string;
+    /** AI model to use for this agent. Can be any model in OpenRouter: https://openrouter.ai/models */
+    model: ModelName;
+    /**
+     * https://openrouter.ai/docs/use-cases/reasoning-tokens
+     * One of `max_tokens` or `effort` is required.
+     * If `exclude` is true, reasoning will be removed from the response. Default is false.
+     */
+    reasoningOptions?: {
+        enabled?: boolean;
+        exclude?: boolean;
+    } & ({
+        max_tokens: number;
+    } | {
+        effort: 'high' | 'medium' | 'low' | 'minimal' | 'none';
+    });
+    /**
+     * Provider routing options for OpenRouter.
+     * Controls which providers to use and fallback behavior.
+     * See https://openrouter.ai/docs/features/provider-routing
+     */
+    providerOptions?: {
+        /**
+         * List of provider slugs to try in order (e.g. ["anthropic", "openai"])
+         */
+        order?: string[];
+        /**
+         * Whether to allow backup providers when primary is unavailable (default: true)
+         */
+        allow_fallbacks?: boolean;
+        /**
+         * Only use providers that support all parameters in your request (default: false)
+         */
+        require_parameters?: boolean;
+        /**
+         * Control whether to use providers that may store data
+         */
+        data_collection?: 'allow' | 'deny';
+        /**
+         * List of provider slugs to allow for this request
+         */
+        only?: string[];
+        /**
+         * List of provider slugs to skip for this request
+         */
+        ignore?: string[];
+        /**
+         * List of quantization levels to filter by (e.g. ["int4", "int8"])
+         */
+        quantizations?: Array<'int4' | 'int8' | 'fp4' | 'fp6' | 'fp8' | 'fp16' | 'bf16' | 'fp32' | 'unknown'>;
+        /**
+         * Sort providers by price, throughput, or latency
+         */
+        sort?: 'price' | 'throughput' | 'latency';
+        /**
+         * Maximum pricing you want to pay for this request
+         */
+        max_price?: {
+            prompt?: number | string;
+            completion?: number | string;
+            image?: number | string;
+            audio?: number | string;
+            request?: number | string;
+        };
+    };
+    /** MCP servers by name. Names cannot contain `/`. */
+    mcpServers?: Record<string, MCPConfig>;
+    /**
+     * Tools this agent can use.
+     *
+     * By default, all tools are available from any specified MCP server. In
+     * order to limit the tools from a specific MCP server, add the tool name(s)
+     * in the format `'mcpServerName/toolName1'`, `'mcpServerName/toolName2'`,
+     * etc.
+     */
+    toolNames?: (ToolName | (string & {}))[];
+    /** Other agents this agent can spawn, like 'levelcode/file-picker@0.0.1'.
+     *
+     * Use the fully qualified agent id from the agent store, including publisher and version: 'levelcode/file-picker@0.0.1'
+     * (publisher and version are required!)
+     *
+     * Or, use the agent id from a local agent file in your .agents directory: 'file-picker'.
+     */
+    spawnableAgents?: string[];
+    /** The input schema required to spawn the agent. Provide a prompt string and/or a params object or none.
+     * 80% of the time you want just a prompt string with a description:
+     * inputSchema: {
+     *   prompt: { type: 'string', description: 'A description of what info would be helpful to the agent' }
+     * }
+     */
+    inputSchema?: {
+        prompt?: {
+            type: 'string';
+            description?: string;
+        };
+        params?: JsonObjectSchema;
+    };
+    /** How the agent should output a response to its parent (defaults to 'last_message')
+     *
+     * last_message: The last message from the agent, typically after using tools.
+     *
+     * all_messages: All messages from the agent, including tool calls and results.
+     *
+     * structured_output: Make the agent output a JSON object. Can be used with outputSchema or without if you want freeform json output.
+     */
+    outputMode?: 'last_message' | 'all_messages' | 'structured_output';
+    /** JSON schema for structured output (when outputMode is 'structured_output') */
+    outputSchema?: JsonObjectSchema;
+    /** Prompt for when and why to spawn this agent. Include the main purpose and use cases.
+     *
+     * This field is key if the agent is intended to be spawned by other agents. */
+    spawnerPrompt?: string;
+    /** Whether to include conversation history from the parent agent in context.
+     *
+     * Defaults to false.
+     * Use this when the agent needs to know all the previous messages in the conversation.
+     */
+    includeMessageHistory?: boolean;
+    /** Whether to inherit the parent agent's system prompt instead of using this agent's own systemPrompt.
+     *
+     * Defaults to false.
+     * Use this when you want to enable prompt caching by preserving the same system prompt prefix.
+     * Cannot be used together with the systemPrompt field.
+     */
+    inheritParentSystemPrompt?: boolean;
+    /** Background information for the agent. Fairly optional. Prefer using instructionsPrompt for agent instructions. */
+    systemPrompt?: string;
+    /** Instructions for the agent.
+     *
+     * IMPORTANT: Updating this prompt is the best way to shape the agent's behavior.
+     * This prompt is inserted after each user input. */
+    instructionsPrompt?: string;
+    /** Prompt inserted at each agent step.
+     *
+     * Powerful for changing the agent's behavior, but usually not necessary for smart models.
+     * Prefer instructionsPrompt for most instructions. */
+    stepPrompt?: string;
+    /** Programmatically step the agent forward and run tools.
+     *
+     * You can either yield:
+     * - A tool call object with toolName and input properties.
+     * - 'STEP' to run agent's model and generate one assistant message.
+     * - 'STEP_ALL' to run the agent's model until it uses the end_turn tool or stops includes no tool calls in a message.
+     *
+     * Or use 'return' to end the turn.
+     *
+     * Example 1:
+     * function* handleSteps({ agentState, prompt, params, logger }) {
+     *   logger.info('Starting file read process')
+     *   const { toolResult } = yield {
+     *     toolName: 'read_files',
+     *     input: { paths: ['file1.txt', 'file2.txt'] }
+     *   }
+     *   yield 'STEP_ALL'
+     *
+     *   // Optionally do a post-processing step here...
+     *   logger.info('Files read successfully, setting output')
+     *   yield {
+     *     toolName: 'set_output',
+     *     input: {
+     *       output: 'The files were read successfully.',
+     *     },
+     *   }
+     * }
+     *
+     * Example 2:
+     * handleSteps: function* ({ agentState, prompt, params, logger }) {
+     *   while (true) {
+     *     logger.debug('Spawning thinker agent')
+     *     yield {
+     *       toolName: 'spawn_agents',
+     *       input: {
+     *         agents: [
+     *         {
+     *           agent_type: 'thinker',
+     *           prompt: 'Think deeply about the user request',
+     *         },
+     *       ],
+     *     },
+     *   }
+     *   const { stepsComplete } = yield 'STEP'
+     *   if (stepsComplete) break
+     * }
+     * }
+     */
+    handleSteps?: (context: AgentStepContext) => Generator<ToolCall | 'STEP' | 'STEP_ALL' | StepText | GenerateN, void, {
+        agentState: AgentState;
+        toolResult: ToolResultOutput[] | undefined;
+        stepsComplete: boolean;
+        nResponses?: string[];
+    }>;
+}
+export interface AgentState {
+    agentId: string;
+    runId: string;
+    parentId: string | undefined;
+    /** The agent's conversation history: messages from the user and the assistant. */
+    messageHistory: Message[];
+    /** The last value set by the set_output tool. This is a plain object or undefined if not set. */
+    output: Record<string, any> | undefined;
+    /** The system prompt for this agent. */
+    systemPrompt: string;
+    /** The tool definitions for this agent. */
+    toolDefinitions: Record<string, {
+        description: string | undefined;
+        inputSchema: {};
+    }>;
+    /**
+     * The token count from the Anthropic API.
+     * This is updated on every agent step via the /api/v1/token-count endpoint.
+     */
+    contextTokenCount: number;
+}
+/**
+ * Context provided to handleSteps generator function
+ */
+export interface AgentStepContext {
+    agentState: AgentState;
+    prompt?: string;
+    params?: Record<string, any>;
+    logger: Logger;
+}
+export type StepText = {
+    type: 'STEP_TEXT';
+    text: string;
+};
+export type GenerateN = {
+    type: 'GENERATE_N';
+    n: number;
+};
+/**
+ * Tool call object for handleSteps generator
+ */
+export type ToolCall<T extends ToolName = ToolName> = {
+    [K in T]: {
+        toolName: K;
+        input: GetToolParams<K>;
+        includeToolCall?: boolean;
+    };
+}[T];
+/**
+ * File operation tools
+ */
+export type FileEditingTools = 'read_files' | 'write_file' | 'str_replace';
+/**
+ * Code analysis tools
+ */
+export type CodeAnalysisTools = 'code_search' | 'find_files' | 'read_files';
+/**
+ * Terminal and system tools
+ */
+export type TerminalTools = 'run_terminal_command' | 'code_search';
+/**
+ * Web and browser tools
+ */
+export type WebTools = 'web_search' | 'read_docs';
+/**
+ * Agent management tools
+ */
+export type AgentTools = 'spawn_agents';
+/**
+ * Output and control tools
+ */
+export type OutputTools = 'set_output';
+/**
+ * AI models available for agents. Pick from our selection of recommended models or choose any model in OpenRouter.
+ *
+ * See available models at https://openrouter.ai/models
+ */
+export type ModelName = 'openai/gpt-5.1' | 'openai/gpt-5.1-chat' | 'openai/gpt-5-mini' | 'openai/gpt-5-nano' | 'anthropic/claude-sonnet-4.5' | 'anthropic/claude-opus-4.1' | 'google/gemini-2.5-pro' | 'google/gemini-2.5-flash' | 'google/gemini-2.5-flash-lite' | 'google/gemini-2.5-flash-preview-09-2025' | 'google/gemini-2.5-flash-lite-preview-09-2025' | 'x-ai/grok-4-07-09' | 'x-ai/grok-4-fast' | 'x-ai/grok-code-fast-1' | 'qwen/qwen3-max' | 'qwen/qwen3-coder-plus' | 'qwen/qwen3-coder' | 'qwen/qwen3-coder:nitro' | 'qwen/qwen3-coder-flash' | 'qwen/qwen3-235b-a22b-2507' | 'qwen/qwen3-235b-a22b-2507:nitro' | 'qwen/qwen3-235b-a22b-thinking-2507' | 'qwen/qwen3-235b-a22b-thinking-2507:nitro' | 'qwen/qwen3-30b-a3b' | 'qwen/qwen3-30b-a3b:nitro' | 'deepseek/deepseek-chat-v3-0324' | 'deepseek/deepseek-chat-v3-0324:nitro' | 'deepseek/deepseek-r1-0528' | 'deepseek/deepseek-r1-0528:nitro' | 'moonshotai/kimi-k2' | 'moonshotai/kimi-k2:nitro' | 'z-ai/glm-4.6' | 'z-ai/glm-4.6:nitro' | (string & {});
+import type { ToolName, GetToolParams } from './tools';
+import type { Message, ToolResultOutput, JsonObjectSchema, MCPConfig, Logger } from './util-types';
+export type { ToolName, GetToolParams };

package/dist/agents/types/secret-agent-definition.d.ts

@@ -0,0 +1,19 @@
+import type { AgentDefinition } from './agent-definition';
+import type * as Tools from './tools';
+export type { Tools };
+export type AllToolNames = Tools.ToolName | 'add_subgoal' | 'browser_logs' | 'create_plan' | 'spawn_agent_inline' | 'update_subgoal';
+export interface SecretAgentDefinition extends Omit<AgentDefinition, 'toolNames'> {
+    /** Tools this agent can use. */
+    toolNames?: AllToolNames[];
+}
+declare const placeholderNames: readonly ["AGENT_NAME", "AGENTS_PROMPT", "FILE_TREE_PROMPT_SMALL", "FILE_TREE_PROMPT", "FILE_TREE_PROMPT_LARGE", "GIT_CHANGES_PROMPT", "INITIAL_AGENT_PROMPT", "KNOWLEDGE_FILES_CONTENTS", "PROJECT_ROOT", "REMAINING_STEPS", "SYSTEM_INFO_PROMPT", "TOOLS_PROMPT", "USER_CWD", "USER_INPUT_PROMPT"];
+type PlaceholderType<T extends readonly string[]> = {
+    [K in T[number]]: `{LEVELCODE_${K}}`;
+};
+export declare const PLACEHOLDER: PlaceholderType<typeof placeholderNames>;
+export type PlaceholderValue = (typeof PLACEHOLDER)[keyof typeof PLACEHOLDER];
+export declare const placeholderValues: ("{LEVELCODE_AGENT_NAME}" | "{LEVELCODE_FILE_TREE_PROMPT_SMALL}" | "{LEVELCODE_FILE_TREE_PROMPT}" | "{LEVELCODE_FILE_TREE_PROMPT_LARGE}" | "{LEVELCODE_GIT_CHANGES_PROMPT}" | "{LEVELCODE_INITIAL_AGENT_PROMPT}" | "{LEVELCODE_KNOWLEDGE_FILES_CONTENTS}" | "{LEVELCODE_PROJECT_ROOT}" | "{LEVELCODE_REMAINING_STEPS}" | "{LEVELCODE_SYSTEM_INFO_PROMPT}" | "{LEVELCODE_USER_CWD}" | "{LEVELCODE_USER_INPUT_PROMPT}" | "{LEVELCODE_AGENTS_PROMPT}" | "{LEVELCODE_TOOLS_PROMPT}")[];
+export declare const AgentTemplateTypeList: readonly ["base", "base_lite", "base_max", "base_experimental", "claude4_gemini_thinking", "superagent", "base_agent_builder", "ask", "dry_run", "thinker", "file_picker", "file_explorer", "researcher", "reviewer", "agent_builder", "example_programmatic"];
+type UnderscoreToDash<S extends string> = S extends `${infer L}_${infer R}` ? `${L}-${UnderscoreToDash<R>}` : S;
+export declare const AgentTemplateTypes: { [K in (typeof AgentTemplateTypeList)[number]]: UnderscoreToDash<K>; };
+export type AgentTemplateType = (typeof AgentTemplateTypeList)[number] | (string & {});