@perstack/runtime 0.0.62 → 0.0.64

package/README.md

@@ -10,24 +10,55 @@ This package serves as the engine of Perstack. It orchestrates the lifecycle of
 npm install @perstack/runtime
 ```
 
-## Usage
+## CLI Usage
 
-The primary entry point is the `run` function. It takes a `RunSetting` object and an optional `RunOptions` object.
+The runtime can be executed as a standalone CLI:
+
+```bash
+perstack-runtime run <expertKey> <query> [options]
+```
+
+### Options
+
+| Option                  | Description             |
+| ----------------------- | ----------------------- |
+| `--config <path>`       | Path to perstack.toml   |
+| `--provider <provider>` | LLM provider            |
+| `--model <model>`       | Model name              |
+| `--temperature <temp>`  | Temperature (0.0-1.0)   |
+| `--max-steps <n>`       | Maximum steps           |
+| `--max-retries <n>`     | Maximum retries         |
+| `--timeout <ms>`        | Timeout in milliseconds |
+| `--job-id <id>`         | Job ID                  |
+| `--run-id <id>`         | Run ID                  |
+| `--env-path <path...>`  | Environment file paths  |
+
+### Example
+
+```bash
+perstack-runtime run my-expert "What is the weather?" --config ./perstack.toml
+```
+
+Output is JSON events (one per line) to stdout.
+
+## Programmatic Usage
+
+The primary entry point is the `run` function. It takes a `JobSetting` object and an optional `RunOptions` object.
 
 ```typescript
 import { run } from "@perstack/runtime"
-import { type RunSetting } from "@perstack/core"
+import { type JobSetting } from "@perstack/core"
 
