@nuvin/agent-core 0.0.0-rc.18 → 0.0.0-rc.19

package/dist/hooks/registry.d.ts

@@ -0,0 +1,8 @@
+import type { HooksConfig } from "@nuvin/config";
+import type { HookEventName, ResolvedHook } from "./types.ts";
+export interface HookRegistry {
+    getHooks(event: HookEventName, toolName?: string): ResolvedHook[];
+    hasHooks(event: HookEventName): boolean;
+}
+export declare function createHookRegistry(config: HooksConfig): HookRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/hooks/types.d.ts

@@ -0,0 +1,40 @@
+export type { CommandHookConfig, HookMatcherGroup, HooksConfig } from "@nuvin/config";
+export type HookEventName = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "Notification" | "SessionStart" | "SessionEnd";
+export interface ResolvedHook {
+    command: string;
+    timeout: number;
+}
+/** JSON payload written to hook's stdin. */
+export interface HookInput {
+    session_id?: string;
+    [key: string]: unknown;
+}
+/** JSON output parsed from hook's stdout. */
+export interface HookOutput {
+    /** Approve or block the action. PreToolUse only. */
+    decision?: "approve" | "block";
+    /** Reason for block. PreToolUse only. */
+    reason?: string;
+    /**
+     * Event-specific outputs. For PreToolUse, this carries `permissionDecision`
+     * (Claude Code compat). For all events, this carries `additionalContext`.
+     */
+    hookSpecificOutput?: {
+        /** Echoed event name — not required to parse, but useful for debugging. */
+        hookEventName?: string;
+        /** Auto-approve/deny/ask the permission. PreToolUse only. */
+        permissionDecision?: "allow" | "deny" | "ask";
+        /** Reason for the permission decision. */
+        permissionDecisionReason?: string;
+        /** Inject additional context into the prompt/system. */
+        additionalContext?: string;
+    };
+}
+/** Internal result from executing a hook command. */
+export interface HookResult {
+    status: "pass" | "block" | "error";
+    output?: HookOutput;
+    error?: string;
+    duration_ms: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lsp/client.d.ts

@@ -0,0 +1,11 @@
+import type { Location } from "vscode-languageserver-types";
+import type { LspClientInfo, LspServerHandle, LspServerInfo } from "./types.ts";
+type LocationResponse = Location | Location[] | null | undefined;
+export declare function normalizeLocations(value: LocationResponse): Location[];
+export declare function createLspClient(input: {
+    server: LspServerInfo;
+    root: string;
+    handle: LspServerHandle;
+}): Promise<LspClientInfo>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/lsp/index.d.ts

@@ -0,0 +1,24 @@
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Diagnostic, DocumentSymbol, Hover, Location, LspPosition, LspServiceConfig, SymbolInformation } from "./types.ts";
+export type { LspServiceConfig } from "./types.ts";
+export interface LspService {
+    isEnabled(): boolean;
+    hasClients(file: string): Promise<boolean>;
+    touchFile(filePath: string, waitDiagnostics?: boolean): Promise<void>;
+    diagnostics(): Promise<Record<string, Diagnostic[]>>;
+    diagnosticsForFile(filePath: string): Promise<Diagnostic[]>;
+    definition(pos: LspPosition): Promise<Location[]>;
+    references(pos: LspPosition): Promise<Location[]>;
+    hover(pos: LspPosition): Promise<Hover[]>;
+    documentSymbol(filePath: string): Promise<(DocumentSymbol | SymbolInformation)[]>;
+    workspaceSymbol(query: string): Promise<SymbolInformation[]>;
+    implementation(pos: LspPosition): Promise<Location[]>;
+    prepareCallHierarchy(pos: LspPosition): Promise<CallHierarchyItem[]>;
+    incomingCalls(pos: LspPosition): Promise<CallHierarchyIncomingCall[]>;
+    outgoingCalls(pos: LspPosition): Promise<CallHierarchyOutgoingCall[]>;
+    shutdown(): Promise<void>;
+    status(): {
+        connectedClients: number;
+    };
+}
+export declare function createLspService(config?: LspServiceConfig): LspService;
+//# sourceMappingURL=index.d.ts.map

package/dist/lsp/installer.d.ts

