agent-afk 5.1.0 → 5.2.0

package/dist/agent/providers/anthropic-direct/types.d.ts

@@ -0,0 +1,122 @@
+import type { ContentBlockParam, MessageParam, RawMessageStreamEvent, ThinkingConfigParam, ToolUseBlock, Usage } from '@anthropic-ai/sdk/resources';
+import type { ProviderEvent, ProviderUsage } from '../../provider.js';
+import type { ToolFailureClass } from '../../trace/types.js';
+export type AuthMode = 'oauth' | 'api-key';
+export interface ToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+    signal: AbortSignal;
+}
+export interface RenderHints {
+    diff?: import('../../../utils/diff.js').DiffPayload;
+}
+export interface ToolResult {
+    content: string;
+    isError?: boolean;
+    truncated?: boolean;
+    circuitBreaker?: boolean;
+    failureClass?: ToolFailureClass;
+    render?: RenderHints;
+    testResult?: import('../../tools/handlers/test-runner-detector.js').TestResult;
+    image?: {
+        mediaType: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+        data: string;
+    };
+}
+export type TranslateOutput = {
+    kind: 'event';
+    event: ProviderEvent;
+} | {
+    kind: 'turn-result';
+    result: TurnResult;
+};
+export interface TranslateCtx {
+    sessionId: string;
+}
+export interface TurnResult {
+    stopReason: string | null;
+    assistantBlocks: ContentBlockParam[];
+    toolUseBlocks: ToolUseBlock[];
+    usage: Usage | null;
+    text: string;
+}
+export interface RunTurnInput {
+    client: AnthropicClientLike;
+    messages: MessageParam[];
+    system: ContentBlockParam[] | string | null;
+    tools: AnthropicToolDef[] | null;
+    toolDispatcher: ToolDispatcherLike;
+    model: string;
+    maxTokens: number;
+    headers: Record<string, string>;
+    signal: AbortSignal;
+    ctx: TranslateCtx;
+    maxToolUseIterations?: number;
+    thinking?: ThinkingConfigParam;
+    effort?: import('../../types/sdk-types.js').EffortLevel;
+    baseUrl?: string;
+    traceWriter?: import('../../trace/index.js').TraceWriter;
+    onUsageProgress?: (usage: ProviderUsage) => void;
+}
+export interface AnthropicClientLike {
+    messages: {
+        create(params: AnthropicMessagesCreateParams, options?: {
+            headers?: Record<string, string>;
+            signal?: AbortSignal;
+        }): Promise<AsyncIterable<RawMessageStreamEvent>> | AsyncIterable<RawMessageStreamEvent>;
+    };
+}
+export interface WireToolDef {
+    name: string;
+    description?: string;
+    input_schema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [k: string]: unknown;
+    };
+}
+export interface AnthropicMessagesCreateParams {
+    model: string;
+    max_tokens: number;
+    messages: MessageParam[];
+    system?: ContentBlockParam[] | string;
+    tools?: WireToolDef[];
+    thinking?: ThinkingConfigParam;
+    output_config?: {
+        effort?: import('../../types/sdk-types.js').EffortLevel;
+    };
+    stream: true;
+    metadata?: Record<string, unknown>;
+}
+export type ToolCategory = 'read' | 'write' | 'shell' | 'subagent' | 'skill' | 'dag' | 'mcp' | 'web' | 'browser' | 'planning' | 'schedule' | 'other';
+export interface AnthropicToolDef {
+    name: string;
+    description?: string;
+    input_schema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [k: string]: unknown;
+    };
+    category?: ToolCategory;
+    concurrencySafe?: boolean;
+    riskClass?: 'safe' | 'caution' | 'destructive';
+}
+export interface ToolDispatcherLike {
+    execute(call: ToolCall): Promise<ToolResult>;
+    executeBatch?(calls: ToolCall[]): Promise<ToolResult[]>;
+    setResolveBase?(cwd: string): void;
+    setAllowAll?(allow: boolean): void;
+}
+interface ModelPricing {
+    inputPerMTok: number;
+    outputPerMTok: number;
+    cacheWritePerMTok?: number;
+    cacheReadPerMTok?: number;
+}
+export declare const MODEL_PRICING: ReadonlyMap<string, ModelPricing>;
+export declare function deriveCallCostUsd(model: string, inputTokens: number, outputTokens: number, cachedInputTokens: number, cacheCreationTokens: number): number | undefined;
+export declare function toProviderUsage(usage: Usage | null, stopReason: string | null, model?: string): ProviderUsage;
+export { sumProviderUsage } from '../../usage.js';

