@neovate/code 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -1,9 +1,129 @@
-import { AgentInputItem } from '@openai/agents';
+import { AgentOutputItem } from '@openai/agents';
+import { FunctionTool } from '@openai/agents';
+import { LanguageModelV1 } from '@openrouter/ai-sdk-provider';
+import type { LanguageModelV1 as LanguageModelV1_2 } from '@ai-sdk/provider';
+import { LanguageModelV1CallWarning } from '@ai-sdk/provider';
+import { LanguageModelV1FinishReason } from '@ai-sdk/provider';
+import { LanguageModelV1FunctionToolCall } from '@ai-sdk/provider';
+import { LanguageModelV1LogProbs } from '@ai-sdk/provider';
+import { LanguageModelV1ProviderMetadata } from '@ai-sdk/provider';
+import { LanguageModelV1Source } from '@ai-sdk/provider';
+import { LoopResult as LoopResult_2 } from './loop';
+import { MCPServer } from '@openai/agents';
+import { Model as Model_2 } from '@openai/agents';
+import { ModelRequest } from '@openai/agents';
+import type { OpenAIProvider } from '@ai-sdk/openai';
+import { ResponseStreamEvent } from '@openai/agents';
+import { Usage as Usage_2 } from '@openai/agents';
+import { z as _zod } from 'zod';
 
-declare type AgentType = 'code' | 'plan';
+/**
+ * Wraps a model from the AI SDK that adheres to the LanguageModelV1 spec to be used used as a model
+ * in the OpenAI Agents SDK to use other models.
+ *
+ * While you can use this with the OpenAI models, it is recommended to use the default OpenAI model
+ * provider instead.
+ *
+ * If tracing is enabled, the model will send generation spans to your traces processor.
+ *
+ * ```ts
+ * import { aisdk } from '@openai/agents-extensions';
+ * import { openai } from '@ai-sdk/openai';
+ *
+ * const model = aisdk(openai('gpt-4o'));
+ *
+ * const agent = new Agent({
+ *   name: 'My Agent',
+ *   model
+ * });
+ * ```
+ *
+ * @param model - The Vercel AI SDK model to wrap.
+ * @returns The wrapped model.
+ */
+declare class AiSdkModel implements Model_2 {
+    #private;
+    constructor(model: LanguageModelV1_2);
+    getResponse(request: ModelRequest): Promise<{
+        responseId: string;
+        usage: Usage_2;
+        output: AgentOutputItem[];
+        providerData: {
+            text?: string;
+            reasoning?: string | Array<{
+                type: "text";
+                text: string;
+                signature?: string;
+            } | {
+                type: "redacted";
+                data: string;
+            }>;
+            files?: Array<{
+                data: string | Uint8Array;
+                mimeType: string;
+            }>;
+            toolCalls?: Array<LanguageModelV1FunctionToolCall>;
+            finishReason: LanguageModelV1FinishReason;
+            usage: {
+                promptTokens: number;
+                completionTokens: number;
+            };
+            rawCall: {
+                rawPrompt: unknown;
+                rawSettings: Record<string, unknown>;
+            };
+            rawResponse?: {
+                headers?: Record<string, string>;
+                body?: unknown;
+            };
+            request?: {
+                body?: string;
+            };
+            response?: {
+                id?: string;
+                timestamp?: Date;
+                modelId?: string;
+            };
+            warnings?: LanguageModelV1CallWarning[];
+            providerMetadata?: LanguageModelV1ProviderMetadata;
+            sources?: LanguageModelV1Source[];
+            logprobs?: LanguageModelV1LogProbs;
+        };
+    }>;
+    getStreamedResponse(request: ModelRequest): AsyncIterable<ResponseStreamEvent>;
+}
+
+declare type ApprovalCategory = 'read' | 'write' | 'command' | 'network';
+
+declare type ApprovalContext = {
+    toolName: string;
+    params: Record<string, any>;
+    approvalMode: string;
+    context: any;
+};
 
 declare type ApprovalMode = 'default' | 'autoEdit' | 'yolo';
 
