reallink-cli 0.1.13 → 0.1.14

package/README.md

@@ -75,6 +75,9 @@ reallink tool register --manifest ./spec/tools/trace-placeholder.tool.jsonc
 reallink tool publish --tool-id trace.placeholder --channel ga --visibility public
 reallink tool enable --tool-id trace.placeholder --project-id prj_xxx
 reallink tool enable --tool-id trace.placeholder --user-id usr_xxx
+reallink tool context put --context-id aa-main --project-id prj_xxx --text "Build notes and constraints"
+reallink tool context get --context-id aa-main --project-id prj_xxx
+reallink tool prompt --tool-id agent.chat --project-id prj_xxx --prompt "Summarize latest trace findings" --session-key aa-main
 reallink tool run --tool-id trace.placeholder --project-id prj_xxx --input-file ./run-input.jsonc --idempotency-key run-001
 reallink tool runs --project-id prj_xxx
 reallink tool get-run --run-id trun_xxx
@@ -104,7 +107,8 @@ reallink link plugin install --project-id prj_xxx --name RealLinkUnreal --url ht
 - If the server rejects `tools:*` as invalid, CLI automatically retries with compatible scopes.
 - You can always pass explicit scopes via repeated `--scope`.
 
-`tool register`, `tool enable/disable` metadata, and `tool run --input-file` accept JSONC.
+`tool register`, `tool enable/disable` metadata, `tool run --input-file`, and `tool prompt --input-file` accept JSONC.
+`tool context put --text-file` accepts plain UTF-8 text files and stores scoped context via API gateway.
 
 ## Session Behavior
 

package/bin/reallink.cjs

@@ -34,8 +34,15 @@ function runBinary(binaryPath) {
   });
 }
 
