@agentex/agent 0.0.2 → 0.0.4

package/README.md

@@ -1,6 +1,6 @@
 # @agentex/agent
 
-Programmatic execution of AI coding agents. Spawn and manage Claude Code, Codex, OpenClaw, or any CLI-based agent as a child process with streaming output, session resume, and a unified interface.
+Programmatic execution of AI coding agents. Spawn and manage Claude Code, Codex, Gemini, Cursor, OpenCode, Pi, OpenClaw, or any CLI-based agent as a child process with streaming output, multi-turn sessions, auth detection, isolated workspaces, skill installation, and a unified interface.
 
 ## Install
 
@@ -8,6 +8,8 @@ Programmatic execution of AI coding agents. Spawn and manage Claude Code, Codex,
 npm install @agentex/agent
 ```
 
+Node.js >= 18. Each provider requires its CLI to be installed and on `$PATH`.
+
 ## Quick Start
 
 ```typescript
@@ -28,21 +30,352 @@ const result = await claude.execute({
   },
 });
 
-console.log(result.exitCode);   // 0
+console.log(result.status);     // "completed"
 console.log(result.summary);    // "Added try/catch to all route handlers..."
 console.log(result.durationMs); // 12340
 console.log(result.costUsd);    // 0.0342
-console.log(result.usage);      // { inputTokens: 1200, outputTokens: 350, cachedInputTokens: 800 }
+console.log(result.usage);      // { "claude-sonnet-4-6": { inputTokens: 1200, outputTokens: 350, ... } }
 ```
 
 ## Built-in Providers
 
-| Provider   | CLI              | Description                         |
-| ---------- | ---------------- | ----------------------------------- |
-| `claude`   | `claude`         | Claude Code (Anthropic)             |
-| `codex`    | `codex`          | Codex CLI (OpenAI)                  |
-| `openclaw` | `openclaw`       | OpenClaw agent                      |
-| `process`  | any executable   | Generic process executor            |
+| Provider   | CLI              | Description                                 |
+| ---------- | ---------------- | ------------------------------------------- |
+| `claude`   | `claude`         | Claude Code (Anthropic)                     |
+| `codex`    | `codex`          | Codex CLI (OpenAI)                          |
+| `gemini`   | `gemini`         | Gemini CLI (Google)                         |
+| `cursor`   | `agent`          | Cursor CLI agent                            |
+| `opencode` | `opencode`       | OpenCode                                    |
+| `pi`       | `pi`             | Pi CLI                                      |
+| `openclaw` | gateway HTTP     | OpenClaw HTTP-gateway agent                 |
+| `process`  | any executable   | Generic process executor (arbitrary binary) |
+
+Provider capabilities (sessions, skills, workspaces, MCP, model discovery, quota probing, instructions) are declared on each module's `capabilities` field — check `provider.capabilities` to branch on what's supported.
+
+## Execution Context
+
+Only `prompt` is required. Everything else has sensible defaults.
+
+```typescript
+interface ExecutionContext {
+  prompt: string;
+  model?: string;
+  runId?: string;                   // Auto-generated UUIDv7 if omitted
+  cwd?: string;                     // Defaults to process.cwd()
+  env?: Record<string, string>;
+  sessionParams?: Record<string, unknown> | null;
+  config?: ProviderConfig;
+  signal?: AbortSignal;             // Cancellation — SIGTERM then SIGKILL after graceSec
+  onOutput?: (stream: "stdout" | "stderr", chunk: string) => void | Promise<void>;
+  onEvent?: (event: StreamEvent) => void | Promise<void>;
+  onStart?: (pid: number) => void;
+  onLifecycle?: (event: LifecycleEvent) => void;
+}
+```
+
+`ProviderConfig` covers the knobs most providers accept:
+
+```typescript
+interface ProviderConfig {
+  command?: string;                 // Override CLI binary path
+  model?: string;
+  effort?: string;
+  maxTurns?: number;
+  timeoutSec?: number;
+  graceSec?: number;
+  skipPermissions?: boolean;
+  skillDirs?: string[];
+  instructionsFile?: string;
+  mcpServers?: McpServerConfig[];
+  extraArgs?: string[];
+  search?: boolean;
+  sandbox?: boolean;
+  thinking?: string;
+  mode?: string;
+  workspace?: { strategy: "worktree"; baseBranch?: string; branchName?: string };
+}
+```
+
+## Execution Result
+
+```typescript
+interface ExecutionResult {
+  runId: string;
+  exitCode: number | null;
+  signal: string | null;
+  status: ExecutionStatus;          // "completed" | "failed" | "aborted" | "timeout" | "blocked"
+  startedAt: string;                // ISO timestamp
+  completedAt: string;
+  durationMs: number;
+  errorMessage: string | null;
+  errorCode: string | null;
+  usage?: Record<string, TokenUsage>;  // keyed by model ID
+  costUsd: number | null;
+  model: string | null;
+  summary: string | null;
+  sessionParams: Record<string, unknown> | null;
+  sessionDisplayId: string | null;
+  clearSession: boolean;
+  billingType: "api" | "subscription" | "metered_api" | null;
+  raw?: Record<string, unknown> | null;
+  workspace?: PreparedWorkspace;    // Present if config.workspace was set
+}
+```
+
+Use `aggregateUsage(result.usage)` to collapse per-model usage into a single total.
+
+## Stream Events
+
+Emitted during execution via `onEvent`. All events include `timestamp`.
+
+- `system` — Session init (`sessionId`, `model`, `subtype`)
+- `assistant` — Text output from the agent (`text`)
+- `thinking` — Agent's internal reasoning (`text`)
+- `tool_call` — Agent invoked a tool (`name`, `input`, `callId?`)
+- `tool_result` — Tool returned a result (`toolCallId`, `content`, `isError`)
+- `result` — Final result (`text`, `cost`, `isError`)
+
+Lifecycle events (via `onLifecycle`) report phases: `preparing`, `spawning`, `running`, `waiting_for_input`, `completed`, `cancelled`, `error`.
+
+## Sessions (multi-turn)
+
+Providers with `capabilities.sessions = true` (Claude, Codex) can host a persistent session where you send multiple user messages and reuse context across turns.
+
+```typescript
+import { getProvider, parseAskUserQuestion } from "@agentex/agent";
+
+const claude = getProvider("claude");
+const session = await claude.createSession!({
+  cwd: process.cwd(),
+  onEvent: (e) => { /* stream events */ },
+  onUserInputRequest: async (req) => {
+    const q = parseAskUserQuestion(req);
+    if (q) return { allow: true, updatedInput: { answers: ["Yes"] } };
+    return { allow: true };  // auto-approve other tool calls
+  },
+});
+
+const first = await session.send("List the API routes in src/");
+const followUp = await session.send("Now add rate limiting to each one.");
+
+await session.close();
+```
+
+`session.send()` returns a `TurnResult` with `summary`, `usage`, `costUsd`, and a `status` of `completed | failed | max_turns | max_budget | aborted`. Handle elicitations (MCP forms), hook callbacks, and interrupts through the corresponding `SessionContext` callbacks.
+
+## Auth
+
+`provider.resolveAuth()` is the single entry point for "is this provider usable?" It returns binary status, every supported auth path with a definitive `present: boolean`, and (when the CLI exposes it) rich identity info like email and subscription tier.
+
+Under the hood it prefers the provider's own status subcommand — `claude auth status --json`, `codex login status` — falling back to filesystem heuristics if the binary is missing or too old.
+
+```typescript
+import { getProvider, hasSubscription, hasApiKey } from "@agentex/agent";
+
+const claude = getProvider("claude");
+const auth = await claude.resolveAuth();
+
+// {
+//   providerType: "claude",
+//   binary: { installed: true, resolvedPath: "/Users/you/.local/bin/claude", version: "2.1.116" },
+//   options: [
+//     { method: "api_key",      source: { kind: "env", var: "ANTHROPIC_API_KEY" }, present: false },
+//     { method: "bedrock",      source: { kind: "env_combo", vars: [...] },        present: false },
+//     { method: "subscription", source: { kind: "cli", command: "claude auth status --json" }, present: true },
+//   ],
+//   identity: { email: "you@example.com", orgName: "Acme", subscriptionType: "max", authMethod: "claude.ai" },
+//   source: "cli",
+// }
+```
+
+### Sugar helpers (commit to a billing mode explicitly)
+
+There is deliberately no blanket `canRun()` / `isReady()` helper — conflating subscription and API-key auth is a billing footgun (e.g. Claude with `ANTHROPIC_API_KEY` set silently bills metered API even if the user's also subscribed). Callers name the mode they want:
+
+```typescript
+await hasSubscription(claude);  // true only if a subscription credential is confirmed present
+await hasApiKey(claude);        // true only if an API env var is set
+await hasBedrock(claude);       // true only if Bedrock credentials are configured
+```
+
+For "any auth works," write it out explicitly at the call site:
+
+```typescript
+const anyReady = (await claude.resolveAuth()).options.some((o) => o.present);
+```
+
+### Welcome-flow pattern
+
+```typescript
+const auth = await claude.resolveAuth();
+
+if (!auth.binary.installed) {
+  return showInstallInstructions(auth.binary.error);
+}
+
+const sub = await hasSubscription(claude);
+const key = await hasApiKey(claude);
+
+if (sub && !key)  return showReady("subscription", auth.identity);
+if (key && !sub)  return showReady("api_key");
+if (sub && key)   return showReady("api_key", { warning: "api_key_wins" });
+return showLoginInstructions();
+```
+
+For end-to-end verification (is auth actually good enough to complete a round-trip?), just call `execute()` with a trivial prompt — no separate probe method:
+
+```typescript
+await claude.execute({ prompt: "Respond with 'hello'.", config: { timeoutSec: 15 } });
+```
+
+### What each provider reports
+
+| Provider  | Subscription source                                             | API key source(s)                          | Other                                                                        |
+| --------- | --------------------------------------------------------------- | ------------------------------------------ | ---------------------------------------------------------------------------- |
+| `claude`  | `claude auth status --json` · fallback: keychain/creds file     | `ANTHROPIC_API_KEY`                        | Bedrock via `ANTHROPIC_BEDROCK_BASE_URL` or `AWS_ACCESS_KEY_ID`+`AWS_REGION` |
+| `codex`   | `codex login status` · fallback: `$CODEX_HOME/auth.json`        | `OPENAI_API_KEY`                           | —                                                                            |
+| `gemini`  | `$GEMINI_CONFIG_DIR/oauth_creds.json`                           | `GEMINI_API_KEY`, `GOOGLE_API_KEY`         | —                                                                            |
+| `cursor`  | (detected at runtime by the CLI)                                | `CURSOR_API_KEY`, `OPENAI_API_KEY`         | —                                                                            |
+| `opencode`| —                                                               | `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`      | —                                                                            |
+| `pi`      | —                                                               | `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`      | —                                                                            |
+
+### Precedence (what actually gets used when both are present)
+
+The library reflects real CLI behavior rather than imposing its own:
+
+| Provider  | Winner when both API key and subscription present                       |
+| --------- | ----------------------------------------------------------------------- |
+| Claude    | API key wins (documented). Set `hasApiKey` + show a billing warning.    |
+| Codex     | Subscription wins (current CLI; see openai/codex#2733, #3286).          |
+| Gemini    | API key wins in non-interactive mode.                                   |
+
+### Caching
+
+Results are cached for 60s per `(providerType, env, command)` to keep welcome-flow and badge-rendering calls effectively free. Pass `{ fresh: true }` to bypass:
+
+```typescript
+await claude.resolveAuth({ fresh: true });
+// Or globally:
+import { clearAuthCache } from "@agentex/agent";
+clearAuthCache();
+```
+
+### Auth types
+
+```typescript
+type AuthMethod = "api_key" | "bedrock" | "subscription";
+
+type AuthSource =
+  | { kind: "env"; var: string }
+  | { kind: "env_combo"; vars: string[] }
+  | { kind: "file"; path: string }
+  | { kind: "keychain"; service: string; account?: string }
+  | { kind: "cli"; command: string };
+
+interface AuthOption {
+  method: AuthMethod;
+  source: AuthSource;
+  present: boolean;
+}
+
+interface BinaryStatus {
+  installed: boolean;
+  resolvedPath?: string;
+  version?: string;
+  error?: string;
+}
+
+interface AuthIdentity {
+  email?: string;
+  orgName?: string;
+  subscriptionType?: string;   // "max", "pro", "team", "enterprise"
+  authMethod?: string;         // "claude.ai", "chatgpt", "api_key", ...
+}
+
+interface AuthReport {
+  providerType: string;
+  binary: BinaryStatus;
+  options: AuthOption[];
+  identity?: AuthIdentity;
+  source: "cli" | "filesystem";
+}
+```
+
+## Workspaces (isolated git worktree)
+
+Providers with `capabilities.workspace = true` can run in an isolated `git worktree`, letting you diff or discard the agent's changes without touching your main checkout.
+
+```typescript
+import { prepareWorkspace } from "@agentex/agent";
+
+const ws = await prepareWorkspace({ strategy: "worktree", baseBranch: "main" });
+const result = await claude.execute({ prompt: "Refactor utils.ts", cwd: ws.cwd });
+
+const patch = await ws.diff();                        // all changes (default)
+const summary = await ws.diff({ stat: true });        // --stat summary
+const committed = await ws.diff({ scope: "committed" });
+
+await ws.cleanup({ deleteBranch: true });
+```
+
+Or pass `config.workspace` to `execute()` and the provider will prepare and attach it — the result's `workspace` field exposes the same handle.
+
+## Parallel Execution
+
+```typescript
+import { executeAll } from "@agentex/agent";
+
+const results = await executeAll(
+  [
+    { provider: "claude", ctx: { prompt: "Review server.ts" } },
+    { provider: "codex",  ctx: { prompt: "Review db.ts" } },
+  ],
+  { cancelOnFailure: true },
+);
+```
+
+## Skills
+
+Install and remove reusable agent skills across multiple runtimes at once, into either the user's home or a workspace directory.
+
+```typescript
+import { installSkills, listInstalledSkills, removeSkills } from "@agentex/agent";
+
+await installSkills({
+  location: "global",                 // or "workspace" with cwd
+  includeNativeDirs: false,           // true also installs into ~/.gemini/skills/, etc.
+});
+
+const installed = await listInstalledSkills({ location: "global" });
+await removeSkills({ location: "global" });
+```
+
+Channels and locations follow the emerging `.agents/skills/` + `.claude/skills/` convention — see the `SkillRuntime`, `SkillLocation`, and `SkillChannel` types.
+
+## Temporary Config Override
+
+Run a CLI with a throwaway config directory (useful for injecting system prompts or custom settings without touching the user's real home).
+
+```typescript
+import { withTempConfig } from "@agentex/agent";
+
+const cfg = await withTempConfig({
+  runtime: "codex",
+  seedFromDefault: true,                          // optional: copy ~/.codex into the temp dir
+  overrides: { "config.toml": "model = \"o3\"\n" },
+});
+
+await codex.execute({ prompt: "...", env: cfg.env });
+await cfg.cleanup();
+```
+
+## AskUserQuestion / Elicitation / Hooks
+
+Sessions can surface three distinct user-input requests. Handle each via a `SessionContext` callback:
+
+- `onUserInputRequest` — tool permission requests (and interactive tools like Claude's `AskUserQuestion`). Use `parseAskUserQuestion(req)` to detect structured question payloads and return answers via `updatedInput`.
+- `onElicitation` — MCP servers asking the host to render a form or open a URL (`form` / `url` modes, with a JSON-Schema `requestedSchema`).
+- `onHookCallback` — CLI requesting the host to run a registered hook.
 
 ## Custom Providers
 
@@ -52,6 +385,15 @@ import type { ProviderModule } from "@agentex/agent";
 
 const myProvider: ProviderModule = {
   type: "my-agent",
+  capabilities: {
+    sessions: false,
+    modelDiscovery: false,
+    quotaProbing: false,
+    mcp: false,
+    skills: false,
+    instructions: false,
+    workspace: false,
+  },
   async execute(ctx) {
     const startedAt = new Date().toISOString();
     // Spawn your agent, stream events via ctx.onEvent...
@@ -59,7 +401,7 @@ const myProvider: ProviderModule = {
       runId: ctx.runId ?? "generated-id",
       exitCode: 0,
       signal: null,
-      timedOut: false,
+      status: "completed",
       startedAt,
       completedAt: new Date().toISOString(),
       durationMs: 0,
@@ -74,93 +416,69 @@ const myProvider: ProviderModule = {
       billingType: null,
     };
   },
-  async testEnvironment(ctx) {
-    return { providerType: ctx.providerType, status: "pass", checks: [], testedAt: new Date().toISOString() };
+  async resolveAuth() {
+    return {
+      providerType: "my-agent",
+      binary: { installed: true },
+      options: [],
+      source: "filesystem",
+    };
   },
 };
 
 registerProvider(myProvider);
 ```
 
