agent-sh 0.13.6 → 0.14.0

package/dist/agent/events.d.ts

@@ -0,0 +1,218 @@
+import type { ProviderRegistration } from "./host-types.js";
+import type { ToolDefinition, ToolResultDisplay } from "./types.js";
+export interface AgentIdentity {
+    name: string;
+    version: string;
+    model?: string;
+    provider?: string;
+    contextWindow?: number;
+}
+declare module "../core/event-bus.js" {
+    interface BusEvents {
+        "agent:providers": {
+            providers: ProviderRegistration[];
+        };
+        "agent:providers:changed": Record<string, never>;
+        "provider:configure": {
+            id: string;
+            reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
+        };
+        "agent:modes-changed": Record<string, never>;
+        "config:switch-provider": {
+            provider: string;
+        };
+        "agent:info": AgentIdentity;
+        "agent:tools": {
+            tools: ToolDefinition[];
+        };
+        "agent:instructions": {
+            instructions: Array<{
+                name: string;
+                text: string;
+            }>;
+        };
+        "agent:skills": {
+            skills: Array<{
+                name: string;
+                description: string;
+                filePath: string;
+            }>;
+        };
+        "agent:submit": {
+            query: string;
+        };
+        "agent:cancel-request": {
+            silent?: boolean;
+        };
+        "agent:append-user-message": {
+            text: string;
+        };
+        "agent:query": {
+            query: string;
+        };
+        "agent:reset-session": Record<string, never>;
+        "agent:compact-request": Record<string, never>;
+        "agent:thinking-chunk": {
+            text: string;
+        };
+        "agent:response-chunk": {
+            blocks: ContentBlock[];
+        };
+        "agent:response-done": {
+            response: string;
+        };
+        "agent:usage": {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        };
+        "agent:processing-start": Record<string, never>;
+        "agent:processing-done": Record<string, never>;
+        "agent:cancelled": Record<string, never>;
+        "agent:error": {
+            message: string;
+        };
+        "agent:tool-call": {
+            tool: string;
+            args: Record<string, unknown>;
+        };
+        "agent:tool-output": {
+            tool: string;
+            output: string;
+            exitCode: number | null;
+        };
+        "agent:tool-batch": {
+            groups: Array<{
+                kind: string;
+                tools: Array<{
+                    name: string;
+                    displayDetail?: string;
+                }>;
+            }>;
+        };
+        "agent:tool-batch-complete": {
+            results: Array<{
+                name: string;
+                isError: boolean;
+                errorSummary?: string;
+            }>;
+        };
+        "agent:tool-started": {
+            title: string;
+            toolCallId?: string;
+            kind?: string;
+            icon?: string;
+            locations?: {
+                path: string;
+                line?: number | null;
+            }[];
+            rawInput?: unknown;
+            displayDetail?: string;
+            /** highlight.js identifier for rawInput.source. */
+            sourceLanguage?: string;
+            batchIndex?: number;
+            batchTotal?: number;
+        };
+        "agent:tool-completed": {
+            toolCallId?: string;
+            exitCode: number | null;
+            rawOutput?: unknown;
+            kind?: string;
+            resultDisplay?: ToolResultDisplay;
+        };
+        "agent:tool-output-chunk": {
+            chunk: string;
+        };
+        "tool:interactive-start": Record<string, never>;
+        "tool:interactive-end": Record<string, never>;
+        "agent:subagent-started": {
+            taskId: string;
+            task: string;
+        };
+        "agent:subagent-completed": {
+            taskId: string;
+            task: string;
+            result: string;
+            isError: boolean;
+        };
+        "agent:terminal-intercept": {
+            command: string;
+            cwd: string;
+            intercepted: boolean;
+            output: string;
+        };
+        "conversation:message-appended": {
+            role: "user" | "assistant" | "tool" | "system";
+            content: string;
+            toolName?: string;
+            toolArgs?: Record<string, unknown>;
+            isError?: boolean;
+        };
+        "conversation:after-compact": {
+            beforeTokens: number;
+            afterTokens: number;
+            evictedCount: number;
+        };
+        "context:get-stats": {
+            activeTokens: number;
+            totalTokens: number;
+            budgetTokens: number;
+        };
+        "context:snapshot": {
+            messages: unknown[];
+            contextWindow: number;
+            activeTokens: number;
+        };
+        "context:compact": {
+            strategy?: {
+                kind: "two-tier-pin";
+                target: number;
+                keepRecent?: number;
+                force?: boolean;
+            } | {
+                kind: "rewind";
+                toIndex: number;
+            } | {
+                kind: "replace";
+                messages: unknown[];
+            };
+            stats?: {
+                before: number;
+                after: number;
+                evictedCount: number;
+            };
+        };
+        "config:switch-model": {
+            model: string;
+        };
+        "config:get-models": {
+            models: {
+                model: string;
+                provider: string;
+            }[];
+            active: {
+                model: string;
+                provider: string;
+            } | null;
+        };
+        "config:set-thinking": {
+            level: string;
+        };
+        "config:get-thinking": {
+            level: string;
+            levels: string[];
+            supported: boolean;
+        };
+        "llm:request": {
+            messages: unknown[];
+            tools?: unknown;
+            model?: string;
+            max_tokens?: number;
+            reasoning_effort?: string;
+        };
+        "llm:chunk": {
+            chunk: unknown;
+        };
+    }
+}
+export {};