package/dist/agent/providers/anthropic-direct/usage-limit.d.ts

@@ -0,0 +1,21 @@
+export type UsageLimitClassification = {
+    kind: 'oauth-limit';
+    resetsAt: Date;
+} | {
+    kind: 'oauth-limit-no-ts';
+} | {
+    kind: 'credit-exhausted';
+};
+export declare function classifyUsageLimitError(error: Error): UsageLimitClassification | null;
+export interface WaitForResetOpts {
+    resetsAt: Date;
+    signal: AbortSignal;
+    readToken?: () => string | undefined;
+}
+export declare function waitForReset(opts: WaitForResetOpts): Promise<'aborted' | 'timer' | 'hot-swap'>;
+export interface WaitForHotSwapOpts {
+    signal: AbortSignal;
+    readToken?: () => string | undefined;
+    retryAfterMs?: number;
+}
+export declare function waitForHotSwap(opts: WaitForHotSwapOpts): Promise<'aborted' | 'hot-swap' | 'timer'>;

package/dist/agent/providers/index.d.ts

@@ -0,0 +1,16 @@
+import type { ModelProvider } from '../provider.js';
+import { anthropicDirectProvider } from './anthropic-direct/index.js';
+import { type ModelSlots } from '../session/model-slots.js';
+export type BundledProviderName = 'anthropic' | 'anthropic-direct' | 'openai-compatible' | 'openai-codex';
+export interface ProviderRouteHints {
+    explicit?: string;
+    openaiBaseUrl?: string;
+    slots?: ModelSlots;
+}
+export declare function providerForModel(model: string | undefined, hints?: ProviderRouteHints): BundledProviderName;
+export declare function resolveProvider(model: string | undefined, hints?: ProviderRouteHints, opts?: {
+    customTools?: import('../tools/custom-tool.js').CustomToolDef[];
+}): ModelProvider;
+export { anthropicDirectProvider };
+export { AnthropicDirectProvider } from './anthropic-direct/index.js';
+export { OpenAICompatibleProvider, openaiCompatibleProvider } from './openai-compatible/index.js';

package/dist/agent/providers/openai-compatible/auth.d.ts

@@ -0,0 +1,32 @@
+export type OpenAIAuthSource = 'config' | 'env' | 'codex-cli' | 'chatgpt-oauth' | 'no-usable-auth' | 'no-usable-auth-codex-oauth';
+export interface OpenAIAuthResolution {
+    apiKey: string | null;
+    source: OpenAIAuthSource;
+    last4?: string;
+    envVar?: 'OPENAI_API_KEY' | 'CODEX_API_KEY';
+    accountId?: string;
+    expiresAt?: number;
+}
+export interface AuthResolverDeps {
+    readEnv?: (key: string) => string | undefined;
+    homedir?: () => string;
+    readFile?: (path: string) => string | null;
+}
+export declare function resolveOpenAIAuth(explicitConfigKey: string | undefined, deps?: AuthResolverDeps): OpenAIAuthResolution;
+type CodexAuthParse = {
+    kind: 'apikey';
+    apiKey: string;
+} | {
+    kind: 'chatgpt';
+    accessToken?: string;
+    accountId?: string;
+    expiresAt?: number;
+} | {
+    kind: 'no-key';
+} | {
+    kind: 'invalid';
+};
+export declare function parseCodexAuthJson(raw: string): CodexAuthParse;
+export declare function decodeJwtClaims(token: string): Record<string, unknown> | null;
+export declare function formatAuthDiagnostic(resolution: OpenAIAuthResolution): string;
+export {};

package/dist/agent/providers/openai-compatible/index.d.ts