-## API
-
-### `getProvider(type: string): ProviderModule`
-
-Returns a registered provider by name. Throws if not found.
-
-### `listProviders(): string[]`
-
-Returns all registered provider type names.
-
-### `registerProvider(provider: ProviderModule): void`
-
-Registers a custom provider, making it available via `getProvider()`.
-
-### `renderTemplate(template: string, context: Record<string, string>): string`
-
-Renders a template string with `{{variable}}` interpolation.
-
-### `redactEnvForLogs(env: Record<string, string>): Record<string, string>`
-
-Returns a copy of env vars with sensitive values redacted for safe logging.
-
-## Execution Context
-
-Only `prompt` is required. Everything else has sensible defaults.
-
-```typescript
-interface ExecutionContext {
-  prompt: string;             // The task to execute
-  model?: string;             // Model override (e.g. "claude-sonnet-4-20250514")
-  runId?: string;             // Auto-generated UUIDv7 if omitted
-  cwd?: string;               // Defaults to process.cwd()
-  env?: Record<string, string>;
-  sessionParams?: Record<string, unknown> | null;
-  config?: ProviderConfig;
-  onOutput?: (stream: "stdout" | "stderr", chunk: string) => void;
-  onEvent?: (event: StreamEvent) => void;
-}
-```
-
-## Execution Result
-
-```typescript
-interface ExecutionResult {
-  runId: string;
-  exitCode: number | null;
-  signal: string | null;
-  timedOut: boolean;
-  startedAt: string;          // ISO timestamp
-  completedAt: string;        // ISO timestamp
-  durationMs: number;         // Wall-clock duration
-  errorMessage: string | null;
-  errorCode: string | null;
-  usage?: { inputTokens: number; outputTokens: number; cachedInputTokens?: number };
-  costUsd: number | null;
-  model: string | null;
-  summary: string | null;
-  sessionParams: Record<string, unknown> | null;
-  sessionDisplayId: string | null;
-  clearSession: boolean;
-  billingType: "api" | "subscription" | null;
-}
-```
-
-## Stream Events
-
-Events emitted during execution via `onEvent`. All events include a `timestamp` field.
-
-- `system` — Session init (`event.sessionId`, `event.model`)
-- `assistant` — Text output from the agent (`event.text`)
-- `thinking` — Agent's internal reasoning (`event.text`)
-- `tool_call` — Agent invoked a tool (`event.name`, `event.input`)
-- `tool_result` — Tool returned a result (`event.content`, `event.isError`)
-- `result` — Final result (`event.text`, `event.cost`)
+## API Reference
+
+### Registry
+- `getProvider(type)` — look up a registered provider. Throws if unknown.
+- `listProviders()` — list all registered provider type names.
+- `registerProvider(module)` — register a custom provider.
+
+### Execution
+- `provider.execute(ctx)` — run a single turn.
+- `provider.createSession?(ctx)` — start a multi-turn session (when `capabilities.sessions`).
+- `executeAll(tasks, { cancelOnFailure?, signal? })` — run multiple executions concurrently.
+
+### Auth
+- `provider.resolveAuth(ctx?)` — structured report: binary status, all auth paths, identity. Cached 60s; pass `{ fresh: true }` to bypass.
+- `hasSubscription(provider, ctx?)` / `hasApiKey(provider, ctx?)` / `hasBedrock(provider, ctx?)` — presence sugar.
+- `clearAuthCache()` — invalidate the resolveAuth cache globally (e.g. after a login).
+- `detectAuth(providerType, env)` — legacy env-only auth classification used internally for `ExecutionResult.billingType`.
+
+### Binary / runtime
+- `findBinary(name, configOverride?)` — resolve a provider CLI on disk.
+- `ensureCommandResolvable(command)` — like `findBinary` but accepts an absolute path too.
+- `clearBinaryCache()` — invalidate the binary-resolution cache.
+- `provider.checkQuota?(ctx)` — rate-limit / quota status (when `capabilities.quotaProbing`).
+- `provider.listModels?(opts?)` — enumerate models the binary can drive.
+
+### Workspace
+- `prepareWorkspace({ strategy, baseBranch?, branchName?, targetDir? })` → `PreparedWorkspace` with `cwd`, `diff()`, `cleanup()`.
+
+### Skills
+- `installSkills(opts)` / `removeSkills(opts)` / `listInstalledSkills(opts)`
+- `resolveSkillsHome(channel)` / `resolveSkillsWorkspace(channel, cwd)`
+- `resolveNativeSkillsHome(runtime)` / `resolveNativeSkillsWorkspace(runtime, cwd)`
+- `ensureSkillSymlink(...)`
+
+### Runtime config
+- `withTempConfig({ runtime, seedFromDefault?, overrides? })` → env + configDir + cleanup.
+- `getRuntimeHomeEnvVar(runtime)` / `getDefaultRuntimeHome(runtime)` — introspect each CLI's home dir override.
+
+### Utilities
+- `aggregateUsage(usage)` — collapse `Record<string, TokenUsage>` to a single total.
+- `renderTemplate(template, ctx)` — `{{var}}` interpolation.
+- `redactEnvForLogs(env)` — redact sensitive values before logging.
+- `resolveInstructions(path?)` — read an instructions file, or `null` if no path.
+- `parseAskUserQuestion(req)` — extract structured question/option data from a `UserInputRequest`.
 
 ## Requirements
 
 - Node.js >= 18