+declare type AssistantContent = string | Array<TextPart | ReasoningPart | ToolUsePart>;
+
+declare type AssistantMessage = {
+    role: 'assistant';
+    content: AssistantContent;
+    text: string;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
+    };
+};
+
+declare interface BaseSlashCommand {
+    name: string;
+    description: string;
+}
+
 declare type CommitConfig = {
     language: string;
 };
@@ -30,6 +150,21 @@ declare type Config = {
     outputFormat?: 'text' | 'stream-json' | 'json';
 };
 
+export declare class _ConfigManager {
+    globalConfig: Partial<Config>;
+    projectConfig: Partial<Config>;
+    argvConfig: Partial<Config>;
+    globalConfigPath: string;
+    projectConfigPath: string;
+    constructor(cwd: string, productName: string, argvConfig: Partial<Config>);
+    get config(): Config;
+    removeConfig(global: boolean, key: string, values?: string[]): void;
+    addConfig(global: boolean, key: string, values: string[]): void;
+    getConfig(global: boolean, key: string): any;
+    setConfig(global: boolean, key: string, value: string): void;
+    updateConfig(global: boolean, newConfig: Partial<Config>): void;
+}
+
 export declare class Context {
     #private;
     cwd: string;
@@ -38,6 +173,7 @@ export declare class Context {
     version: string;
     config: Config;
     paths: Paths;
+    mcpManager: MCPManager;
     constructor(opts: ContextOpts);
     apply(applyOpts: Omit<PluginApplyOpts, 'pluginContext'>): Promise<any>;
     destroy(): Promise<void>;
@@ -62,17 +198,95 @@ declare type ContextOpts = {
     pluginManager: PluginManager;
     paths: Paths;
     argvConfig: Record<string, any>;
+    mcpManager: MCPManager;
 };
 
+export declare function createTool<TSchema extends _zod.ZodTypeAny>(config: {
+    name: string;
+    description: string;
+    parameters: TSchema;
+    execute: (params: _zod.infer<TSchema>) => Promise<any> | any;
+    approval?: ToolApprovalInfo;
+}): Tool<_zod.infer<TSchema>>;
+
 declare type Enforce = 'pre' | 'post';
 
-declare type GeneralInfo = Record<string, string | {
-    enforce: Enforce;
-    text: string;
-}>;
+declare interface LocalCommand extends BaseSlashCommand {
+    type: 'local';
+    call(args: string, context: Context): Promise<string>;
+}
+
+declare interface LocalJSXCommand extends BaseSlashCommand {
+    type: 'local-jsx';
+    call(onDone: (result: string) => void, context: Context): Promise<React.ReactNode>;
+}
+
+declare type LoopResult = {
+    success: true;
+    data: Record<string, any>;
+    metadata: {
+        turnsCount: number;
+        toolCallsCount: number;
+        duration: number;
+    };
+} | {
+    success: false;
+    error: {
+        type: 'tool_denied' | 'max_turns_exceeded' | 'api_error' | 'canceled';
+        message: string;
+        details?: Record<string, any>;
+    };
+};
+
+declare interface MCPConfig {
+    type?: 'stdio' | 'sse' | 'http';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    disable?: boolean;
+    /**
+     * The timeout for tool calls in milliseconds.
+     */
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+
+declare class MCPManager {
+    #private;
+    private servers;
+    private configs;
+    private isInitialized;
+    private initPromise?;
+    private initLock;
+    static create(mcpServers: Record<string, MCPConfig>): MCPManager;
+    initAsync(): Promise<void>;
+    private _performInit;
+    private _connectServer;
+    getAllTools(): Promise<Tool[]>;
+    getTools(keys: string[]): Promise<Tool[]>;
+    destroy(): Promise<void>;
+    getServerNames(): string[];
+    hasServer(name: string): boolean;
+    getServerStatus(name: string): MCPServerStatus | undefined;
+    getServerError(name: string): string | undefined;
+    getAllServerStatus(): Promise<Record<string, {
+        status: MCPServerStatus;
+        error?: string;
+        toolCount: number;
+    }>>;
+    isReady(): boolean;
+    isLoading(): boolean;
+    retryConnection(serverName: string): Promise<void>;
+    getAllMcpTools(mcpServers: MCPServer[], convertSchemasToStrict?: boolean): Promise<Tool[]>;
+    getFunctionToolsFromServer<TContext = UnknownContext>(server: MCPServer, convertSchemasToStrict: boolean): Promise<FunctionTool<TContext, any, string>[]>;
+    private _isTemporaryError;
+}
 
 declare type McpServerConfig = McpStdioServerConfig | McpSSEServerConfig;
 
+declare type MCPServerStatus = 'pending' | 'connecting' | 'connected' | 'failed' | 'disconnected';
+
 declare type McpSSEServerConfig = {
     type: 'sse';
     url: string;
@@ -87,11 +301,12 @@ declare type McpStdioServerConfig = {
     disable?: boolean;
 };
 
-declare type MessageContent = TextContent | ToolUse;
+declare type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
 
 declare interface Model {
     id: string;
     name: string;
+    shortName?: string;
     attachment: boolean;
     reasoning: boolean;
     temperature: boolean;
@@ -105,6 +320,8 @@ declare interface Model {
     limit: ModelLimit;
 }
 
+declare type ModelAlias = Record<string, string>;
+
 declare interface ModelCost {
     input: number;
     output: number;
@@ -112,6 +329,12 @@ declare interface ModelCost {
     cache_write?: number;
 }
 
+declare type ModelInfo = {
+    provider: Provider;
+    model: Omit<Model, 'cost'>;
+    aisdk: AiSdkModel;
+};
+
 declare interface ModelLimit {
     context: number;
     output: number;
@@ -124,6 +347,29 @@ declare interface ModelModalities {
     output: ('text' | 'audio' | 'image')[];
 }
 
+declare type NormalizedMessage = Message & {
+    type: 'message';
+    timestamp: string;
+    uuid: string;
+    parentUuid: string | null;
+};
+
+declare class OutputStyle {
+    name: string;
+    description: string;
+    isCodingRelated: boolean;
+    prompt: string;
+    constructor(opts: OutputStyleOpts);
+    isDefault(): boolean;
+}
+
+declare type OutputStyleOpts = {
+    name: string;
+    description: string;
+    isCodingRelated: boolean;
+    prompt: string;
+};
+
 declare class Paths {
     globalConfigDir: string;
     globalProjectDir: string;
@@ -149,61 +395,70 @@ declare type Plugin_2 = {
     config?: (this: TempPluginContext, opts: {
         config: Config;
         argvConfig: Record<string, any>;
-    }) => any | Promise<any>;
-    configResolved?: (this: TempPluginContext, opts: {
-        resolvedConfig: any;
-    }) => Promise<any> | any;
-    generalInfo?: (this: TempPluginContext) => GeneralInfo | Promise<GeneralInfo>;
-    cliStart?: (this: PluginContext) => Promise<any> | any;
-    cliEnd?: (this: PluginContext, opts: {
-        startTime: number;
-        endTime: number;
-        error?: any;
-    }) => Promise<any> | any;
-    contextStart?: (this: PluginContext, opts: {
-        prompt: string;
-    }) => Promise<any> | any;
+    }) => Partial<Config> | Promise<Partial<Config>>;
+    slashCommand?: (this: PluginContext) => Promise<SlashCommand[]> | SlashCommand[];
+    outputStyle?: (this: PluginContext) => Promise<OutputStyle[]> | OutputStyle[];
+    provider?: (this: PluginContext, providers: ProvidersMap, opts: {
+        models: ModelMap;
+        defaultModelCreator: (name: string, provider: Provider) => LanguageModelV1;
+        createOpenAI: (options: any) => OpenAIProvider;
+    }) => Promise<ProvidersMap> | ProvidersMap;
+    modelAlias?: (this: PluginContext, modelAlias: ModelAlias) => Promise<ModelAlias> | ModelAlias;
+    initialized?: (this: PluginContext, opts: {
+        cwd: string;
+        quiet: boolean;
+    }) => Promise<void> | void;
     context?: (this: PluginContext, opts: {
-        prompt: string;
-    }) => Promise<any> | any;
-    userPrompt?: (this: PluginContext, opts: {
-        text: string;
+        userPrompt: string | null;
+        sessionId: string;
+    }) => Promise<Record<string, string> | {}> | Record<string, string> | {};
+    env?: (this: PluginContext, opts: {
+        userPrompt: string | null;
+        sessionId: string;
+    }) => Promise<Record<string, string> | {}> | Record<string, string> | {};
+    userPrompt?: (this: PluginContext, userPrompt: string, opts: {
+        sessionId: string;
+    }) => Promise<string> | string;
+    systemPrompt?: (this: PluginContext, systemPrompt: string, opts: {
+        isPlan?: boolean;
         sessionId: string;
-    }) => Promise<any> | any;
-    systemPrompt?: (this: PluginContext, memo: string[], opts: {
-        prompt: string | undefined;
     }) => Promise<string> | string;
-    text?: (this: PluginContext, opts: {
-        text: string;
+    tool?: (this: PluginContext, opts: {
+        isPlan?: boolean;
+        sessionId: string;
+    }) => Promise<Tool[]> | Tool[];
+    toolUse?: (this: PluginContext, toolUse: ToolUse, opts: {
+        sessionId: string;
+    }) => Promise<ToolUse> | ToolUse;
+    toolResult?: (this: PluginContext, toolResult: any, opts: {
+        toolUse: ToolUse;
+        approved: boolean;
         sessionId: string;
     }) => Promise<any> | any;
     query?: (this: PluginContext, opts: {
-        text: string;
-        parsed: MessageContent[];
-        input: AgentInputItem[];
-        model: string;
-        usage: any;
+        usage: Usage;
+        startTime: Date;
+        endTime: Date;
         sessionId: string;
-    }) => Promise<any> | any;
+    }) => Promise<void> | void;
     conversation?: (this: PluginContext, opts: {
-        prompt: string;
-        finalText: string;
-        history: AgentInputItem[];
-        startTime: number;
-        endTime: number;
-    }) => Promise<any> | any;
-    destroy?: (this: PluginContext) => Promise<any> | any;
-    env?: (this: PluginContext) => Record<string, string>;
-    serverAppData?: (this: PluginContext, opts: {
+        userPrompt: string | null;
+        result: LoopResult;
+        startTime: Date;
+        endTime: Date;
+        sessionId: string;
+    }) => Promise<void> | void;
+    status?: (this: PluginContext) => Promise<Status> | Status;
+    _serverAppData?: (this: PluginContext, opts: {
         context: any;
         cwd: string;
     }) => Promise<any> | any;
-    serverRoutes?: (this: PluginContext, opts: {
+    _serverRoutes?: (this: PluginContext, opts: {
         app: any;
         prefix: string;
         opts: any;
     }) => Promise<any> | any;
-    serverRouteCompletions?: (this: PluginContext, opts: {
+    _serverRouteCompletions?: (this: PluginContext, opts: {
         message: {
             role: 'user';
             content: string;
@@ -212,28 +467,6 @@ declare type Plugin_2 = {
         };
         attachedContexts: any[];
     }) => Promise<any> | any;
-    command?: (this: PluginContext) => Promise<any[]> | any[];
-    outputStyle?: (this: PluginContext) => Promise<any> | any;
-    argvConfig?: (this: PluginContext) => Promise<any> | any;
-    status?: (this: PluginContext) => Promise<Status> | Status;
-    tool?: (this: PluginContext, opts: {
-        agentType: AgentType;
-    }) => Promise<any>;
-    toolUse?: (this: PluginContext, opts: {
-        toolUse: any;
-        sessionId: string;
-    }) => Promise<any> | any;
-    toolUseResult?: (this: PluginContext, opts: {
-        toolUse: any;
-        result: any;
-        sessionId: string;
-    }) => Promise<any> | any;
-    provider?: (this: PluginContext, opts: {
-        models: ModelMap;
-        defaultModelCreator: any;
-        createOpenAI: any;
-    }) => Promise<any> | any;
-    modelAlias?: (this: PluginContext) => Promise<any> | any;
 };
 export { Plugin_2 as Plugin }
 
@@ -261,6 +494,43 @@ declare class PluginManager {
     apply({ hook, args, memo, type, pluginContext, }: PluginApplyOpts): Promise<any>;
 }
 
+declare interface PromptCommand extends BaseSlashCommand {
+    type: 'prompt';
+    argNames?: string[];
+    progressMessage: string;
+    model?: string;
+    getPromptForCommand(args: string): Promise<Array<{
+        role: string;
+        content: string;
+    }>>;
+}
+
+declare interface Provider {
+    id: string;
+    env: string[];
+    name: string;
+    api?: string;
+    doc: string;
+    models: Record<string, Omit<Model, 'id' | 'cost'>>;
+    createModel(name: string, provider: Provider): LanguageModelV1;
+}
+
+declare type ProvidersMap = Record<string, Provider>;
+
+export declare function _query(opts: {
+    userPrompt: string;
+    messages?: NormalizedMessage[];
+    context?: Context;
+    model?: ModelInfo;
+    systemPrompt?: string;
+    onMessage?: (message: NormalizedMessage) => Promise<void>;
+}): Promise<LoopResult_2>;
+
+declare type ReasoningPart = {
+    type: 'reasoning';
+    text: string;
+};
+
 export declare function runNeovate(opts: {
     productName: string;
     productASCIIArt?: string;
@@ -269,30 +539,72 @@ export declare function runNeovate(opts: {
     upgrade?: UpgradeOptions;
 }): Promise<void>;
 
+declare type SlashCommand = LocalCommand | LocalJSXCommand | PromptCommand;
+
 declare type Status = Record<string, {
     description?: string;
     items: string[];
 }>;
 
+declare type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+
 declare type TempPluginContext = ContextCreateOpts & {
     pluginManager: PluginManager;
     config: Config;
     apply: (opts: PluginApplyOpts) => Promise<any> | any;
 };
 
-declare interface TextContent {
+declare type TextPart = {
     type: 'text';
-    content: string;
-    partial: boolean;
+    text: string;
+};
+
+declare interface Tool<T = any> {
+    name: string;
+    description: string;
+    execute: (params: T) => Promise<any> | any;
+    approval?: ToolApprovalInfo;
+    parameters: _zod.ZodSchema<T>;
 }
 
-declare interface ToolUse {
+declare type ToolApprovalInfo = {
+    needsApproval?: (context: ApprovalContext) => Promise<boolean> | boolean;
+    category?: ApprovalCategory;
+};
+
+declare type ToolContent = Array<ToolResultPart>;
+
+declare type ToolMessage = {
+    role: 'user';
+    content: ToolContent;
+};
+
+declare type ToolResultPart = {
+    type: 'tool_result';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+    result: any;
+    isError?: boolean;
+};
+
+declare type ToolUse = {
+    name: string;
+    params: Record<string, any>;
+    callId: string;
+};
+
+declare type ToolUsePart = {
     type: 'tool_use';
+    id: string;
     name: string;
-    params: Partial<Record<string, string>>;
-    callId?: string;
-    partial: boolean;
-}
+    input: Record<string, any>;
+};
+
+declare type UnknownContext = unknown;
 
 declare type UpgradeOptions = {
     registryBase: string;
@@ -304,4 +616,27 @@ declare type UpgradeOptions = {
     changelogUrl?: string;
 };
 
+declare class Usage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    constructor(init?: Partial<Usage>);
+    static empty(): Usage;
+    static fromEventUsage(eventUsage: any): Usage;
+    add(other: Usage): void;
+    reset(): void;
+    clone(): Usage;
+    isValid(): boolean;
+}
+
+declare type UserContent = string | Array<TextPart>;
+
+declare type UserMessage = {
+    role: 'user';
+    content: UserContent;
+    hidden?: boolean;
+};
+
+export { _zod }
+
 export { }