@rowan-agent/agent 0.4.11 → 0.5.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _rowan_agent_models from '@rowan-agent/models';
-import { LlmRequest, LlmResponse, LlmModelRef, LlmModelUsage, StreamFn, AgentEventListener, ToolCall, ToolResult, AgentMessage, Outcome, Skill as Skill$1, ContentBlock, ProviderConfig, Protocol, ModelCost, AgentEvent, LlmMessage } from '@rowan-agent/models';
+import { LlmRequest, LlmResponse, LlmModelRef, LlmModelUsage, AgentMessage, ContentBlock, ToolCall, ToolResult, Outcome, ProviderConfig, Skill as Skill$1, StreamFn, AgentEventListener, Protocol, ModelCost, AgentEvent, LlmMessage } from '@rowan-agent/models';
 export { AgentEvent, AgentEventListener, AgentMessage, LlmModelRef, Outcome, Skill, StreamFn, ToolResult, createDispatchStream, registerBuiltInApiProviders } from '@rowan-agent/models';
 import Type from 'typebox';
 
@@ -23,119 +23,6 @@ type ModelTranscript = {
     response: LlmResponse;
 };
 
-type BeforePhaseHook = (phaseId: string, input: PhaseContext) => Promise<BeforePhaseHookResult>;
-type AfterPhaseHook = (phaseId: string, output: PhaseOutput) => Promise<AfterPhaseHookResult>;
-type BeforePromptHook = (phaseId: string, input: PhaseContext) => Promise<PhaseContext>;
-type LoopMetrics = {
-    /** Number of phase iterations executed. */
-    iterations: number;
-    /** Phase transition history. */
-    phaseTransitions: Array<{
-        from: string;
-        to: string;
-        ts: string;
-    }>;
-    /** Number of times compaction was triggered. */
-    compactionCount: number;
-    /** Number of retry attempts due to transient errors. */
-    retryCount: number;
-    /** Loop start timestamp. */
-    startedAt: string;
-    /** Loop start time as epoch ms (for duration calculation). */
-    startedAtMs: number;
-    /** Loop end timestamp (set on completion). */
-    endedAt?: string;
-    /** Total wall-clock duration in ms. */
-    durationMs?: number;
-};
-type SessionState = {
-    currentPhase: string;
-    attempt: number;
-    metrics: LoopMetrics;
-    status: "idle" | "running" | "completed" | "aborted" | "failed";
-};
-type AgentConfig = {
-    context: AgentContext;
-    sessionId?: string;
-    model: LlmModelRef;
-    stream: StreamFn;
-    signal?: AbortSignal;
-    emit?: AgentEventListener;
-    phases?: PhaseRegistry;
-    runtime?: AgentRuntimePort;
-    beforeToolCall?: BeforeToolCall;
-    afterToolCall?: AfterToolCall;
-    beforePhase?: BeforePhaseHook;
-    afterPhase?: AfterPhaseHook;
-    beforePrompt?: BeforePromptHook;
-    maxAttempts?: number;
-    onModelTranscript?: (transcript: ModelTranscript, meta: {
-        phase: string;
-        model: LlmModelRef;
-    }) => Promise<void>;
-    onMessage?: (message: AgentMessage) => Promise<void>;
-    onOutcome?: (outcome: Outcome) => Promise<void>;
-    sessionState?: SessionState;
-};
-type ToolRunnerInput = {
-    config: AgentConfig;
-    toolCall: ToolCall;
-};
-type ToolRunner = (input: ToolRunnerInput) => Promise<ToolResult>;
-type AgentRuntimePort = {
-    tools?: ToolRunner;
-};
-
-type ToolContext = Pick<AgentContext, "skills"> & {
-    toolCallId: string;
-};
-type ToolExecutionMode = "sequential" | "parallel";
-type Tool<TArgs = unknown> = {
-    name: string;
-    description: string;
-    parameters: Type.TSchema;
-    /** One-line snippet shown in the system prompt tool list. */
-    promptSnippet?: string;
-    /** Additional guidelines appended to the system prompt when this tool is active. */
-    promptGuidelines?: string[];
-    /** Whether this tool can run concurrently with others. Default: "parallel". */
-    executionMode?: ToolExecutionMode;
-    execute(args: TArgs, context: ToolContext, signal?: AbortSignal): Promise<ToolResult>;
-};
-/** Context snapshot passed into the low-level agent loop. */
-type AgentContext = {
-    /** System prompt included with the request. */
-    systemPrompt: string;
-    /** Transcript visible to the model. */
-    messages: AgentMessage[];
-    /** Tools available for this run. */
-    tools: Tool[];
-    /** Skills available for this run. */
-    skills: Skill$1[];
-};
-type BeforeToolCall = (input: {
-    tool: Tool;
-    args: unknown;
-}) => Promise<{
-    allow: true;
-} | {
-    allow: false;
-    reason: string;
-}>;
-type AfterToolCall = (input: {
-    tool: Tool;
-    result: ToolResult;
-}) => Promise<ToolResult>;
-type RunResult = {
-    sessionId: string;
-    messages: AgentMessage[];
-    outcome: Outcome;
-    metrics: LoopMetrics;
-};
-type Unsubscribe = () => void;
-declare function createMessage(role: AgentMessage["role"], content: AgentMessage["content"], metadata?: Record<string, unknown>): AgentMessage;
-declare function messageContentText(content: AgentMessage["content"]): string;
-
 type ModelInvokeOutput = {
     text: string;
     contentBlocks: ContentBlock[];
@@ -159,89 +46,6 @@ type PhaseExecution = {
     executeTool(context: AgentContext, toolCall: ToolCall): Promise<ToolResult>;
 };
 
-/** Unified phase output — model decides routing via route. */
-type PhaseOutput = {
-    message: string;
-    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end */
-    route: string;
-    /** Phase name that produced this output */
-    phase?: string;
-    /** Tool calls from the model invocation (used by framework for route extraction) */
-    toolCalls?: Array<{
-        id: string;
-        name: string;
-        args: unknown;
-    }>;
-    /** Route reason extracted from route tool call (for hooks to inspect) */
-    routeReason?: string;
-    /** Structured data from this phase, passed to the next phase */
-    payload?: unknown;
-};
-/** Phase machine state — tracks position and inter-phase data */
-interface PhaseState {
-    current: string;
-    available: string[];
-    iterations: number;
-    payload?: unknown;
-}
-/** Everything a phase needs to execute */
-interface PhaseContext {
-    systemPrompt: string;
-    messages: AgentMessage[];
-    /** Phase-filtered tools */
-    tools: Tool[];
-    /** Phase-filtered skills */
-    skills: Skill$1[];
-    /** Phase machine state */
-    state: PhaseState;
-    /** Additional guideline bullets appended to the system prompt */
-    promptGuidelines?: string[];
-    /** Text to append after the system prompt */
-    appendSystemPrompt?: string;
-}
-/**
- * Loaded Phase object
- */
-interface Phase {
-    /** Unique identifier */
-    id: string;
-    /** Display name */
-    name: string;
-    /** Description */
-    description: string;
-    /** Restricted tools (undefined = all tools available) */
-    tools?: string[];
-    /** Restricted skills (undefined = all skills available) */
-    skills?: string[];
-    /** Forced next phase */
-    target?: string;
-    /** Expected input fields (key → description) */
-    input?: Record<string, string>;
-    /** If true, phase gets a fresh context when executed in parallel */
-    isolated?: boolean;
-    /** Path to PHASE.md file */
-    filePath: string;
-    /** Phase directory path */
-    baseDir: string;
-    /** PHASE.md body content */
-    content: string;
-    /** Model override for this phase (resolved from frontmatter) */
-    model?: LlmModelRef;
-    /** ExtensionAPI factory function (default export pattern) */
-    factory?: (api: ExtensionAPI) => Promise<void>;
-    /** Legacy run function */
-    run?: (context: PhaseContext, execution: PhaseExecution) => Promise<PhaseOutput | void>;
-}
-/**
- * Phase registry containing all loaded phases
- */
-interface PhaseRegistry {
-    /** Map of phase id to Phase object */
-    phases: Map<string, Phase>;
-    /** Entry phase id (null if no phases defined) */
-    entryPhaseId: string | null;
-}
-
 /**
  * Extension types — simplified for the new hook-based system.
  */
@@ -387,10 +191,8 @@ type HandlerFn = (...args: unknown[]) => Promise<unknown>;
  * Tracks what each extension registered for attribution and cleanup.
  */
 interface Extension {
-    /** Extension path (may be synthetic like `<builtin:phase:chat>`) */
+    /** Extension path (may be synthetic like `<inline>`) */
     path: string;
-    /** Resolved absolute path */
-    resolvedPath: string;
     /** Source info for error messages */
     sourceInfo: SourceInfo;
     /** Event handlers registered by this extension */
@@ -403,7 +205,7 @@ interface Extension {
 /**
  * Create an Extension object with empty collections.
  */
-declare function createExtension(extensionPath: string, resolvedPath: string, sourceInfo: SourceInfo): Extension;
+declare function createExtension(extensionPath: string, sourceInfo: SourceInfo): Extension;
 /**
  * Shared runtime state created by loader, used during registration and runtime.
  * All ExtensionAPI instances reference this shared state.
@@ -459,7 +261,6 @@ type LoadExtensionsResult = {
  */
 interface LoadedExtension {
     path: string;
-    resolvedPath: string;
     name: string;
     factory: ExtensionFactory;
     manifest?: ExtensionManifest;
@@ -1342,48 +1143,203 @@ declare class ExtensionRunner {
 }
 declare function createExtensionRunner(options?: ExtensionRunnerOptions): ExtensionRunner;
 
+type LoopMetrics = {
+    /** Number of phase iterations executed. */
+    iterations: number;
+    /** Phase transition history. */
+    phaseTransitions: Array<{
+        from: string;
+        to: string;
+        ts: string;
+    }>;
+    /** Number of times compaction was triggered. */
+    compactionCount: number;
+    /** Number of retry attempts due to transient errors. */
+    retryCount: number;
+    /** Loop start timestamp. */
+    startedAt: string;
+    /** Loop start time as epoch ms (for duration calculation). */
+    startedAtMs: number;
+    /** Loop end timestamp (set on completion). */
+    endedAt?: string;
+    /** Total wall-clock duration in ms. */
+    durationMs?: number;
+};
+type SessionState = {
+    currentPhase: string;
+    attempt: number;
+    metrics: LoopMetrics;
+    status: "idle" | "running" | "completed" | "aborted" | "failed";
+};
+
+type ToolContext = Pick<AgentContext, "skills"> & {
+    toolCallId: string;
+};
+type ToolExecutionMode = "sequential" | "parallel";
+type Tool<TArgs = unknown> = {
+    name: string;
+    description: string;
+    parameters: Type.TSchema;
+    /** One-line snippet shown in the system prompt tool list. */
+    promptSnippet?: string;
+    /** Additional guidelines appended to the system prompt when this tool is active. */
+    promptGuidelines?: string[];
+    /** Whether this tool can run concurrently with others. Default: "parallel". */
+    executionMode?: ToolExecutionMode;
+    execute(args: TArgs, context: ToolContext, signal?: AbortSignal): Promise<ToolResult>;
+};
+/** Context snapshot passed into the low-level agent loop. */
+type AgentContext = {
+    /** System prompt included with the request. */
+    systemPrompt: string;
+    /** Transcript visible to the model. */
+    messages: AgentMessage[];
+    /** Tools available for this run. */
+    tools: Tool[];
+    /** Skills available for this run. */
+    skills: Skill$1[];
+    /** Custom phases for this run. Agent normalizes this with the built-in default phase. */
+    phases?: PhaseRegistry;
+};
+type BeforeToolCall = (input: {
+    tool: Tool;
+    args: unknown;
+}) => Promise<{
+    allow: true;
+} | {
+    allow: false;
+    reason: string;
+}>;
+type AfterToolCall = (input: {
+    tool: Tool;
+    result: ToolResult;
+}) => Promise<ToolResult>;
+type RunResult = {
+    sessionId: string;
+    messages: AgentMessage[];
+    outcome: Outcome;
+    metrics: LoopMetrics;
+};
+type Unsubscribe = () => void;
+declare function createMessage(role: AgentMessage["role"], content: AgentMessage["content"], metadata?: Record<string, unknown>): AgentMessage;
+declare function messageContentText(content: AgentMessage["content"]): string;
+
+/** Unified phase output — model decides routing via route. */
+type PhaseOutput = {
+    message: string;
+    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end */
+    route: string;
+    /** Phase name that produced this output */
+    phase?: string;
+    /** Tool calls from the model invocation (used by framework for route extraction) */
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        args: unknown;
+    }>;
+    /** Route reason extracted from route tool call (for hooks to inspect) */
+    routeReason?: string;
+    /** Structured data from this phase, passed to the next phase */
+    payload?: unknown;
+};
+/** Phase machine state — tracks position and inter-phase data */
+interface PhaseState {
+    current: string;
+    available: string[];
+    iterations: number;
+    payload?: unknown;
+}
+/** Everything a phase needs to execute */
+interface PhaseContext {
+    systemPrompt: string;
+    messages: AgentMessage[];
+    /** Phase-filtered tools */
+    tools: Tool[];
+    /** Phase-filtered skills */
+    skills: Skill$1[];
+    /** Phase machine state */
+    state: PhaseState;
+    /** Additional guideline bullets appended to the system prompt */
+    promptGuidelines?: string[];
+    /** Text to append after the system prompt */
+    appendSystemPrompt?: string;
+}
 /**
- * Extension loader — discovers and loads extensions from the filesystem.
- *
- * Uses the new LoadedExtension type that works with ExtensionRunner.
+ * Loaded Phase object
  */
-
+interface Phase {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Restricted tools (undefined = all tools available) */
+    tools?: string[];
+    /** Restricted skills (undefined = all skills available) */
+    skills?: string[];
+    /** Forced next phase */
+    target?: string;
+    /** Expected input fields (key → description) */
+    input?: Record<string, string>;
+    /** If true, phase gets a fresh context when executed in parallel */
+    isolated?: boolean;
+    /** Path to PHASE.md file */
+    filePath: string;
+    /** Phase directory path */
+    baseDir: string;
+    /** PHASE.md body content */
+    content: string;
+    /** Model override for this phase (resolved from frontmatter) */
+    model?: LlmModelRef;
+    /** ExtensionAPI factory function (default export pattern) */
+    factory?: (api: ExtensionAPI) => Promise<void>;
+    /** Legacy run function */
+    run?: (context: PhaseContext, execution: PhaseExecution) => Promise<PhaseOutput | void>;
+}
 /**
- * Load a single extension from a factory function.
+ * Phase registry containing all loaded phases
  */
-declare function loadExtensionFromFactory(factory: ExtensionFactory, cwd: string, extensionPath?: string): LoadedExtension;
+interface PhaseRegistry {
+    /** Map of phase id to Phase object */
+    phases: Map<string, Phase>;
+    /** Entry phase id (null until Agent applies its default phase) */
+    entryPhaseId: string | null;
+}
+
+type WorkspacePaths = {
+    cwd: string;
+    rowanDir: string;
+};
+type ResolveWorkspaceOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    rowanDir?: string;
+};
+declare function resolveWorkspacePaths(options?: ResolveWorkspaceOptions): WorkspacePaths;
+declare function resolveInWorkspace(path: string, rootOrPaths: string | Pick<WorkspacePaths, "cwd">): string;
+
+type PhaseLoadTarget = string | Pick<WorkspacePaths, "rowanDir">;
 /**
- * Load extensions from file paths.
+ * Load a single phase from a PHASE.md file or phase directory.
+ *
+ * If a directory is provided, the loader reads its PHASE.md.
  */
-declare function loadExtensions(paths: string[], cwd: string): Promise<{
-    extensions: LoadedExtension[];
-    errors: Array<{
-        path: string;
-        error: string;
-    }>;
-}>;
+declare function loadPhase(targetPath: string): Promise<Phase>;
+declare function loadPhases(targetPath: PhaseLoadTarget): Promise<PhaseRegistry>;
 /**
- * Discover and load extensions from .rowan/extensions directory.
+ * Re-read all file-based phases from disk and update the registry in place.
+ * Extension-registered phases (with empty filePath) are preserved as-is.
  */
-declare function discoverAndLoadExtensions(cwd: string): Promise<{
-    extensions: LoadedExtension[];
-    errors: Array<{
-        path: string;
-        error: string;
-    }>;
-}>;
+declare function reloadPhases(registry: PhaseRegistry): Promise<void>;
 
-type ExtensionRunnerRef = {
-    current?: ExtensionRunner;
-};
 type AgentOptions = {
     context: AgentContext;
     model: LlmModelRef;
     stream: StreamFn;
     cwd?: string;
-    rowanDir?: string;
-    phases?: PhaseRegistry;
-    extensionRunnerRef?: ExtensionRunnerRef;
+    extensions?: LoadedExtension[];
     sessionId?: string;
     maxAttempts?: number;
     beforeToolCall?: BeforeToolCall;
@@ -1395,7 +1351,7 @@ type AgentOptions = {
         model: LlmModelRef;
     }) => Promise<void>;
 };
-type RunOptions = Partial<AgentConfig> & Pick<AgentConfig, "context">;
+type RunOptions = Partial<AgentOptions>;
 type AgentStatus = {
     sessionId?: string;
     context: AgentContext;
@@ -1412,6 +1368,12 @@ declare class Agent {
     private readonly pendingListenerTasks;
     private readonly listenerErrors;
     private activeRun?;
+    private extensionRunner?;
+    private loadedExtensions?;
+    private loadedExtensionsCwd?;
+    static loadSkills(targetPath: string): Promise<AgentContext["skills"]>;
+    static loadPhases(targetPath: Parameters<typeof loadPhases>[0]): Promise<PhaseRegistry>;
+    static loadExtensions(targetPath: string): Promise<LoadExtensionsResult>;
     constructor(options: AgentOptions);
     subscribe(listener: AgentEventListener): Unsubscribe;
     private emitToListeners;
@@ -1443,16 +1405,9 @@ declare class Agent {
      */
     private handleBeforePrompt;
     private handleRunFailure;
-    /**
-     * Discover and load phases and skills from the workspace.
-     *
-     * - Auto-discovers file-based phases from .rowan/phases/
-     * - Auto-discovers skills from .rowan/skills/
-     * - Merges with CLI-provided phases and skills
-     */
-    private discoverResources;
     private runWithLifecycle;
     private finishRun;
+    private loadExtensions;
     run(config?: RunOptions): Promise<RunResult>;
     abort(reason?: string): void;
     /**
@@ -1688,28 +1643,6 @@ type CoreToolContext = {
 };
 declare function createCoreTools(input?: CoreToolContext): Tool[];
 
-type RuntimeMode = "source" | "binary";
-type WorkspacePaths = {
-    mode: RuntimeMode;
-    cwd: string;
-    rowanDir: string;
-};
-type ResolveWorkspaceOptions = {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    execPath?: string;
-    entrypoint?: string;
-    homeDir?: string;
-    mode?: RuntimeMode;
-    rowanDir?: string;
-};
-declare function resolveWorkspacePaths(options?: ResolveWorkspaceOptions): WorkspacePaths;
-declare function resolveInWorkspace(path: string, rootOrPaths: string | Pick<WorkspacePaths, "cwd">): string;
-
-declare function resolveSkillPath(input: string, workspace?: WorkspacePaths): string;
-declare function loadSkill(path: string, workspace?: WorkspacePaths): Promise<Skill$1>;
-declare function loadSkills(workspace?: WorkspacePaths, paths?: string[]): Promise<Skill$1[]>;
-
 type ModelConfigFromFile = {
     id: string;
     name?: string;
@@ -1776,17 +1709,18 @@ declare class AgentEventStream extends EventStream<AgentEvent, AgentMessage[]> {
     constructor();
 }
 
-/**
- * Load all phases from .rowan/phases directory.
- *
- * Scans for subdirectories containing PHASE.md files.
- * Returns PhaseRegistry with entryPhaseId:
- * - null by default (caller must explicitly set to start from a specific phase)
- * - Set to a specific phase id to start from that phase
- *
- * When entryPhaseId is null, AgentLoop starts from "none" phase.
- */
-declare function loadPhases(workspace?: WorkspacePaths, paths?: string[]): Promise<PhaseRegistry>;
+/** Error thrown when the model returns an empty response (no text, no tool calls). */
+declare class EmptyResponseError extends Error {
+    readonly code = "empty_response";
+    constructor(message?: string);
+}
+/** Error thrown when a routed phase needs a route tool call but the model did not emit one. */
+declare class MissingRouteToolCallError extends Error {
+    readonly code = "missing_route_tool_call";
+    readonly phase: string;
+    readonly toolCallNames: string[];
+    constructor(phase: string, toolCallNames: string[]);
+}
 
 interface SystemPromptOptions {
     /** Base system prompt. */
@@ -1841,4 +1775,4 @@ declare function buildModelRequest(input: ModelRequestInput, options?: {
     model?: LlmModelRef;
 }): LlmRequest;
 
-export { type AbortEvent, type AfterPhaseEvent, type AfterPhaseHookResult, type AfterPhaseResult, type AfterToolCallEvent, type AfterToolCallResult, Agent, type AgentConfigFile, type AgentContext, type AgentEndEvent, AgentEventStream, type AgentOptions, type AgentStartEvent, type AgentStatus, type BeforePhaseEvent, type BeforePhaseHookResult, type BeforePhaseResult, type BeforePromptEvent, type BeforePromptResult, type BeforeToolCallEvent, type BeforeToolCallResult, type EventBus, EventStream, type ExecOptions, type ExecResult, type ExecutionTurn, type Extension, type ExtensionAPI, type ExtensionContext, type ExtensionError, type ExtensionErrorListener, type ExtensionFactory, type ExtensionManifest, type ExtensionPackageManifest, ExtensionRunner, type ExtensionRunnerOptions, type ExtensionRunnerRef, type ExtensionRuntime, type ExtensionUtils, HookError, type HookEvent, type HookEventType, type HookHandler, type HookResultMap, HooksManager, type LoadExtensionsResult, type LoadedExtension, LocalJsonlSessionManager, type LoopMetrics, type MessageEndEvent, type MessageStartEvent, type MessageUpdateEvent, type ModelConfigFromFile, type ModelTranscript, type Phase, type PhaseContext, type PhaseDefinition, type PhaseExecution, type PhaseOutput, type PhaseRegistration, type PhaseRegistry, type PhaseRun, type PhaseState, type ProviderConfigFromFile, type QueueUpdateEvent, type RegisteredPhase, type RegisteredTool, type RunOptions, type RunResult, type SavePointEvent, type Session, type SessionListItem, type SettledEvent, type SourceInfo, type Tool, type ToolDefinition, type ToolExecutionEndEvent, type ToolExecutionResult, type ToolExecutionStartEvent, type ToolExecutionUpdateEvent, type TurnEndEvent, type TurnStartEvent, type WorkspacePaths, appendUserTurn, buildModelRequest, buildSystemPrompt, conversationMessages, createCoreTools, createEventBus, createExtension, createExtensionAPI, createExtensionRunner, createExtensionRuntime, createId, createMessage, createSession, createSourceInfo, createTimestamp, discoverAndLoadExtensions, getGlobalHooks, interpolateEnvVars, latestUserInput, loadConfigFile, loadExtensionFromFactory, loadExtensions, loadPhases, loadSkill, loadSkills, messageContentText, parseModelRef, registerConfigModels, resetGlobalHooks, resolveDefaultModel, resolveInWorkspace, resolveSkillPath, resolveWorkspacePaths, serializeSkills };
+export { type AbortEvent, type AfterPhaseEvent, type AfterPhaseHookResult, type AfterPhaseResult, type AfterToolCallEvent, type AfterToolCallResult, Agent, type AgentConfigFile, type AgentContext, type AgentEndEvent, AgentEventStream, type AgentOptions, type AgentStartEvent, type AgentStatus, type BeforePhaseEvent, type BeforePhaseHookResult, type BeforePhaseResult, type BeforePromptEvent, type BeforePromptResult, type BeforeToolCallEvent, type BeforeToolCallResult, EmptyResponseError, type EventBus, EventStream, type ExecOptions, type ExecResult, type ExecutionTurn, type Extension, type ExtensionAPI, type ExtensionContext, type ExtensionError, type ExtensionErrorListener, type ExtensionFactory, type ExtensionManifest, type ExtensionPackageManifest, ExtensionRunner, type ExtensionRunnerOptions, type ExtensionRuntime, type ExtensionUtils, HookError, type HookEvent, type HookEventType, type HookHandler, type HookResultMap, HooksManager, type LoadExtensionsResult, type LoadedExtension, LocalJsonlSessionManager, type LoopMetrics, type MessageEndEvent, type MessageStartEvent, type MessageUpdateEvent, MissingRouteToolCallError, type ModelConfigFromFile, type ModelTranscript, type Phase, type PhaseContext, type PhaseDefinition, type PhaseExecution, type PhaseOutput, type PhaseRegistration, type PhaseRegistry, type PhaseRun, type PhaseState, type ProviderConfigFromFile, type QueueUpdateEvent, type RegisteredPhase, type RegisteredTool, type RunOptions, type RunResult, type SavePointEvent, type Session, type SessionListItem, type SettledEvent, type SourceInfo, type Tool, type ToolDefinition, type ToolExecutionEndEvent, type ToolExecutionResult, type ToolExecutionStartEvent, type ToolExecutionUpdateEvent, type TurnEndEvent, type TurnStartEvent, type WorkspacePaths, appendUserTurn, buildModelRequest, buildSystemPrompt, conversationMessages, createCoreTools, createEventBus, createExtension, createExtensionAPI, createExtensionRunner, createExtensionRuntime, createId, createMessage, createSession, createSourceInfo, createTimestamp, getGlobalHooks, interpolateEnvVars, latestUserInput, loadConfigFile, loadPhase, loadPhases, messageContentText, parseModelRef, registerConfigModels, reloadPhases, resetGlobalHooks, resolveDefaultModel, resolveInWorkspace, resolveWorkspacePaths, serializeSkills };