-- The CLI for each provider must be installed and on `$PATH` (e.g., `claude` for the Claude provider)
+- Each provider's CLI installed and resolvable on `$PATH` (`claude`, `codex`, `gemini`, `agent` for Cursor, `opencode`, `pi`, or a reachable OpenClaw gateway)
+- For subscription auth, the relevant CLI must already be logged in (`codex login`, `claude login`, `gemini auth login`, etc.)
 
 ## License
 

package/dist/index.d.ts

@@ -1,5 +1,22 @@
 export { getProvider, listProviders, registerProvider } from "./registry.js";
 export { renderTemplate } from "./utils/template.js";
 export { redactEnvForLogs } from "./utils/env.js";
-export type { ProviderModule, ExecutionContext, ExecutionResult, ProviderConfig, McpServerConfig, StreamEvent, SessionCodec, EnvironmentTestContext, EnvironmentTestResult, EnvironmentCheck, ProviderModel, } from "./types.js";
+export { parseAskUserQuestion } from "./utils/ask-user-question.js";
+export { aggregateUsage } from "./types.js";
+export { resolveInstructions } from "./utils/instructions.js";
+export { getRuntimeHomeEnvVar, getDefaultRuntimeHome } from "./utils/runtime-homes.js";
+export { findBinary, ensureCommandResolvable, clearBinaryCache } from "./utils/binary.js";
+export type { ResolvedBinary } from "./utils/binary.js";
+export { detectAuth, resolveAuthForProvider, clearAuthCache, hasSubscription, hasApiKey, hasBedrock, } from "./utils/auth.js";
+export type { ResolvedAuth } from "./utils/auth.js";
+export { prepareWorkspace } from "./utils/workspace.js";
+export type { WorkspaceOptions, PreparedWorkspace, DiffOptions } from "./utils/workspace.js";
+export { withTempConfig } from "./utils/runtime-config.js";
+export type { TempConfigResult, TempConfigOptions } from "./utils/runtime-config.js";
+export { executeAll } from "./utils/execute-all.js";
+export type { ExecuteAllOptions, ExecuteAllTask } from "./utils/execute-all.js";
+export { installSkills, removeSkills, listInstalledSkills, resolveSkillsHome, resolveSkillsWorkspace, resolveNativeSkillsHome, resolveNativeSkillsWorkspace, ensureSkillSymlink, } from "./utils/skills.js";
+export type { ProviderModule, ProviderCapabilities, ExecutionContext, ExecutionResult, ExecutionStatus, ProviderConfig, McpServerConfig, StreamEvent, SessionCodec, SessionState, TokenUsage, LifecycleEvent, QuotaStatus, QuotaContext, AuthMethod, AuthSource, AuthOption, AuthReport, AuthResolveContext, AuthIdentity, BinaryStatus, ProviderModel, SessionContext, AgentSession, TurnResult, UserInputRequest, UserInputResponse, ElicitationRequest, ElicitationResponse, HookCallbackRequest, HookCallbackResponse, } from "./types.js";
+export type { AskUserQuestion, QuestionOption, } from "./utils/ask-user-question.js";
+export type { SkillRuntime, SkillLocation, SkillChannel, InstallSkillsOptions, SkillInstallEntry, SkillInstallResult, RemoveSkillsOptions, SkillRemoveEntry, SkillRemoveResult, InstalledSkill, } from "./utils/skills.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGlD,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,eAAe,EACf,WAAW,EACX,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1F,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EACL,UAAU,EACV,sBAAsB,EACtB,cAAc,EACd,eAAe,EACf,SAAS,EACT,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACrF,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAGhF,OAAO,EACL,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,4BAA4B,EAC5B,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EACV,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,cAAc,EACd,eAAe,EACf,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,WAAW,EACX,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,cAAc,EACd,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,eAAe,EACf,cAAc,GACf,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,GACf,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -2,4 +2,15 @@
 export { getProvider, listProviders, registerProvider } from "./registry.js";
 export { renderTemplate } from "./utils/template.js";
 export { redactEnvForLogs } from "./utils/env.js";