@@ -0,0 +1,53 @@
+import type { ModelProvider, ProviderQuery, ProviderQueryArgs, ProviderCompleteArgs } from '../../provider.js';
+import type { HookRegistry } from '../../hooks.js';
+import type { SubagentExecutor } from '../../tools/subagent-executor.js';
+import type { SkillExecutor } from '../../tools/skill-executor.js';
+import type { ComposeExecutor } from '../../tools/compose-executor.js';
+import { type ToolPermissionConfig } from '../../tools/permissions.js';
+import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
+import { MemoryStore } from '../../memory/index.js';
+export interface OpenAICompatibleProviderOptions {
+    baseURL?: string;
+    hookRegistry?: HookRegistry;
+    permissions?: ToolPermissionConfig;
+    subagentExecutor?: SubagentExecutor;
+    skillExecutor?: SkillExecutor;
+    composeExecutor?: ComposeExecutor;
+    memoryStore?: MemoryStore;
+    surface?: string;
+    readOnlyMemory?: boolean;
+    readOnlyBash?: boolean;
+    tools?: ToolDispatcher;
+    mcpManager?: import('../../mcp/index.js').McpManager;
+    customTools?: import('../../tools/custom-tool.js').CustomToolDef[];
+}
+export declare class OpenAICompatibleProvider implements ModelProvider {
+    readonly name = "openai-compatible";
+    private readonly providerOpts;
+    private readonly memoryStore;
+    private readonly schemas;
+    private _sharedReadRoots;
+    private _sharedWriteRoots;
+    private _currentPermissionMode;
+    private _initialResolveBase;
+    private _presenceSessionId;
+    constructor(opts?: OpenAICompatibleProviderOptions);
+    query(args: ProviderQueryArgs): ProviderQuery;
+    private buildDispatcher;
+    private ensureSharedRoots;
+    addReadRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    addWriteRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    revokeRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    getGrants(): {
+        resolveBase: string | undefined;
+        readRoots: string[];
+        writeRoots: string[];
+        allowAll: boolean;
+    };
+    private appendProviderAuditLog;
+    close(): void;
+    complete(args: ProviderCompleteArgs): Promise<string>;
+}
+export declare const openaiCompatibleProvider: ModelProvider;
+export { resolveOpenAIAuth, formatAuthDiagnostic, type OpenAIAuthResolution, type OpenAIAuthSource, } from './auth.js';
+export { OpenAICompatibleQuery, __setOpenAIClientFactory } from './query.js';

package/dist/agent/providers/openai-compatible/loop.d.ts

@@ -0,0 +1,47 @@
+import type { AnthropicToolDef } from '../anthropic-direct/types.js';
+import type { ToolCall, ToolResult } from '../anthropic-direct/types.js';
+import type { AccumulatedToolCall } from './translate.js';
+import type { OpenAIMessage } from './messages.js';
+export interface OpenAIFunctionTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export declare function toolDefsToOpenAIFunctions(defs: readonly AnthropicToolDef[]): OpenAIFunctionTool[];
+export declare function accumulatedToolCallsToToolCalls(calls: readonly AccumulatedToolCall[], signal: AbortSignal): {
+    calls: ToolCall[];
+    parseErrors: Map<string, string>;
+};
+export interface OpenAIAssistantToolCallMessage {
+    role: 'assistant';
+    content: string | null;
+    tool_calls: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    reasoning_content?: string;
+}
+export declare function assistantMessageWithToolCalls(accumulatedText: string, toolCalls: readonly AccumulatedToolCall[], reasoningText?: string): OpenAIAssistantToolCallMessage;
+export interface OpenAIToolResultMessage {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+}
+export declare function toolResultsToMessages(results: readonly {
+    call: ToolCall;
+    result: ToolResult;
+}[]): OpenAIToolResultMessage[];
+export declare function toolImageFollowupMessage(results: readonly {
+    call: ToolCall;
+    result: ToolResult;
+}[], opts: {
+    vision: boolean;
+}): OpenAIMessage | undefined;
+export declare function summarizeToolCalls(calls: readonly AccumulatedToolCall[]): string;

package/dist/agent/providers/openai-compatible/messages.d.ts

@@ -0,0 +1,33 @@
+import type { AgentConfig, ResumeHistoryTurn } from '../../types/config-types.js';
+import type { ProviderUserTurn } from '../../provider.js';
+export interface OpenAITextPart {
+    type: 'text';
+    text: string;
+}
+export interface OpenAIImagePart {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+}
+export type OpenAIContentPart = OpenAITextPart | OpenAIImagePart;
+export interface OpenAIMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | OpenAIContentPart[];
+    tool_call_id?: string;
+    reasoning_content?: string;
+}
+export declare function imageOmittedNotice(model: string | undefined, count: number): string;
+export declare function flattenUserContent(content: ProviderUserTurn['content'], model?: string): string;
+export declare function buildUserContent(content: ProviderUserTurn['content'], opts: {
+    vision: boolean;
+    model: string;
+}): string | OpenAIContentPart[];
+export declare function resolveSystemPrompt(config: AgentConfig): string | undefined;
+export declare function buildMessages(args: {
+    config: AgentConfig;
+    resumeHistory?: ResumeHistoryTurn[];
+    priorTurns?: OpenAIMessage[];
+    currentUserText?: string;
+    vision?: boolean;
+}): OpenAIMessage[];