+function resolvePreferredBinary() {
+  if (fs.existsSync(prebuiltBinaryPath)) {
+    return prebuiltBinaryPath;
+  }
+  return resolveExistingReleaseBinary();
+}
+
 function ensureBinary() {
-  if (resolveExistingReleaseBinary() || fs.existsSync(prebuiltBinaryPath)) {
+  if (resolvePreferredBinary()) {
     return true;
   }
 
@@ -56,14 +63,14 @@ function ensureBinary() {
     return false;
   }
 
-  return build.status === 0 && !!resolveExistingReleaseBinary();
+  return build.status === 0 && !!resolvePreferredBinary();
 }
 
 if (!ensureBinary()) {
   process.exit(1);
 }
 
-const binaryPath = resolveExistingReleaseBinary() || prebuiltBinaryPath;
+const binaryPath = resolvePreferredBinary();
 const result = runBinary(binaryPath);
 if (result.error) {
   console.error(`Failed to run reallink binary: ${result.error.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reallink-cli",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Rust-based CLI for Reallink auth and API operations",
   "bin": {
     "reallink": "bin/reallink.cjs"

package/rust/Cargo.lock

@@ -993,7 +993,7 @@ dependencies = [
 
 [[package]]
 name = "reallink-cli"
-version = "0.1.13"
+version = "0.1.14"
 dependencies = [
  "anyhow",
  "clap",

package/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reallink-cli"
-version = "0.1.13"
+version = "0.1.14"
 edition = "2021"
 description = "CLI for Reallink auth and token workflows"
 license = "MIT"

package/rust/src/main.rs

@@ -82,6 +82,10 @@ enum Commands {
         #[command(subcommand)]
         command: FileCommands,
     },
+    Skill {
+        #[command(subcommand)]
+        command: SkillCommands,
+    },
     Tool {
         #[command(subcommand)]
         command: ToolCommands,
@@ -192,10 +196,16 @@ enum ToolCommands {
     Publish(ToolPublishArgs),
     Enable(ToolEnableArgs),
     Disable(ToolDisableArgs),
+    Context {
+        #[command(subcommand)]
+        command: ToolContextCommands,
+    },
+    Prompt(ToolPromptArgs),
     Run(ToolRunArgs),
     Runs(ToolRunsArgs),
     GetRun(ToolGetRunArgs),
     RunEvents(ToolRunEventsArgs),
+    TraceStatus(ToolTraceStatusArgs),
     Local {
         #[command(subcommand)]
         command: ToolLocalCommands,
@@ -209,6 +219,35 @@ enum ToolLocalCommands {
     CompleteRun(ToolLocalCompleteRunArgs),
 }
 
+#[derive(Subcommand)]
+enum ToolContextCommands {
+    Put(ToolContextPutArgs),
+    Get(ToolContextGetArgs),
+}
+
+#[derive(Subcommand)]
+enum SkillCommands {
+    List(ToolListArgs),
+    Register(ToolRegisterArgs),
+    Publish(ToolPublishArgs),
+    Enable(ToolEnableArgs),
+    Disable(ToolDisableArgs),
+    Context {
+        #[command(subcommand)]
+        command: ToolContextCommands,
+    },
+    Prompt(ToolPromptArgs),
+    Run(ToolRunArgs),
+    Runs(ToolRunsArgs),
+    GetRun(ToolGetRunArgs),
+    RunEvents(ToolRunEventsArgs),
+    TraceStatus(ToolTraceStatusArgs),
+    Local {
+        #[command(subcommand)]
+        command: ToolLocalCommands,
+    },
+}
+
 #[derive(Subcommand)]
 enum LogsCommands {
     Status,
@@ -478,6 +517,46 @@ struct ToolRunArgs {
     metadata_file: Option<PathBuf>,
     #[arg(long, help = "Idempotency key for deduplicating retries")]
     idempotency_key: Option<String>,
+    #[arg(long, action = ArgAction::SetTrue, help = "Wait until the run reaches a terminal state")]
+    wait: bool,
+    #[arg(long, default_value_t = 300_000, help = "Wait timeout in milliseconds")]
+    timeout_ms: u64,
+    #[arg(long, default_value_t = 1_500, help = "Polling interval in milliseconds")]
+    poll_interval_ms: u64,
+    #[arg(long)]
+    base_url: Option<String>,
+}
+
+#[derive(Args)]
+struct ToolPromptArgs {
+    #[arg(long)]
+    tool_id: String,
+    #[arg(long)]
+    prompt: String,
+    #[arg(long)]
+    org_id: Option<String>,
+    #[arg(long)]
+    project_id: Option<String>,
+    #[arg(long, help = "Optional system prompt")]
+    system_prompt: Option<String>,
+    #[arg(long, help = "Optional model hint passed to remote runtime")]
+    model: Option<String>,
+    #[arg(long, help = "Session key used by remote runtime for context restore")]
+    session_key: Option<String>,
+    #[arg(long, help = "Inline JSON object merged into tool input")]
+    input_json: Option<String>,
+    #[arg(long, help = "Path to JSON/JSONC file merged into tool input")]
+    input_file: Option<PathBuf>,
+    #[arg(long, help = "Path to JSON/JSONC metadata file")]
+    metadata_file: Option<PathBuf>,
+    #[arg(long, help = "Idempotency key for deduplicating retries")]
+    idempotency_key: Option<String>,
+    #[arg(long, action = ArgAction::SetTrue, help = "Wait until the run reaches a terminal state")]
+    wait: bool,
+    #[arg(long, default_value_t = 300_000, help = "Wait timeout in milliseconds")]
+    timeout_ms: u64,
+    #[arg(long, default_value_t = 1_500, help = "Polling interval in milliseconds")]
+    poll_interval_ms: u64,
     #[arg(long)]
     base_url: Option<String>,
 }
@@ -522,6 +601,44 @@ struct ToolRunEventsArgs {
     base_url: Option<String>,
 }
 
+#[derive(Args)]
+struct ToolTraceStatusArgs {
+    #[arg(long)]
+    project_id: String,
+    #[arg(long)]
+    limit: Option<u32>,
+    #[arg(long)]
+    base_url: Option<String>,
+}
+
+#[derive(Args)]
+struct ToolContextPutArgs {
+    #[arg(long)]
+    context_id: String,
+    #[arg(long)]
+    text: Option<String>,
+    #[arg(long, help = "Path to UTF-8 text file for context payload")]
+    text_file: Option<PathBuf>,
+    #[arg(long)]
+    org_id: Option<String>,
+    #[arg(long)]
+    project_id: Option<String>,
+    #[arg(long)]
+    base_url: Option<String>,
+}
+
+#[derive(Args)]
+struct ToolContextGetArgs {
+    #[arg(long)]
+    context_id: String,
+    #[arg(long)]
+    org_id: Option<String>,
+    #[arg(long)]
+    project_id: Option<String>,
+    #[arg(long)]
+    base_url: Option<String>,
+}
+
 #[derive(Args)]
 struct ToolLocalCatalogArgs {
     #[arg(long)]
@@ -4943,6 +5060,141 @@ async fn tool_disable_command(client: &reqwest::Client, args: ToolDisableArgs) -
     .await
 }
 
+async fn tool_prompt_command(client: &reqwest::Client, args: ToolPromptArgs) -> Result<()> {
+    let mut session = load_session()?;
+    apply_base_url_override(&mut session, args.base_url);
+
+    if args.input_json.is_some() && args.input_file.is_some() {
+        return Err(anyhow!(
+            "Provide either --input-json or --input-file, not both"
+        ));
+    }
+
+    let prompt = args.prompt.trim();
+    if prompt.is_empty() {
+        return Err(anyhow!("--prompt is required"));
+    }
+
+    let merged_input = if let Some(path) = args.input_file {
+        load_jsonc_file(&path, "tool prompt input")?
+    } else if let Some(input_json) = args.input_json {
+        parse_jsonc_str(&input_json, "tool prompt input")?
+    } else {
+        serde_json::Value::Object(serde_json::Map::new())
+    };
+    let mut input_map = parse_object_from_value(merged_input, "tool prompt input")?;
+    input_map.insert(
+        "prompt".to_string(),
+        serde_json::Value::String(prompt.to_string()),
+    );
+    if let Some(system_prompt) = args.system_prompt {
+        let normalized = system_prompt.trim();
+        if !normalized.is_empty() {
+            input_map.insert(
+                "systemPrompt".to_string(),
+                serde_json::Value::String(normalized.to_string()),
+            );
+        }
+    }
+    if let Some(model) = args.model {
+        let normalized = model.trim();
+        if !normalized.is_empty() {
+            input_map.insert(
+                "model".to_string(),
+                serde_json::Value::String(normalized.to_string()),
+            );
+        }
+    }
+    if let Some(session_key) = args.session_key {
+        let normalized = session_key.trim();
+        if !normalized.is_empty() {
+            input_map.insert(
+                "sessionKey".to_string(),
+                serde_json::Value::String(normalized.to_string()),
+            );
+        }
+    }
+
+    let mut body = serde_json::Map::new();
+    body.insert(
+        "toolId".to_string(),
+        serde_json::Value::String(args.tool_id),
+    );
+    body.insert("input".to_string(), serde_json::Value::Object(input_map));
+    if let Some(org_id) = args.org_id {
+        body.insert("orgId".to_string(), serde_json::Value::String(org_id));
+    }
+    if let Some(project_id) = args.project_id {
+        body.insert(
+            "projectId".to_string(),
+            serde_json::Value::String(project_id),
+        );
+    }
+
+    let mut metadata_map = if let Some(path) = args.metadata_file {
+        let metadata = load_jsonc_file(&path, "tool prompt metadata")?;
+        parse_object_from_value(metadata, "tool prompt metadata")?
+    } else {
+        serde_json::Map::new()
+    };
+    if let Some(idempotency_key) = args.idempotency_key {
+        let normalized = idempotency_key.trim();
+        if !normalized.is_empty() {
+            metadata_map.insert(
+                "idempotencyKey".to_string(),
+                serde_json::Value::String(normalized.to_string()),
+            );
+        }
+    }
+    metadata_map.insert(
+        "clientCommand".to_string(),
+        serde_json::Value::String("tool.prompt".to_string()),
+    );
+    if !metadata_map.is_empty() {
+        body.insert(
+            "metadata".to_string(),
+            serde_json::Value::Object(metadata_map),
+        );
+    }
+
+    let response = authed_request(
+        client,
+        &mut session,
+        Method::POST,
+        "/tools/runs",
+        Some(serde_json::Value::Object(body)),
+    )
+    .await?;
+    if !response.status().is_success() {
+        let body = read_error_body(response).await;
+        return Err(anyhow!("tool prompt failed: {}", body));
+    }
+    let payload: serde_json::Value = response.json().await?;
+    let payload = if args.wait {
+        let run_id = payload
+            .get("run")
+            .and_then(|run| run.get("id"))
+            .and_then(serde_json::Value::as_str)
+            .ok_or_else(|| anyhow!("tool prompt response missing run.id"))?;
+        wait_for_tool_run_completion(
+            client,
+            &mut session,
+            run_id,
+            args.timeout_ms,
+            args.poll_interval_ms,
+        )
+        .await?
+    } else {
+        payload
+    };
+    println!(
+        "{}",
+        serde_json::to_string_pretty(payload.get("run").unwrap_or(&payload))?
+    );
+    save_session(&session)?;
+    Ok(())
+}
+
 async fn tool_run_command(client: &reqwest::Client, args: ToolRunArgs) -> Result<()> {
     let mut session = load_session()?;
     apply_base_url_override(&mut session, args.base_url);
@@ -5014,6 +5266,23 @@ async fn tool_run_command(client: &reqwest::Client, args: ToolRunArgs) -> Result
         return Err(anyhow!("tool run failed: {}", body));
     }
     let payload: serde_json::Value = response.json().await?;
+    let payload = if args.wait {
+        let run_id = payload
+            .get("run")
+            .and_then(|run| run.get("id"))
+            .and_then(serde_json::Value::as_str)
+            .ok_or_else(|| anyhow!("tool run response missing run.id"))?;
+        wait_for_tool_run_completion(
+            client,
+            &mut session,
+            run_id,
+            args.timeout_ms,
+            args.poll_interval_ms,
+        )
+        .await?
+    } else {
+        payload
+    };
     println!(
         "{}",
         serde_json::to_string_pretty(payload.get("run").unwrap_or(&payload))?
@@ -5022,6 +5291,42 @@ async fn tool_run_command(client: &reqwest::Client, args: ToolRunArgs) -> Result
     Ok(())
 }
 
+async fn wait_for_tool_run_completion(
+    client: &reqwest::Client,
+    session: &mut SessionConfig,
+    run_id: &str,
+    timeout_ms: u64,
+    poll_interval_ms: u64,
+) -> Result<serde_json::Value> {
+    let poll_interval = Duration::from_millis(poll_interval_ms.max(250));
+    let deadline = std::time::Instant::now() + Duration::from_millis(timeout_ms.max(1_000));
+
+    loop {
+        let path = format!("/tools/runs/{}", run_id);
+        let response = authed_request(client, session, Method::GET, &path, None).await?;
+        if !response.status().is_success() {
+            let body = read_error_body(response).await;
+            return Err(anyhow!("tool wait failed: {}", body));
+        }
+        let payload: serde_json::Value = response.json().await?;
+        let status = payload
+            .get("run")
+            .and_then(|run| run.get("status"))
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or_default();
+        if matches!(status, "succeeded" | "failed" | "cancelled") {
+            return Ok(payload);
+        }
+        if std::time::Instant::now() >= deadline {
+            return Err(anyhow!(
+                "Timed out waiting for tool run {} to finish",
+                run_id
+            ));
+        }
+        sleep(poll_interval).await;
+    }
+}
+
 async fn tool_runs_command(client: &reqwest::Client, args: ToolRunsArgs) -> Result<()> {
     let mut session = load_session()?;
     apply_base_url_override(&mut session, args.base_url);
@@ -5117,6 +5422,232 @@ async fn tool_run_events_command(client: &reqwest::Client, args: ToolRunEventsAr
     Ok(())
 }
 
+fn resolve_report_url(base_url: &str, report_download_path: Option<&str>) -> Option<String> {
+    let path = report_download_path?.trim();
+    if path.is_empty() {
+        return None;
+    }
+    if path.starts_with("http://") || path.starts_with("https://") {
+        return Some(path.to_string());
+    }
+    Some(format!("{}{}", normalize_base_url(base_url), path))
+}
+
+fn extract_tool_run_report_paths(
+    run: &serde_json::Map<String, serde_json::Value>,
+    base_url: &str,
+) -> serde_json::Value {
+    let output = run
+        .get("output")
+        .and_then(|value| value.as_object())
+        .cloned()
+        .unwrap_or_default();
+
+    let report_asset_id = output
+        .get("reportHtmlAssetId")
+        .and_then(|value| value.as_str())
+        .or_else(|| output.get("reportAssetId").and_then(|value| value.as_str()));
+    let report_download_path = output
+        .get("reportHtmlDownloadPath")
+        .and_then(|value| value.as_str())
+        .or_else(|| output.get("reportDownloadPath").and_then(|value| value.as_str()));
+    let report_url = resolve_report_url(base_url, report_download_path);
+    let runtime = output
+        .get("runtime")
+        .and_then(|value| value.as_str())
+        .unwrap_or_default();
+    let workflow_mode = output
+        .get("workflowMode")
+        .and_then(|value| value.as_str())
+        .unwrap_or_default();
+    let summary = output
+        .get("summary")
+        .and_then(|value| value.as_str())
+        .unwrap_or_default();
+
+    serde_json::json!({
+        "reportAssetId": report_asset_id,
+        "reportDownloadPath": report_download_path,
+        "reportUrl": report_url,
+        "runtime": runtime,
+        "workflowMode": workflow_mode,
+        "summary": summary
+    })
+}
+
+async fn tool_trace_status_command(client: &reqwest::Client, args: ToolTraceStatusArgs) -> Result<()> {
+    let mut session = load_session()?;
+    apply_base_url_override(&mut session, args.base_url);
+
+    let limit = args.limit.unwrap_or(80).max(1);
+    let path = format!("/tools/runs?projectId={}&limit={}", args.project_id, limit);
+    let response = authed_request(client, &mut session, Method::GET, &path, None).await?;
+    if !response.status().is_success() {
+        let body = read_error_body(response).await;
+        return Err(anyhow!("tool trace-status failed: {}", body));
+    }
+    let payload: serde_json::Value = response.json().await?;
+    let runs = payload
+        .get("runs")
+        .and_then(|value| value.as_array())
+        .cloned()
+        .unwrap_or_default();
+
+    let mut items: Vec<serde_json::Value> = Vec::new();
+    for run in &runs {
+        let Some(run_obj) = run.as_object() else {
+            continue;
+        };
+        let tool_id = run_obj
+            .get("toolId")
+            .and_then(|value| value.as_str())
+            .unwrap_or_default()
+            .to_string();
+        let normalized_tool_id = tool_id.to_ascii_lowercase();
+        if !normalized_tool_id.starts_with("trace") && !normalized_tool_id.starts_with("crash") {
+            continue;
+        }
+
+        let run_id = run_obj
+            .get("id")
+            .and_then(|value| value.as_str())
+            .unwrap_or_default();
+        let status = run_obj
+            .get("status")
+            .and_then(|value| value.as_str())
+            .unwrap_or_default();
+        let created_at = run_obj
+            .get("createdAt")
+            .and_then(|value| value.as_str())
+            .unwrap_or_default();
+        let completed_at = run_obj
+            .get("completedAt")
+            .and_then(|value| value.as_str())
+            .unwrap_or_default();
+        let error_message = run_obj
+            .get("errorMessage")
+            .and_then(|value| value.as_str())
+            .unwrap_or_default();
+        let report = extract_tool_run_report_paths(run_obj, &session.base_url);
+
+        items.push(serde_json::json!({
+            "runId": run_id,
+            "toolId": tool_id,
+            "status": status,
+            "createdAt": created_at,
+            "completedAt": if completed_at.is_empty() { serde_json::Value::Null } else { serde_json::Value::String(completed_at.to_string()) },
+            "errorMessage": if error_message.is_empty() { serde_json::Value::Null } else { serde_json::Value::String(error_message.to_string()) },
+            "report": report
+        }));
+    }
+
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&serde_json::json!({
+            "projectId": args.project_id,
+            "count": items.len(),
+            "items": items
+        }))?
+    );
+    save_session(&session)?;
+    Ok(())
+}
+
+fn build_tool_context_path(
+    context_id: &str,
+    org_id: Option<&str>,
+    project_id: Option<&str>,
+) -> Result<String> {
+    if org_id.is_some() && project_id.is_some() {
+        return Err(anyhow!("Only one of --org-id or --project-id can be set"));
+    }
+    let normalized_context_id = context_id.trim();
+    if normalized_context_id.is_empty() {
+        return Err(anyhow!("--context-id is required"));
+    }
+
+    let mut path = format!("/tools/runtime/contexts/{}", normalized_context_id);
+    let mut query_parts: Vec<String> = Vec::new();
+    if let Some(org_id) = org_id {
+        let normalized = org_id.trim();
+        if !normalized.is_empty() {
+            query_parts.push(format!("orgId={}", normalized));
+        }
+    }
+    if let Some(project_id) = project_id {
+        let normalized = project_id.trim();
+        if !normalized.is_empty() {
+            query_parts.push(format!("projectId={}", normalized));
+        }
+    }
+    if !query_parts.is_empty() {
+        path.push_str(&format!("?{}", query_parts.join("&")));
+    }
+    Ok(path)
+}
+
+async fn tool_context_put_command(client: &reqwest::Client, args: ToolContextPutArgs) -> Result<()> {
+    let mut session = load_session()?;
+    apply_base_url_override(&mut session, args.base_url);
+
+    if args.text.is_some() && args.text_file.is_some() {
+        return Err(anyhow!("Provide either --text or --text-file, not both"));
+    }
+    let context_text = if let Some(text_file) = args.text_file {
+        fs::read_to_string(&text_file)
+            .with_context(|| format!("Failed to read context text file {}", text_file.display()))?
+    } else {
+        args.text.unwrap_or_default()
+    };
+    if context_text.trim().is_empty() {
+        return Err(anyhow!("Context text is required (--text or --text-file)"));
+    }
+
+    let path = build_tool_context_path(
+        &args.context_id,
+        args.org_id.as_deref(),
+        args.project_id.as_deref(),
+    )?;
+    let response = authed_request(
+        client,
+        &mut session,
+        Method::PUT,
+        &path,
+        Some(serde_json::json!({
+            "text": context_text
+        })),
+    )
+    .await?;
+    if !response.status().is_success() {
+        let body = read_error_body(response).await;
+        return Err(anyhow!("tool context put failed: {}", body));
+    }
+    let payload: serde_json::Value = response.json().await?;
+    println!("{}", serde_json::to_string_pretty(&payload)?);
+    save_session(&session)?;
+    Ok(())
+}
+
+async fn tool_context_get_command(client: &reqwest::Client, args: ToolContextGetArgs) -> Result<()> {
+    let mut session = load_session()?;
+    apply_base_url_override(&mut session, args.base_url);
+
+    let path = build_tool_context_path(
+        &args.context_id,
+        args.org_id.as_deref(),
+        args.project_id.as_deref(),
+    )?;
+    let response = authed_request(client, &mut session, Method::GET, &path, None).await?;
+    if !response.status().is_success() {
+        let body = read_error_body(response).await;
+        return Err(anyhow!("tool context get failed: {}", body));
+    }
+    let payload: serde_json::Value = response.json().await?;
+    println!("{}", serde_json::to_string_pretty(&payload)?);
+    save_session(&session)?;
+    Ok(())
+}
+
 async fn tool_local_catalog_command(client: &reqwest::Client, args: ToolLocalCatalogArgs) -> Result<()> {
     let mut session = load_session()?;
     apply_base_url_override(&mut session, args.base_url);
@@ -5741,16 +6272,46 @@ async fn run_cli(cli: Cli) -> Result<()> {
             FileCommands::Rmdir(args) => file_rmdir_command(&client, args).await?,
             FileCommands::Remove(args) => file_remove_command(&client, args).await?,
         },
+        Commands::Skill { command } => match command {
+            SkillCommands::List(args) => tool_list_command(&client, args).await?,
+            SkillCommands::Register(args) => tool_register_command(&client, args).await?,
+            SkillCommands::Publish(args) => tool_publish_command(&client, args).await?,
+            SkillCommands::Enable(args) => tool_enable_command(&client, args).await?,
+            SkillCommands::Disable(args) => tool_disable_command(&client, args).await?,
+            SkillCommands::Context { command } => match command {
+                ToolContextCommands::Put(args) => tool_context_put_command(&client, args).await?,
+                ToolContextCommands::Get(args) => tool_context_get_command(&client, args).await?,
+            },
+            SkillCommands::Prompt(args) => tool_prompt_command(&client, args).await?,
+            SkillCommands::Run(args) => tool_run_command(&client, args).await?,
+            SkillCommands::Runs(args) => tool_runs_command(&client, args).await?,
+            SkillCommands::GetRun(args) => tool_get_run_command(&client, args).await?,
+            SkillCommands::RunEvents(args) => tool_run_events_command(&client, args).await?,
+            SkillCommands::TraceStatus(args) => tool_trace_status_command(&client, args).await?,
+            SkillCommands::Local { command } => match command {
+                ToolLocalCommands::Catalog(args) => tool_local_catalog_command(&client, args).await?,
+                ToolLocalCommands::Install(args) => tool_local_install_command(&client, args).await?,
+                ToolLocalCommands::CompleteRun(args) => {
+                    tool_local_complete_run_command(&client, args).await?
+                }
+            },
+        },
         Commands::Tool { command } => match command {
             ToolCommands::List(args) => tool_list_command(&client, args).await?,
             ToolCommands::Register(args) => tool_register_command(&client, args).await?,
             ToolCommands::Publish(args) => tool_publish_command(&client, args).await?,
             ToolCommands::Enable(args) => tool_enable_command(&client, args).await?,
             ToolCommands::Disable(args) => tool_disable_command(&client, args).await?,
+            ToolCommands::Context { command } => match command {
+                ToolContextCommands::Put(args) => tool_context_put_command(&client, args).await?,
+                ToolContextCommands::Get(args) => tool_context_get_command(&client, args).await?,
+            },
+            ToolCommands::Prompt(args) => tool_prompt_command(&client, args).await?,
             ToolCommands::Run(args) => tool_run_command(&client, args).await?,
             ToolCommands::Runs(args) => tool_runs_command(&client, args).await?,
             ToolCommands::GetRun(args) => tool_get_run_command(&client, args).await?,
             ToolCommands::RunEvents(args) => tool_run_events_command(&client, args).await?,
+            ToolCommands::TraceStatus(args) => tool_trace_status_command(&client, args).await?,
             ToolCommands::Local { command } => match command {
                 ToolLocalCommands::Catalog(args) => tool_local_catalog_command(&client, args).await?,
                 ToolLocalCommands::Install(args) => tool_local_install_command(&client, args).await?,