+export { parseAskUserQuestion } from "./utils/ask-user-question.js";
+export { aggregateUsage } from "./types.js";
+export { resolveInstructions } from "./utils/instructions.js";
+export { getRuntimeHomeEnvVar, getDefaultRuntimeHome } from "./utils/runtime-homes.js";
+export { findBinary, ensureCommandResolvable, clearBinaryCache } from "./utils/binary.js";
+export { detectAuth, resolveAuthForProvider, clearAuthCache, hasSubscription, hasApiKey, hasBedrock, } from "./utils/auth.js";
+export { prepareWorkspace } from "./utils/workspace.js";
+export { withTempConfig } from "./utils/runtime-config.js";
+export { executeAll } from "./utils/execute-all.js";
+// Skills
+export { installSkills, removeSkills, listInstalledSkills, resolveSkillsHome, resolveSkillsWorkspace, resolveNativeSkillsHome, resolveNativeSkillsWorkspace, ensureSkillSymlink, } from "./utils/skills.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY;AACZ,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY;AACZ,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1F,OAAO,EACL,UAAU,EACV,sBAAsB,EACtB,cAAc,EACd,eAAe,EACf,SAAS,EACT,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGpD,SAAS;AACT,OAAO,EACL,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,4BAA4B,EAC5B,kBAAkB,GACnB,MAAM,mBAAmB,CAAC"}

package/dist/providers/claude/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/execute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAaxE,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4M3F"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/execute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAWxE,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAgP3F"}