package/dist/agent/providers/openai-compatible/oneshot.d.ts

@@ -0,0 +1,17 @@
+import OpenAI from 'openai';
+export type OneShotOpenAIClientFactory = (opts: {
+    apiKey: string;
+    baseURL?: string;
+}) => OpenAI;
+export declare function __setOpenAIOneShotClientFactory(factory: OneShotOpenAIClientFactory | null): void;
+export interface OpenAIOneShotInput {
+    apiKey?: string;
+    baseURL?: string;
+    model: string;
+    system: string;
+    user: string;
+    maxTokens?: number;
+    signal?: AbortSignal;
+    clientFactory?: OneShotOpenAIClientFactory;
+}
+export declare function oneShotChatCompletion(input: OpenAIOneShotInput): Promise<string>;

package/dist/agent/providers/openai-compatible/query.d.ts

@@ -0,0 +1,79 @@
+import OpenAI from 'openai';
+import type { AgentConfig } from '../../types/config-types.js';
+import type { EffortLevel } from '../../types/sdk-types.js';
+import type { TraceWriter } from '../../trace/index.js';
+import type { ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderContextUsage, ProviderRewindResult, ProviderModelInfo, ProviderCommandInfo, ProviderAgentInfo, ProviderMcpServerStatus, ProviderAccountInfo } from '../../provider.js';
+import { type OpenAIAuthResolution, type AuthResolverDeps } from './auth.js';
+import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
+export declare function __setRetryBaseDelay(ms: number | null): void;
+export type OpenAIClientFactory = (opts: {
+    apiKey: string;
+    baseURL?: string;
+    defaultHeaders?: Record<string, string>;
+}) => OpenAI;
+export declare function __setOpenAIClientFactory(factory: OpenAIClientFactory | null): void;
+export interface OpenAICompatibleQueryOptions {
+    auth: OpenAIAuthResolution;
+    baseURL?: string;
+    model: string;
+    synthesizedSessionId: string;
+    promptStream: AsyncIterable<ProviderUserTurn>;
+    config: AgentConfig;
+    toolDispatcher?: ToolDispatcher;
+    onPermissionMode?: (mode: string) => void;
+    mcpManager?: import('../../mcp/index.js').McpManager;
+    useResponsesApi?: boolean;
+    traceWriter?: TraceWriter;
+}
+export declare function isOSeriesModel(model: string): boolean;
+export declare function mapEffortForOpenAI(effort: EffortLevel): 'low' | 'medium' | 'high';
+export declare function resolveReasoningEffort(effort: EffortLevel | undefined, model: string): 'low' | 'medium' | 'high' | undefined;
+export declare class OpenAICompatibleQuery implements ProviderQuery {
+    private readonly client;
+    private readonly opts;
+    private readonly initSessionId;
+    private readonly toolDispatcher;
+    private readonly onPermissionMode?;
+    private readonly openAITools;
+    private readonly wireMode;
+    private readonly traceWriter;
+    private priorTurns;
+    private currentModel;
+    private currentPermissionMode;
+    private abortController;
+    private pendingAbortReason;
+    private closed;
+    private closeResolve;
+    private readonly closedPromise;
+    private lastUsage;
+    constructor(opts: OpenAICompatibleQueryOptions);
+    [Symbol.asyncIterator](): AsyncIterator<ProviderEvent>;
+    private runTurn;
+    private _runTurnInner;
+    private finishTurn;
+    private clarifyResponsesError;
+    private runIteration;
+    private dispatchAndAppend;
+    interrupt(): Promise<void>;
+    setModel(model?: string): Promise<void>;
+    setPermissionMode(mode: string): Promise<void>;
+    setCwd(cwd: string): void;
+    supportedCommands(): Promise<ProviderCommandInfo[]>;
+    supportedModels(): Promise<ProviderModelInfo[]>;
+    supportedAgents(): Promise<ProviderAgentInfo[]>;
+    getContextUsage(): Promise<ProviderContextUsage>;
+    mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
+    accountInfo(): Promise<ProviderAccountInfo>;
+    rewindFiles(_userMessageId: string, _options?: {
+        dryRun?: boolean;
+    }): Promise<ProviderRewindResult>;
+    close(): void;
+}
+export declare function buildQueryFromConfig(config: AgentConfig, promptStream: AsyncIterable<ProviderUserTurn>, options?: {
+    baseURL?: string;
+    toolDispatcher?: ToolDispatcher;
+    onPermissionMode?: (mode: string) => void;
+    mcpManager?: import('../../mcp/index.js').McpManager;
+    useResponsesApi?: boolean;
+    authDeps?: AuthResolverDeps;
+}): OpenAICompatibleQuery;