@@ -0,0 +1,11 @@
+export declare function shouldDisableLspDownload(env?: NodeJS.ProcessEnv): boolean;
+export declare function getLspPackageDir(packageName: string): string;
+export declare function getLspBinDir(packageName: string): string;
+export declare function findPackageBinary(binaryName: string, startDir: string): Promise<string | undefined>;
+export declare function resolvePackageBinary(input: {
+    packageName: string;
+    binaryName?: string;
+    startDir: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<string | undefined>;
+//# sourceMappingURL=installer.d.ts.map

package/dist/lsp/language.d.ts

@@ -0,0 +1,2 @@
+export declare function getLanguageId(filePath: string): string | undefined;
+//# sourceMappingURL=language.d.ts.map

package/dist/lsp/server.d.ts

@@ -0,0 +1,6 @@
+import type { LspServerInfo } from "./types.ts";
+export declare const TypeScriptServer: LspServerInfo;
+export declare const BiomeServer: LspServerInfo;
+export declare const BUILTIN_LSP_SERVERS: readonly LspServerInfo[];
+export declare function getServersForFile(file: string): LspServerInfo[];
+//# sourceMappingURL=server.d.ts.map

package/dist/lsp/types.d.ts

@@ -0,0 +1,68 @@
+import type { ChildProcess } from "node:child_process";
+import type { MessageConnection } from "vscode-jsonrpc";
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Diagnostic, DocumentSymbol, Hover, Location, SymbolInformation } from "vscode-languageserver-types";
+export type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Diagnostic, DocumentSymbol, Hover, Location, SymbolInformation, };
+export interface LspPosition {
+    file: string;
+    line: number;
+    character: number;
+}
+export interface LspServerInfo {
+    id: string;
+    name: string;
+    extensions: string[];
+    root(file: string): Promise<string | undefined>;
+    spawn(root: string): Promise<LspServerHandle | undefined>;
+}
+export interface LspServerHandle {
+    process: ChildProcess;
+    initialization?: Record<string, unknown>;
+}
+export interface LspServerCapabilities {
+    definitionProvider?: boolean;
+    referencesProvider?: boolean;
+    hoverProvider?: boolean;
+    documentSymbolProvider?: boolean;
+    workspaceSymbolProvider?: boolean;
+    implementationProvider?: boolean;
+    callHierarchyProvider?: boolean;
+}
+export interface LspClientInfo {
+    serverId: string;
+    root: string;
+    connection: MessageConnection;
+    diagnostics: Map<string, Diagnostic[]>;
+    capabilities: LspServerCapabilities;
+    notify: {
+        open(input: {
+            path: string;
+        }): Promise<void>;
+        change(input: {
+            path: string;
+            version: number;
+        }): Promise<void>;
+        close(input: {
+            path: string;
+        }): Promise<void>;
+    };
+    request: {
+        definition(pos: LspPosition): Promise<Location[]>;
+        references(pos: LspPosition): Promise<Location[]>;
+        hover(pos: LspPosition): Promise<Hover | null>;
+        documentSymbol(filePath: string): Promise<(DocumentSymbol | SymbolInformation)[]>;
+        workspaceSymbol(query: string): Promise<SymbolInformation[]>;
+        implementation(pos: LspPosition): Promise<Location[]>;
+        prepareCallHierarchy(pos: LspPosition): Promise<CallHierarchyItem[]>;
+        incomingCalls(item: CallHierarchyItem): Promise<CallHierarchyIncomingCall[]>;
+        outgoingCalls(item: CallHierarchyItem): Promise<CallHierarchyOutgoingCall[]>;
+    };
+    waitForDiagnostics(input: {
+        path: string;
+        timeoutMs?: number;
+    }): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export interface LspServiceConfig {
+    enabled?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/models/anthropic-model.d.ts

@@ -0,0 +1,27 @@
+import type { BaseChatModelOptions, ChatRequest, ChatResponse, ChatResponseChunk, ModelExecutionOptions, ProviderCredential } from "../shared/types.ts";
+import type { ProviderRequestMutator, ProviderSessionResolver, ResolvedProviderSession } from "./provider-session.ts";
+import { RoutedModel } from "./routed-model.ts";
+export interface AnthropicModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    baseUrl?: string;
+    protocolVersion?: string;
+    authScheme?: "bearer" | "x-api-key";
+    fetch?: typeof globalThis.fetch;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    headerResolver?: AnthropicHeaderResolver;
+}
+export interface AnthropicRequestHeadersContext {
+    request?: ChatRequest;
+    body: unknown;
+    credential: ProviderCredential;
+    session?: ResolvedProviderSession;
+    stream: boolean;
+}
+export type AnthropicHeaderResolver = (context: AnthropicRequestHeadersContext) => Promise<Record<string, string>> | Record<string, string>;
+export declare class AnthropicModel extends RoutedModel {
+    constructor(options?: AnthropicModelOptions);
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+}
+//# sourceMappingURL=anthropic-model.d.ts.map

package/dist/models/anthropic-surface.d.ts

@@ -0,0 +1,5 @@
+import type { RoutedModelSurface } from "./routed-model.ts";
+export declare const ANTHROPIC_MESSAGES_SURFACE = "anthropic-messages";
+export declare const ANTHROPIC_MESSAGES_STREAM_SURFACE = "anthropic-messages-stream";
+export declare function createAnthropicSurfaces(): RoutedModelSurface[];
+//# sourceMappingURL=anthropic-surface.d.ts.map

package/dist/models/chat-model.d.ts

@@ -0,0 +1,31 @@
+import type { BaseChatModelOptions, ChatRequest, ChatResponse, ChatResponseChunk, EngineChatModel, ModelExecutionOptions } from "../shared/types.ts";
+import type { AnthropicModelOptions } from "./anthropic-model.ts";
+import type { OpenAiHeaderResolver, WebSocketFactory } from "./openai-model.ts";
+import type { ProviderRequestMutator, ProviderSessionResolver } from "./provider-session.ts";
+export declare const AVAILABLE_CHAT_MODEL_SURFACES: readonly ["anthropic-messages", "openai-chat-completions", "openai-responses", "openai-responses-ws"];
+export type ChatModelSurface = (typeof AVAILABLE_CHAT_MODEL_SURFACES)[number];
+export type ChatModelAuthScheme = NonNullable<AnthropicModelOptions["authScheme"]>;
+export interface ChatModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    baseUrl?: string;
+    surface?: ChatModelSurface;
+    authScheme?: ChatModelAuthScheme;
+    fetch?: typeof globalThis.fetch;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    headerResolver?: OpenAiHeaderResolver;
+    webSocketFactory?: WebSocketFactory;
+}
+export declare class ChatModel implements EngineChatModel {
+    readonly model: string;
+    readonly maxTokens: number;
+    readonly surface: ChatModelSurface;
+    private readonly anthropicDelegate?;
+    private readonly openAiDelegate?;
+    constructor(options?: ChatModelOptions);
+    private getAnthropicDelegate;
+    private getOpenAiDelegate;
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+}
+//# sourceMappingURL=chat-model.d.ts.map

