@neovate/code 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -1,98 +1,9 @@
-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 EventEmitter from 'events';
+import { LanguageModelV2 } from '@openrouter/ai-sdk-provider';
 import type { OpenAIProvider } from '@ai-sdk/openai';
-import { ResponseStreamEvent } from '@openai/agents';
-import { Usage as Usage_2 } from '@openai/agents';
+import * as z from 'zod';
 import { z as _zod } from 'zod';
 
-/**
- * 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 = {
@@ -119,6 +30,34 @@ declare type AssistantMessage = {
     };
 };
 
+declare interface BackgroundTask {
+    id: string;
+    command: string;
+    pid: number;
+    pgid?: number;
+    status: 'running' | 'completed' | 'killed' | 'failed';
+    createdAt: number;
+    output: string;
+    exitCode: number | null;
+}
+
+declare class BackgroundTaskManager {
+    private tasks;
+    createTask(input: CreateTaskInput): string;
+    getTask(id: string): BackgroundTask | null;
+    getAllTasks(): BackgroundTask[];
+    appendOutput(id: string, output: string): void;
+    updateTaskStatus(id: string, status: BackgroundTask['status'], exitCode?: number | null): void;
+    deleteTask(id: string): void;
+    private isProcessAlive;
+    killTask(id: string): Promise<boolean>;
+}
+
+declare type BaseMessage = {
+    id: MessageId;
+    timestamp: number;
+};
+
 declare interface BaseSlashCommand {
     name: string;
     description: string;
@@ -127,11 +66,13 @@ declare interface BaseSlashCommand {
 
 declare type CommitConfig = {
     language: string;
+    systemPrompt?: string;
 };
 
 declare type Config = {
     model: string;
     planModel: string;
+    smallModel?: string;
     language: string;
     quiet: boolean;
     approvalMode: ApprovalMode;
@@ -179,6 +120,8 @@ export declare class Context {
     paths: Paths;
     argvConfig: Record<string, any>;
     mcpManager: MCPManager;
+    backgroundTaskManager: BackgroundTaskManager;
+    messageBus?: MessageBus;
     constructor(opts: ContextOpts);
     apply(applyOpts: Omit<PluginApplyOpts, 'pluginContext'>): Promise<any>;
     destroy(): Promise<void>;
@@ -192,6 +135,7 @@ declare type ContextCreateOpts = {
     version: string;
     argvConfig: Record<string, any>;
     plugins: (string | Plugin_2)[];
+    messageBus?: MessageBus;
 };
 
 declare type ContextOpts = {
@@ -204,19 +148,27 @@ declare type ContextOpts = {
     paths: Paths;
     argvConfig: Record<string, any>;
     mcpManager: MCPManager;
+    backgroundTaskManager: BackgroundTaskManager;
+    messageBus?: MessageBus;
 };
 
-export declare function createTool<TSchema extends _zod.ZodTypeAny>(config: {
+declare interface CreateTaskInput {
+    command: string;
+    pid: number;
+    pgid?: number;
+}
+
+export declare function createTool<TSchema extends z.ZodTypeAny>(config: {
     name: string;
     description: string;
     parameters: TSchema;
-    execute: (params: _zod.infer<TSchema>) => Promise<ToolResult> | ToolResult;
+    execute: (params: z.output<TSchema>) => Promise<ToolResult> | ToolResult;
     approval?: ToolApprovalInfo;
     getDescription?: ({ params, cwd, }: {
-        params: _zod.infer<TSchema>;
+        params: z.output<TSchema>;
         cwd: string;
     }) => string;
-}): Tool<_zod.infer<TSchema>>;
+}): Tool<TSchema>;
 
 declare type DiffViewerReturnDisplay = {
     type: 'diff_viewer';
@@ -232,6 +184,14 @@ declare type DiffViewerReturnDisplay = {
 
 declare type Enforce = 'pre' | 'post';
 
+declare type EventHandler = (data: any) => void;
+
+declare type EventMessage = BaseMessage & {
+    type: 'event';
+    event: string;
+    data: any;
+};
+
 declare type ImagePart = {
     type: 'image';
     data: string;
@@ -312,8 +272,8 @@ declare class MCPManager {
     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 _createClient;
+    private _testConnectionAndFetchTools;
     private _isTemporaryError;
 }
 
@@ -336,7 +296,45 @@ declare type McpStdioServerConfig = {
     disable?: boolean;
 };
 
-declare type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+declare type Message = RequestMessage | ResponseMessage | EventMessage;
+
+declare type Message_2 = SystemMessage | UserMessage | AssistantMessage | ToolMessage | ToolMessage2;
+
+declare class MessageBus extends EventEmitter {
+    private transport?;
+    private pendingRequests;
+    private messageHandlers;
+    private eventHandlers;
+    constructor();
+    setTransport(transport: MessageTransport): void;
+    isConnected(): boolean;
+    request(method: string, params: any, options?: {
+        timeout?: number;
+    }): Promise<any>;
+    registerHandler(method: string, handler: MessageHandler): void;
+    unregisterHandler(method: string): void;
+    emitEvent(event: string, data: any): Promise<void>;
+    onEvent(event: string, handler: EventHandler): void;
+    offEvent(event: string, handler: EventHandler): void;
+    private handleIncomingMessage;
+    private handleRequest;
+    private handleResponse;
+    private handleEvent;
+    private sendResponse;
+}
+
+declare type MessageHandler = (data: any) => Promise<any>;
+
+declare type MessageId = string;
+
+declare interface MessageTransport {
+    send: (message: Message) => Promise<void>;
+    onMessage: (handler: (message: Message) => void) => void;
+    onError: (handler: (error: Error) => void) => void;
+    onClose: (handler: () => void) => void;
+    close: () => Promise<void>;
+    isConnected: () => boolean;
+}
 
 declare interface Model {
     id: string;
@@ -367,7 +365,8 @@ declare interface ModelCost {
 declare type ModelInfo = {
     provider: Provider;
     model: Omit<Model, 'cost'>;
-    aisdk: AiSdkModel;
+    m: LanguageModelV2;
+    thinkingConfig?: Record<string, any>;
 };
 
 declare interface ModelLimit {
@@ -382,7 +381,7 @@ declare interface ModelModalities {
     output: ('text' | 'audio' | 'image')[];
 }
 
-declare type NormalizedMessage = Message & {
+declare type NormalizedMessage = Message_2 & {
     type: 'message';
     timestamp: string;
     uuid: string;
@@ -437,7 +436,7 @@ declare type Plugin_2 = {
     outputStyle?: (this: PluginContext) => Promise<OutputStyle[]> | OutputStyle[];
     provider?: (this: PluginContext, providers: ProvidersMap, opts: {
         models: ModelMap;
-        defaultModelCreator: (name: string, provider: Provider) => LanguageModelV1;
+        defaultModelCreator: (name: string, provider: Provider) => LanguageModelV2;
         createOpenAI: (options: any) => OpenAIProvider;
     }) => Promise<ProvidersMap> | ProvidersMap;
     modelAlias?: (this: PluginContext, modelAlias: ModelAlias) => Promise<ModelAlias> | ModelAlias;
@@ -554,7 +553,7 @@ declare interface Provider {
     api?: string;
     doc: string;
     models: Record<string, string | Omit<Model, 'id' | 'cost'>>;
-    createModel(name: string, provider: Provider, globalConfigDir: string): Promise<LanguageModelV1> | LanguageModelV1;
+    createModel(name: string, provider: Provider, globalConfigDir: string): Promise<LanguageModelV2> | LanguageModelV2;
     options?: {
         baseURL?: string;
         apiKey?: string;
@@ -573,13 +572,27 @@ export declare function _query(opts: {
     model?: ModelInfo;
     systemPrompt?: string;
     onMessage?: (message: NormalizedMessage) => Promise<void>;
-}): Promise<LoopResult_2>;
+}): Promise<LoopResult>;
 
 declare type ReasoningPart = {
     type: 'reasoning';
     text: string;
 };
 
+declare type RequestMessage = BaseMessage & {
+    type: 'request';
+    method: string;
+    params: any;
+};
+
+declare type ResponseMessage = BaseMessage & {
+    type: 'response';
+    result?: any;
+    error?: any;
+};
+
+declare type ReturnDisplay = string | DiffViewerReturnDisplay | TodoReadReturnDisplay | TodoWriteReturnDisplay;
+
 export declare function runNeovate(opts: {
     productName: string;
     productASCIIArt?: string;
@@ -616,19 +629,17 @@ declare type TodoItem = _zod.infer<typeof TodoItemSchema>;
 declare const TodoItemSchema: _zod.ZodObject<{
     id: _zod.ZodString;
     content: _zod.ZodString;
-    status: _zod.ZodEnum<["pending", "in_progress", "completed"]>;
-    priority: _zod.ZodEnum<["low", "medium", "high"]>;
-}, "strip", _zod.ZodTypeAny, {
-    status: "in_progress" | "completed" | "pending";
-    id: string;
-    content: string;
-    priority: "low" | "medium" | "high";
-}, {
-    status: "in_progress" | "completed" | "pending";
-    id: string;
-    content: string;
-    priority: "low" | "medium" | "high";
-}>;
+    status: _zod.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+    }>;
+    priority: _zod.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+}, _zod.core.$strip>;
 
 declare type TodoReadReturnDisplay = {
     type: 'todo_read';
@@ -641,17 +652,17 @@ declare type TodoWriteReturnDisplay = {
     newTodos: TodoItem[];
 };
 
-declare interface Tool<T = any> {
+declare interface Tool<TSchema extends z.ZodTypeAny = z.ZodTypeAny> {
     name: string;
     description: string;
-    getDescription?: ({ params, cwd }: {
-        params: T;
+    getDescription?: ({ params, cwd, }: {
+        params: z.output<TSchema>;
         cwd: string;
     }) => string;
     displayName?: string;
-    execute: (params: T) => Promise<ToolResult> | ToolResult;
+    execute: (params: z.output<TSchema>) => Promise<ToolResult> | ToolResult;
     approval?: ToolApprovalInfo;
-    parameters: _zod.ZodSchema<T>;
+    parameters: TSchema;
 }
 
 declare type ToolApprovalInfo = {
@@ -666,9 +677,14 @@ declare type ToolMessage = {
     content: ToolContent;
 };
 
+declare type ToolMessage2 = {
+    role: 'tool';
+    content: ToolResultPart2[];
+};
+
 declare type ToolResult = {
     llmContent: string | (TextPart | ImagePart)[];
-    returnDisplay?: string | DiffViewerReturnDisplay | TodoReadReturnDisplay | TodoWriteReturnDisplay;
+    returnDisplay?: ReturnDisplay;
     isError?: boolean;
 };
 
@@ -680,6 +696,14 @@ declare type ToolResultPart = {
     result: ToolResult;
 };
 
+declare type ToolResultPart2 = {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    input: Record<string, any>;
+    result: ToolResult;
+};
+
 declare type ToolUse = {
     name: string;
     params: Record<string, any>;
@@ -695,8 +719,6 @@ declare type ToolUsePart = {
     description?: string;
 };
 
-declare type UnknownContext = unknown;
-
 declare type UpgradeOptions = {
     registryBase: string;
     name: string;