package/dist/agent/events.js

@@ -0,0 +1 @@
+export {};

package/dist/agent/host-types.d.ts

@@ -39,6 +39,23 @@ export interface LlmInterface {
         reasoningEffort?: string;
     }): LlmSession;
 }
+export interface ProviderRegistration {
+    id: string;
+    apiKey?: string;
+    baseURL?: string;
+    /** Falls back to models[0] when absent. */
+    defaultModel?: string;
+    models?: (string | {
+        id: string;
+        reasoning?: boolean;
+        contextWindow?: number;
+        maxTokens?: number;
+        echoReasoning?: boolean;
+    })[];
+    supportsReasoningEffort?: boolean;
+    /** Local daemons etc. — `auth list/login` shows "no auth required". */
+    noAuth?: boolean;
+}
 /** A model entry in the cycling list, optionally tied to a provider. */
 export interface AgentMode {
     model: string;
@@ -70,6 +87,9 @@ export interface AgentMode {
 export interface AgentSurface {
     llm: LlmInterface;
     providers: {
+        /** Re-registering the same id replaces the prior contribution. */
+        register: (reg: ProviderRegistration) => () => void;
+        unregister: (id: string) => void;
         configure: (id: string, opts: {
             reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
         }) => void;

package/dist/agent/index.d.ts

@@ -1,13 +1,8 @@
 /**
- * Constructs the AgentLoop synchronously with a placeholder LlmClient,
- * so core handlers (history:append, system-prompt:build, conversation:*)
- * are defined before user extensions activate. Mode resolution is
- * deferred to `core:extensions-loaded`, giving runtime-registered
- * providers (e.g. openrouter) a chance to register before we look up
- * settings.defaultProvider. Without this deferral, a persisted
- * `defaultProvider: "openrouter"` loses to a cold-start race and the
- * backend bails silently.
+ * Mode resolution is deferred to `core:extensions-loaded` so a persisted
+ * `defaultProvider: "openrouter"` doesn't lose to a cold-start race.
  */
+import "./events.js";
 import type { ExtensionContext } from "../shell/host-types.js";
 export default function agentBackend(ctx: ExtensionContext): void;
 export type { AgentBackend } from "./types.js";
@@ -15,5 +10,6 @@ export type { ToolDefinition, ToolResult, ToolDisplayInfo } from "./types.js";
 export { AgentLoop } from "./agent-loop.js";
 export { ToolRegistry } from "./tool-registry.js";
 export { runSubagent, type SubagentOptions } from "./subagent.js";
-/** Activate the ash backend and any provider whose key is configured. */
+/** Built-in providers register unconditionally so `auth list` can
+ *  enumerate them; buildModes() skips entries without an apiKey. */
 export declare function activateAgent(ctx: ExtensionContext): void;