package/dist/models/github-model.d.ts

@@ -0,0 +1,32 @@
+import type { BaseChatModelOptions, ChatRequest, ChatResponse, ChatResponseChunk, ModelExecutionOptions, ModelInfo, ProviderSessionResolver } from "../shared/types.ts";
+import { OpenAiModel } from "./openai-model.ts";
+export type GitHubModelSurface = "auto" | "anthropic-messages" | "openai-chat-completions" | "openai-responses" | "openai-responses-ws";
+export interface GitHubModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    accessToken?: string;
+    baseUrl?: string;
+    surface?: GitHubModelSurface;
+    githubApiUrl?: string;
+    fetch?: typeof globalThis.fetch;
+    editorVersion?: string;
+    editorPluginVersion?: string;
+    tokenExchangeApiVersion?: string;
+    providerSessionResolver?: ProviderSessionResolver;
+}
+export declare class GitHubModel extends OpenAiModel {
+    private readonly anthropicDelegate;
+    private readonly modelEndpointCache;
+    private readonly surface;
+    constructor(options?: GitHubModelOptions);
+    protected createMissingCredentialError(): Error;
+    private usesResponsesApi;
+    private shouldPreferResponsesApi;
+    private markModelAsResponsesOnly;
+    protected mapApiError(error: Error): Error;
+    private completeViaConfiguredSurface;
+    private streamViaConfiguredSurface;
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    getModels(signal?: AbortSignal): Promise<ModelInfo[]>;
+}
+//# sourceMappingURL=github-model.d.ts.map

package/dist/models/http-transport.d.ts

@@ -0,0 +1,10 @@
+export interface FetchJsonOptions {
+    url: string;
+    body: unknown;
+    headers: Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+    signal?: AbortSignal;
+}
+export declare function fetchRawResponse(options: FetchJsonOptions): Promise<Response>;
+export declare function fetchJsonResponse<T>(options: FetchJsonOptions): Promise<T>;
+//# sourceMappingURL=http-transport.d.ts.map