package/dist/agent/providers/openai-compatible/responses-config.d.ts

@@ -0,0 +1,14 @@
+import type { OpenAIAuthResolution } from './auth.js';
+export declare const CHATGPT_BACKEND_BASE_URL = "https://chatgpt.com/backend-api/codex";
+export declare const DEFAULT_RESPONSES_INSTRUCTIONS = "You are a helpful assistant.";
+export declare const RESPONSES_OPT_IN_ENV = "AFK_OPENAI_USE_RESPONSES";
+export declare function isClaudeFamilyModel(model: string | undefined): boolean;
+export type WireMode = 'chat-completions' | 'responses';
+export interface WireResolution {
+    mode: WireMode;
+    baseURL?: string;
+    headers?: Record<string, string>;
+}
+export declare function envFlagEnabled(value: string | undefined): boolean;
+export declare function buildChatGptOAuthHeaders(accountId?: string): Record<string, string>;
+export declare function resolveWireMode(auth: Pick<OpenAIAuthResolution, 'source' | 'accountId'>, responsesOptIn?: boolean): WireResolution;

package/dist/agent/providers/openai-compatible/responses-messages.d.ts

@@ -0,0 +1,54 @@
+import type { OpenAIFunctionTool } from './loop.js';
+import type { OpenAIContentPart } from './messages.js';
+export interface ResponsesInputText {
+    type: 'input_text';
+    text: string;
+}
+export interface ResponsesInputImage {
+    type: 'input_image';
+    image_url: string;
+    detail: 'auto' | 'low' | 'high';
+}
+export type ResponsesContentPart = ResponsesInputText | ResponsesInputImage;
+export interface ResponsesInputMessage {
+    role: 'user' | 'assistant' | 'system' | 'developer';
+    content: string | ResponsesContentPart[];
+}
+export interface ResponsesFunctionCall {
+    type: 'function_call';
+    call_id: string;
+    name: string;
+    arguments: string;
+}
+export interface ResponsesFunctionCallOutput {
+    type: 'function_call_output';
+    call_id: string;
+    output: string;
+}
+export type ResponsesInputItem = ResponsesInputMessage | ResponsesFunctionCall | ResponsesFunctionCallOutput;
+export interface ResponsesFunctionTool {
+    type: 'function';
+    name: string;
+    parameters: Record<string, unknown>;
+    description?: string;
+}
+export interface BuildableMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | OpenAIContentPart[] | null;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        type?: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+export interface ResponsesRequest {
+    instructions?: string;
+    input: ResponsesInputItem[];
+    tools?: ResponsesFunctionTool[];
+}
+export declare function buildResponsesRequest(messages: readonly BuildableMessage[], openAITools?: readonly OpenAIFunctionTool[]): ResponsesRequest;
+export declare function responsesToolsFromOpenAITools(openAITools?: readonly OpenAIFunctionTool[]): ResponsesFunctionTool[];

package/dist/agent/providers/openai-compatible/responses-translate.d.ts

@@ -0,0 +1,30 @@
+import type { ProviderEvent } from '../../provider.js';
+import type { StreamState } from './translate.js';
+export interface ResponsesStreamEvent {
+    type: string;
+    delta?: string;
+    output_index?: number;
+    item_id?: string;
+    item?: {
+        type?: string;
+        id?: string;
+        call_id?: string;
+        name?: string;
+        arguments?: string;
+    };
+    response?: {
+        status?: string;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            total_tokens?: number;
+            input_tokens_details?: {
+                cached_tokens?: number;
+            };
+        };
+        incomplete_details?: {
+            reason?: string;
+        };
+    };
+}
+export declare function translateResponsesEvent(event: ResponsesStreamEvent, state: StreamState, sessionId: string): Generator<ProviderEvent>;

package/dist/agent/providers/openai-compatible/translate.d.ts