-// Configure the run
-const setting: RunSetting = {
-  runId: "run-123",
+// Configure the job
+const setting: JobSetting = {
+  jobId: "job-123",
   expertKey: "researcher",
   input: { text: "Research quantum computing" },
   // ... configuration for model, experts, etc.
 }
 
-// Execute the run
-const finalCheckpoint = await run({ setting }, {
+// Execute the job
+const finalJob = await run({ setting }, {
   eventListener: (event) => {
     console.log(`[${event.type}]`, event)
   }
@@ -43,8 +74,9 @@ type RunEvent = {
   type: EventType       // e.g., "startRun", "callTools"
   id: string            // Unique event ID
   timestamp: number     // Unix timestamp
-  runId: string         // ID of the current run
-  stepNumber: number    // Current step number
+  jobId: string         // ID of the Job
+  runId: string         // ID of the current Run
+  stepNumber: number    // Current step number within this Run
   // ... plus payload specific to the event type
 }
 ```
@@ -72,11 +104,11 @@ eventListener: (event) => {
 
 The runtime manages skills through specialized Skill Managers. Each skill type has its own manager class:
 
-| Type            | Manager                   | Purpose                            |
-| --------------- | ------------------------- | ---------------------------------- |
-| MCP (stdio/SSE) | `McpSkillManager`         | External tools via MCP protocol    |
-| Interactive     | `InteractiveSkillManager` | User input tools (pause execution) |
-| Delegate        | `DelegateSkillManager`    | Expert-to-Expert calls             |
+| Type            | Manager                   | Purpose                             |
+| --------------- | ------------------------- | ----------------------------------- |
+| MCP (stdio/SSE) | `McpSkillManager`         | External tools via MCP protocol     |
+| Interactive     | `InteractiveSkillManager` | User input tools (Coordinator only) |
+| Delegate        | `DelegateSkillManager`    | Expert-to-Expert calls              |
 
 All managers extend `BaseSkillManager` which provides:
 - `init()` — Initialize the skill (connect MCP servers, parse definitions)
@@ -84,6 +116,8 @@ All managers extend `BaseSkillManager` which provides:
 - `getToolDefinitions()` — Get available tools
 - `callTool()` — Execute a tool call
 
+**Note:** Interactive skills are only available to the Coordinator Expert. See [Experts documentation](https://docs.perstack.ai/understanding-perstack/experts#why-no-interactive-tools-for-delegates) for details.
+
 ### Initialization Flow
 
 ```
@@ -92,7 +126,7 @@ getSkillManagers(expert, experts, setting)
     ├─► Initialize MCP skills (parallel)
     │   └─► McpSkillManager × N
     │
-    ├─► Initialize Interactive skills (parallel)
+    ├─► Initialize Interactive skills (Coordinator only)
     │   └─► InteractiveSkillManager × N
     │
     └─► Initialize Delegate skills (parallel)
@@ -113,15 +147,20 @@ graph TD
     User((User)) -->|Provides| Input[Input / Query]
     
     subgraph Runtime [Runtime Engine]
-        subgraph Instance [Expert Instance]
-            State[State Machine]
-            Context[Execution Context]
-            
-            subgraph Skills [Skill Layer]
-                SM[Skill Manager]
-                MCP[MCP Client]
-                MCPServer[MCP Server]
+        subgraph Job [Job]
+            subgraph Run1 [Run: Coordinator]
+                State[State Machine]
+                Context[Execution Context]
+                
+                subgraph Skills [Skill Layer]
+                    SM[Skill Manager]
+                    MCP[MCP Client]
+                    MCPServer[MCP Server]
+                end
             end
+            
+            Run2["Run: Delegate A"]
+            Run3["Run: Delegate B"]
         end
     end
 
@@ -130,8 +169,8 @@ graph TD
         Workspace[Workspace / FS]
     end
 
-    Def -->|Instantiates| Instance
-    Input -->|Starts| Instance
+    Def -->|Instantiates| Run1
+    Input -->|Starts| Run1
 
     State -->|Reasoning| LLM
     State -->|Act| SM
@@ -139,13 +178,34 @@ graph TD
     MCP -->|Connect| MCPServer
     MCPServer -->|Access| Workspace
     
-    SM -.->|Delegate| Instance2["Expert Instance (Delegate)"]
-
-    State ~~~ Context
+    SM -.->|Delegate| Run2
+    SM -.->|Delegate| Run3
 ```
 
 ## Core Concepts
 
+### Execution Hierarchy
+
+```
+Job (jobId)
+ ├── Run 1 (Coordinator Expert)
+ │    └── Checkpoints...
+ ├── Run 2 (Delegated Expert A)
+ │    └── Checkpoints...
+ └── Run 3 (Delegated Expert B)
+      └── Checkpoints...
+```
+
+| Concept        | Description                                  |
+| -------------- | -------------------------------------------- |
+| **Job**        | Top-level execution unit. Contains all Runs. |
+| **Run**        | Single Expert execution.                     |
+| **Checkpoint** | Snapshot at step end. Enables pause/resume.  |
+
+For details on step counting, Coordinator vs. Delegated Expert differences, and the full execution model, see [Runtime](https://docs.perstack.ai/understanding-perstack/runtime).
+
+### Events, Steps, Checkpoints
+
 The runtime's execution model can be visualized as a timeline where **Events** are points, **Steps** are the lines connecting them, and **Checkpoints** are the anchors.
 
 ```mermaid
@@ -164,13 +224,13 @@ graph LR
     style CP2 fill:#f96,stroke:#333,stroke-width:4px
 ```
 
-### 1. Events
+#### 1. Events
 **Events** are granular moments in time that occur *during* execution. They represent specific actions or observations, such as "started reasoning", "called tool", or "finished tool".
 
-### 2. Step
+#### 2. Step
 A **Step** is the continuous process that connects these events. It represents one atomic cycle of the agent's loop (Reasoning -> Act -> Observe, repeat).
 
-### 3. Checkpoint
+#### 3. Checkpoint
 A **Checkpoint** is the immutable result at the end of a Step. It serves as the anchor point that:
 - Finalizes the previous Step.
 - Becomes the starting point for the next Step.
@@ -194,7 +254,7 @@ stateDiagram-v2
     CallingTools --> ResolvingToolResults: resolveToolResults
     CallingTools --> ResolvingThought: resolveThought
     CallingTools --> GeneratingRunResult: attemptCompletion
-    CallingTools --> CallingDelegate: callDelegate
+    CallingTools --> CallingDelegate: callDelegates
     CallingTools --> CallingInteractiveTool: callInteractiveTool
 
     ResolvingToolResults --> FinishingStep: finishToolCall
@@ -216,24 +276,82 @@ Events trigger state transitions. They are emitted by the runtime logic or exter
 - **Lifecycle**: `startRun`, `startGeneration`, `continueToNextStep`, `completeRun`
 - **Tool Execution**: `callTools`, `resolveToolResults`, `finishToolCall`, `resumeToolCalls`, `finishAllToolCalls`
 - **Special Types**: `resolveThought`
-- **Mixed Tool Calls**: `callDelegate`, `callInteractiveTool` (from CallingTools state)
+- **Delegation**: `callDelegate` (triggers new Run(s) for delegate(s), parallel when multiple)
+- **Interactive**: `callInteractiveTool` (Coordinator only)
 - **Interruption**: `stopRunByInteractiveTool`, `stopRunByDelegate`, `stopRunByExceededMaxSteps`
 - **Error Handling**: `retry`
 
 ## Checkpoint Status
 
-The `status` field in a Checkpoint indicates the current state of the execution.
+The `status` field in a Checkpoint indicates the current state:
 
-- **init**: The run has been created but not yet started.
-- **proceeding**: The run is currently active and executing steps.
-- **completed**: The run has finished successfully.
-- **stoppedByInteractiveTool**: The run is paused, waiting for user input (e.g., confirmation or parameter entry).
-- **stoppedByDelegate**: The run is paused, waiting for a delegated sub-agent to complete.
-- **stoppedByExceededMaxSteps**: The run stopped because it reached the maximum allowed steps.
-- **stoppedByError**: The run stopped due to an unrecoverable error.
+- `init`, `proceeding` — Run lifecycle
+- `completed` — Task finished successfully
+- `stoppedByInteractiveTool`, `stoppedByDelegate` — Waiting for external input
+- `stoppedByExceededMaxSteps`, `stoppedByError` — Run stopped
 
-## Related Documentation
+For stop reasons and error handling, see [Error Handling](https://docs.perstack.ai/using-experts/error-handling).
+
+## Runtime Adapters
+
+The runtime supports multiple execution backends through the adapter pattern. External runtime adapters are provided as separate packages:
+
+| Package                 | Runtime Name  | Description                |
+| ----------------------- | ------------- | -------------------------- |
+| `@perstack/runtime`     | `perstack`    | Built-in runtime (default) |
+| `@perstack/cursor`      | `cursor`      | Cursor IDE headless mode   |
+| `@perstack/claude-code` | `claude-code` | Claude Code CLI            |
+| `@perstack/gemini`      | `gemini`      | Gemini CLI                 |
+
+### Registration Pattern
+
+External adapters must be registered before use:
+
+```typescript
+import { CursorAdapter } from "@perstack/cursor"
+import { getAdapter, isAdapterAvailable, registerAdapter } from "@perstack/runtime"
+
+// Register external adapter
+registerAdapter("cursor", () => new CursorAdapter())
+
+// Check availability
+if (isAdapterAvailable("cursor")) {
+  const adapter = getAdapter("cursor")
+  const result = await adapter.checkPrerequisites()
+  if (result.ok) {
+    await adapter.run({ setting, eventListener })
+  }
+}
+```
+
+### Creating Custom Adapters
+
+Extend `BaseAdapter` from `@perstack/core` for CLI-based runtimes:
 
-- [Running Experts](https://perstack.ai/docs/using-experts/running-experts) - How to run Experts
-- [State Management](https://perstack.ai/docs/using-experts/state-management) - Understanding checkpoints and state
+```typescript
+import { BaseAdapter, type AdapterRunParams, type AdapterRunResult, type PrerequisiteResult } from "@perstack/core"
+
+class MyAdapter extends BaseAdapter {
+  readonly name = "my-runtime"
+  
+  async checkPrerequisites(): Promise<PrerequisiteResult> {
+    const result = await this.execCommand(["my-cli", "--version"])
+    return result.exitCode === 0
+      ? { ok: true }
+      : { ok: false, error: { type: "cli-not-found", message: "..." } }
+  }
+  
+  async run(params: AdapterRunParams): Promise<AdapterRunResult> {
+    // Implementation
+  }
+}
+```
+
+See [Multi-Runtime Support](https://docs.perstack.ai/using-experts/multi-runtime) for details.
+
+## Related Documentation
 
+- [Runtime](https://docs.perstack.ai/understanding-perstack/runtime) — Full execution model
+- [State Management](https://docs.perstack.ai/using-experts/state-management) — Jobs, Runs, and Checkpoints
+- [Running Experts](https://docs.perstack.ai/using-experts/running-experts) — CLI usage
+- [Multi-Runtime](https://docs.perstack.ai/using-experts/multi-runtime) — Multi-runtime support

package/bin/cli.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import type { Checkpoint, RunEvent, RuntimeEvent } from "@perstack/core"
+import { parseWithFriendlyError, runCommandInputSchema } from "@perstack/core"
+import { Command } from "commander"
+import pkg from "../package.json" with { type: "json" }
+import { resolveRunContext } from "../src/cli/context.js"
+import { run } from "../src/run.js"
+
+const defaultEventListener = (event: RunEvent | RuntimeEvent) => console.log(JSON.stringify(event))
+
+const checkpointStore = new Map<string, Checkpoint>()
+const storeCheckpoint = async (checkpoint: Checkpoint) => {
+  checkpointStore.set(checkpoint.id, checkpoint)
+}
+const retrieveCheckpoint = async (_jobId: string, checkpointId: string) => {
+  const checkpoint = checkpointStore.get(checkpointId)
+  if (!checkpoint) {
+    throw new Error(`Checkpoint not found: ${checkpointId}`)
+  }
+  return checkpoint
+}
+
+const program = new Command()
+  .name("perstack-runtime")
+  .description("Perstack Runtime CLI - Execute Experts directly")
+  .version(pkg.version)
+
+program
+  .command("run")
+  .description("Run an Expert with JSON event output")
+  .argument("<expertKey>", "Expert key to run")
+  .argument("<query>", "Query to run")
+  .option("--config <configPath>", "Path to perstack.toml config file")
+  .option("--provider <provider>", "Provider to use")
+  .option("--model <model>", "Model to use")
+  .option("--temperature <temperature>", "Temperature for the model, default is 0.3")
+  .option(
+    "--max-steps <maxSteps>",
+    "Maximum number of steps to run, default is undefined (no limit)",
+  )
+  .option("--max-retries <maxRetries>", "Maximum number of generation retries, default is 5")
+  .option(
+    "--timeout <timeout>",
+    "Timeout for each generation in milliseconds, default is 60000 (1 minute)",
+  )
+  .option("--job-id <jobId>", "Job ID for identifying the job")
+  .option("--run-id <runId>", "Run ID for identifying the run")
+  .option("--env-path <envPath...>", "Path to the environment file, default is .env and .env.local")
+  .option("--verbose", "Enable verbose logging")
+  .action(async (expertKey, query, options) => {
+    const input = parseWithFriendlyError(runCommandInputSchema, { expertKey, query, options })
+    try {
+      const { perstackConfig, env, providerConfig, model, experts } = await resolveRunContext({
+        configPath: input.options.config,
+        provider: input.options.provider,
+        model: input.options.model,
+        envPath: input.options.envPath,
+      })
+      await run(
+        {
+          setting: {
+            jobId: input.options.jobId,
+            runId: input.options.runId,
+            expertKey: input.expertKey,
+            input: { text: input.query },
+            experts,
+            model,
+            providerConfig,
+            temperature: input.options.temperature ?? perstackConfig.temperature,
+            maxSteps: input.options.maxSteps ?? perstackConfig.maxSteps,
+            maxRetries: input.options.maxRetries ?? perstackConfig.maxRetries,
+            timeout: input.options.timeout ?? perstackConfig.timeout,
+            perstackApiBaseUrl: perstackConfig.perstackApiBaseUrl,
+            perstackApiKey: env.PERSTACK_API_KEY,
+            perstackBaseSkillCommand: perstackConfig.perstackBaseSkillCommand,
+            env,
+            proxyUrl: process.env.PERSTACK_PROXY_URL,
+          },
+        },
+        { eventListener: defaultEventListener, storeCheckpoint, retrieveCheckpoint },
+      )
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(error.message)
+      } else {
+        console.error(error)
+      }
+      process.exit(1)
+    }
+  })
+
+program.parse()

package/dist/bin/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/cli.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+import { package_default, run } from '../chunk-C7AFEVYF.js';
+import { parseWithFriendlyError, runCommandInputSchema, perstackConfigSchema } from '@perstack/core';
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+import { readFile } from 'fs/promises';
+import path from 'path';
+import TOML from 'smol-toml';
+
+function getEnv(envPath) {
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter(([_, value]) => !!value).map(([key, value]) => [key, value])
+  );
+  dotenv.config({ path: envPath, processEnv: env, quiet: true });
+  return env;
+}
+async function getPerstackConfig(configPath) {
+  const configString = await findPerstackConfigString(configPath);
+  if (configString === null) {
+    throw new Error("perstack.toml not found. Create one or specify --config path.");
+  }
+  return await parsePerstackConfig(configString);
+}
+async function findPerstackConfigString(configPath) {
+  if (configPath) {
+    try {
+      const tomlString = await readFile(path.resolve(process.cwd(), configPath), "utf-8");
+      return tomlString;
+    } catch {
+      throw new Error(`Given config path "${configPath}" is not found`);
+    }
+  }
+  return await findPerstackConfigStringRecursively(path.resolve(process.cwd()));
+}
+async function findPerstackConfigStringRecursively(cwd) {
+  try {
+    const tomlString = await readFile(path.resolve(cwd, "perstack.toml"), "utf-8");
+    return tomlString;
+  } catch {
+    if (cwd === path.parse(cwd).root) {
+      return null;
+    }
+    return await findPerstackConfigStringRecursively(path.dirname(cwd));
+  }
+}
+async function parsePerstackConfig(config) {
+  const toml = TOML.parse(config ?? "");
+  return parseWithFriendlyError(perstackConfigSchema, toml, "perstack.toml");
+}
+
+// src/cli/provider-config.ts
+function getProviderConfig(provider, env, providerTable) {
+  const setting = providerTable?.setting ?? {};
+  switch (provider) {
+    case "anthropic": {
+      const apiKey = env.ANTHROPIC_API_KEY;
+      if (!apiKey) throw new Error("ANTHROPIC_API_KEY is not set");
+      return {
+        providerName: "anthropic",
+        apiKey,
+        baseUrl: setting.baseUrl ?? env.ANTHROPIC_BASE_URL,
+        headers: setting.headers
+      };
+    }
+    case "google": {
+      const apiKey = env.GOOGLE_GENERATIVE_AI_API_KEY;
+      if (!apiKey) throw new Error("GOOGLE_GENERATIVE_AI_API_KEY is not set");
+      return {
+        providerName: "google",
+        apiKey,
+        baseUrl: setting.baseUrl ?? env.GOOGLE_GENERATIVE_AI_BASE_URL,
+        headers: setting.headers
+      };
+    }
+    case "openai": {
+      const apiKey = env.OPENAI_API_KEY;
+      if (!apiKey) throw new Error("OPENAI_API_KEY is not set");
+      return {
+        providerName: "openai",
+        apiKey,
+        baseUrl: setting.baseUrl ?? env.OPENAI_BASE_URL,
+        organization: setting.organization ?? env.OPENAI_ORGANIZATION,
+        project: setting.project ?? env.OPENAI_PROJECT,
+        name: setting.name,
+        headers: setting.headers
+      };
+    }
+    case "ollama": {
+      return {
+        providerName: "ollama",
+        baseUrl: setting.baseUrl ?? env.OLLAMA_BASE_URL,
+        headers: setting.headers
+      };
+    }
+    case "azure-openai": {
+      const apiKey = env.AZURE_API_KEY;
+      if (!apiKey) throw new Error("AZURE_API_KEY is not set");
+      const resourceName = setting.resourceName ?? env.AZURE_RESOURCE_NAME;
+      const baseUrl = setting.baseUrl ?? env.AZURE_BASE_URL;
+      if (!resourceName && !baseUrl) throw new Error("AZURE_RESOURCE_NAME or baseUrl is not set");
+      return {
+        providerName: "azure-openai",
+        apiKey,
+        resourceName,
+        apiVersion: setting.apiVersion ?? env.AZURE_API_VERSION,
+        baseUrl,
+        headers: setting.headers,
+        useDeploymentBasedUrls: setting.useDeploymentBasedUrls
+      };
+    }
+    case "amazon-bedrock": {
+      const accessKeyId = env.AWS_ACCESS_KEY_ID;
+      const secretAccessKey = env.AWS_SECRET_ACCESS_KEY;
+      const sessionToken = env.AWS_SESSION_TOKEN;
+      if (!accessKeyId) throw new Error("AWS_ACCESS_KEY_ID is not set");
+      if (!secretAccessKey) throw new Error("AWS_SECRET_ACCESS_KEY is not set");
+      const region = setting.region ?? env.AWS_REGION;
+      if (!region) throw new Error("AWS_REGION is not set");
+      return {
+        providerName: "amazon-bedrock",
+        accessKeyId,
+        secretAccessKey,
+        region,
+        sessionToken
+      };
+    }
+    case "google-vertex": {
+      return {
+        providerName: "google-vertex",
+        project: setting.project ?? env.GOOGLE_VERTEX_PROJECT,
+        location: setting.location ?? env.GOOGLE_VERTEX_LOCATION,
+        baseUrl: setting.baseUrl ?? env.GOOGLE_VERTEX_BASE_URL,
+        headers: setting.headers
+      };
+    }
+    case "deepseek": {
+      const apiKey = env.DEEPSEEK_API_KEY;
+      if (!apiKey) throw new Error("DEEPSEEK_API_KEY is not set");
+      return {
+        providerName: "deepseek",
+        apiKey,
+        baseUrl: setting.baseUrl ?? env.DEEPSEEK_BASE_URL,
+        headers: setting.headers
+      };
+    }
+  }
+}
+
+// src/cli/context.ts
+var defaultProvider = "anthropic";
+var defaultModel = "claude-sonnet-4-5";
+async function resolveRunContext(input) {
+  const perstackConfig = await getPerstackConfig(input.configPath);
+  const env = getEnv(input.envPath ?? perstackConfig.envPath ?? [".env", ".env.local"]);
+  const provider = input.provider ?? perstackConfig.provider?.providerName ?? defaultProvider;
+  const model = input.model ?? perstackConfig.model ?? defaultModel;
+  const providerConfig = getProviderConfig(provider, env, perstackConfig.provider);
+  const experts = Object.fromEntries(
+    Object.entries(perstackConfig.experts ?? {}).map(([name, expert]) => {
+      return [
+        name,
+        {
+          key: name,
+          name,
+          version: expert.version ?? "1.0.0",
+          description: expert.description,
+          instruction: expert.instruction,
+          skills: expert.skills ?? {},
+          delegates: expert.delegates ?? [],
+          tags: expert.tags ?? []
+        }
+      ];
+    })
+  );
+  return {
+    perstackConfig,
+    env,
+    providerConfig,
+    model,
+    experts
+  };
+}
+
+// bin/cli.ts
+var defaultEventListener = (event) => console.log(JSON.stringify(event));
+var checkpointStore = /* @__PURE__ */ new Map();
+var storeCheckpoint = async (checkpoint) => {
+  checkpointStore.set(checkpoint.id, checkpoint);
+};
+var retrieveCheckpoint = async (_jobId, checkpointId) => {
+  const checkpoint = checkpointStore.get(checkpointId);
+  if (!checkpoint) {
+    throw new Error(`Checkpoint not found: ${checkpointId}`);
+  }
+  return checkpoint;
+};
+var program = new Command().name("perstack-runtime").description("Perstack Runtime CLI - Execute Experts directly").version(package_default.version);
+program.command("run").description("Run an Expert with JSON event output").argument("<expertKey>", "Expert key to run").argument("<query>", "Query to run").option("--config <configPath>", "Path to perstack.toml config file").option("--provider <provider>", "Provider to use").option("--model <model>", "Model to use").option("--temperature <temperature>", "Temperature for the model, default is 0.3").option(
+  "--max-steps <maxSteps>",
+  "Maximum number of steps to run, default is undefined (no limit)"
+).option("--max-retries <maxRetries>", "Maximum number of generation retries, default is 5").option(
+  "--timeout <timeout>",
+  "Timeout for each generation in milliseconds, default is 60000 (1 minute)"
+).option("--job-id <jobId>", "Job ID for identifying the job").option("--run-id <runId>", "Run ID for identifying the run").option("--env-path <envPath...>", "Path to the environment file, default is .env and .env.local").option("--verbose", "Enable verbose logging").action(async (expertKey, query, options) => {
+  const input = parseWithFriendlyError(runCommandInputSchema, { expertKey, query, options });
+  try {
+    const { perstackConfig, env, providerConfig, model, experts } = await resolveRunContext({
+      configPath: input.options.config,
+      provider: input.options.provider,
+      model: input.options.model,
+      envPath: input.options.envPath
+    });
+    await run(
+      {
+        setting: {
+          jobId: input.options.jobId,
+          runId: input.options.runId,
+          expertKey: input.expertKey,
+          input: { text: input.query },
+          experts,
+          model,
+          providerConfig,
+          temperature: input.options.temperature ?? perstackConfig.temperature,
+          maxSteps: input.options.maxSteps ?? perstackConfig.maxSteps,
+          maxRetries: input.options.maxRetries ?? perstackConfig.maxRetries,
+          timeout: input.options.timeout ?? perstackConfig.timeout,
+          perstackApiBaseUrl: perstackConfig.perstackApiBaseUrl,
+          perstackApiKey: env.PERSTACK_API_KEY,
+          perstackBaseSkillCommand: perstackConfig.perstackBaseSkillCommand,
+          env,
+          proxyUrl: process.env.PERSTACK_PROXY_URL
+        }
+      },
+      { eventListener: defaultEventListener, storeCheckpoint, retrieveCheckpoint }
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map