@@ -0,0 +1,53 @@
+import type { ProviderEvent, ProviderUsage } from '../../provider.js';
+export interface OpenAIChunk {
+    id?: string;
+    model?: string;
+    choices?: Array<{
+        index?: number;
+        delta?: {
+            role?: string;
+            content?: string | null;
+            reasoning_content?: string | null;
+            reasoning?: string | null;
+            tool_calls?: Array<{
+                index: number;
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }>;
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+    };
+}
+export interface StreamState {
+    assistantText: string;
+    reasoningText: string;
+    toolCallsByIndex: Map<number, AccumulatedToolCall>;
+    finishReason: string | null;
+    usage: OpenAIChunk['usage'] | null;
+    model: string | null;
+    id: string | null;
+}
+export interface AccumulatedToolCall {
+    index: number;
+    id: string;
+    name: string;
+    argumentsRaw: string;
+    startEmitted: boolean;
+}
+export declare function createStreamState(): StreamState;
+export declare function translateChunk(chunk: OpenAIChunk, state: StreamState, sessionId: string): Generator<ProviderEvent>;
+export declare function usageFromState(state: StreamState): ProviderUsage;
+export declare function finalizedToolCalls(state: StreamState): AccumulatedToolCall[];
+export declare function isToolCallStop(state: StreamState): boolean;

package/dist/agent/providers/router/provider-router.d.ts

@@ -0,0 +1,55 @@
+import type { ModelProvider, ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderCommandInfo, ProviderModelInfo, ProviderAgentInfo, ProviderContextUsage, ProviderMcpServerStatus, ProviderAccountInfo, ProviderRewindResult, ProviderCompactResult } from '../../provider.js';
+import type { AgentConfig } from '../../types/config-types.js';
+export interface ProviderRouterDeps {
+    resolveProvider: (model: string | undefined) => ModelProvider;
+    providerNameForModel: (model: string | undefined) => string;
+    resolveApiKey: (model: string | undefined) => string | undefined;
+}
+export interface ProviderRouterArgs {
+    prompt: AsyncIterable<ProviderUserTurn>;
+    config: AgentConfig;
+}
+export declare class ProviderRouter implements ProviderQuery {
+    private readonly outerIterator;
+    private readonly baseConfig;
+    private readonly deps;
+    private currentModel;
+    private currentPermissionMode;
+    private currentCwd;
+    private readonly startupFamily;
+    private active;
+    private activeModel;
+    private closed;
+    private readonly shadowHistory;
+    private pendingUserText;
+    private pendingAssistantText;
+    private lastSessionId;
+    constructor(args: ProviderRouterArgs, deps: ProviderRouterDeps);
+    private resolveInner;
+    private buildInner;
+    private closeActive;
+    private observeEvent;
+    private commitShadowTurn;
+    [Symbol.asyncIterator](): AsyncGenerator<ProviderEvent, void, unknown>;
+    private driveUntilInit;
+    interrupt(): Promise<void>;
+    setModel(model?: string): Promise<void>;
+    setPermissionMode(mode: string): Promise<void>;
+    setCwd(cwd: string): void;
+    reauth(): Promise<{
+        accountId: string;
+        swapped: boolean;
+    } | null>;
+    supportedCommands(): Promise<ProviderCommandInfo[]>;
+    supportedModels(): Promise<ProviderModelInfo[]>;
+    supportedAgents(): Promise<ProviderAgentInfo[]>;
+    getContextUsage(): Promise<ProviderContextUsage>;
+    mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
+    accountInfo(): Promise<ProviderAccountInfo>;
+    rewindFiles(userMessageId: string, options?: {
+        dryRun?: boolean;
+    }): Promise<ProviderRewindResult>;
+    compact(): Promise<ProviderCompactResult>;
+    reloadPlugins(...args: unknown[]): Promise<unknown>;
+    close(): Promise<void>;
+}

package/dist/agent/query.d.ts

@@ -0,0 +1,11 @@
+import type { ZodType } from 'zod';
+import type { AgentConfig, AgentModelInput, OutputEvent } from './types.js';
+export type QueryOptions = Partial<Omit<AgentConfig, 'model'>> & {
+    model?: AgentModelInput;
+};
+export declare function query(prompt: string, options?: QueryOptions): AsyncGenerator<OutputEvent, void, void>;
+export declare function queryText(prompt: string, options?: QueryOptions): Promise<string>;
+export declare function queryStructured<T>(prompt: string, schema: ZodType<T>, options?: QueryOptions & {
+    maxRetries?: number;
+    injectSchemaPrompt?: boolean;
+}): Promise<T>;

package/dist/agent/risk-classifier.d.ts

@@ -0,0 +1,6 @@
+export type RiskLevel = 'safe' | 'medium' | 'high';
+export interface RiskContext {
+    cwd: string;
+    workspaceRoot?: string;
+}
+export declare function classifyRisk(toolName: string, input: unknown, ctx: RiskContext): RiskLevel;