@invokehq/cli 0.2.5 → 0.2.7

package/agentify.py

@@ -1165,6 +1165,18 @@ def sample_sdk_source() -> str:
 def init_command(args: argparse.Namespace) -> int:
     root = Path(args.name)
     project_name = root.name
+
+    if args.template == "claude-agent":
+        from invoke.deploy import copy_template
+
+        path = copy_template(root, force=args.force)
+        print(f"Created Claude Agent SDK project at {path}")
+        print("Next:")
+        print(f"  cd {path}")
+        print("  npm install")
+        print("  invoke deploy --dry-run")
+        return 0
+
     if root.exists() and any(root.iterdir()) and not args.force:
         raise ValueError(f"{root} already exists and is not empty. Pass --force to write into it.")
     root.mkdir(parents=True, exist_ok=True)
@@ -1214,6 +1226,25 @@ def read_project(root: Path) -> dict[str, Any]:
     return config
 
 
+def read_project_config(root: Path) -> dict[str, Any]:
+    config_path = root / "invoke.json"
+    if not config_path.exists():
+        return {}
+    config = load_json_file(config_path, {})
+    if not isinstance(config, dict):
+        raise ValueError("invoke.json must contain an object")
+    return config
+
+
+def is_agent_project(config: dict[str, Any]) -> bool:
+    runtime = str(config.get("runtime") or "").lower()
+    agent_type = str(config.get("agent_type") or config.get("type") or "").lower()
+    return bool(config.get("entrypoint")) and (
+        runtime in {"node", "python", "claude-agent-sdk"}
+        or agent_type in {"agent", "claude-agent", "claude-agent-sdk"}
+    )
+
+
 def project_mcp_url(root: Path, config: dict[str, Any], explicit_mcp_url: str | None = None) -> str | None:
     if explicit_mcp_url:
         return explicit_mcp_url
@@ -1371,6 +1402,34 @@ def save_deployment(record: dict[str, Any]) -> None:
 
 def deploy_command(args: argparse.Namespace) -> int:
     root = Path(args.path)
+    raw_config = read_project_config(root)
+    if is_agent_project(raw_config):
+        from dataclasses import asdict
+
+        from invoke.deploy import deploy_claude_agent
+
+        result = deploy_claude_agent(
+            root,
+            app_name=args.slug or raw_config.get("slug") or raw_config.get("name"),
+            dry_run=args.dry_run,
+        )
+        record = {
+            "project": str(root.resolve()),
+            "name": result.plan.app_name,
+            "provider_id": result.deployment_id,
+            "slug": result.plan.app_name,
+            "gateway_url": result.modal_app_name,
+            "base_url": "modal",
+            "tools": ["agent.run"],
+            "deployed_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+            "mode": "modal_agent",
+            "trace_path": result.trace_path,
+        }
+        if not args.dry_run:
+            save_deployment(record)
+        print(json.dumps({"success": result.success, "mode": "modal_agent", **asdict(result)}, indent=2))
+        return 0
+
     config = read_project(root)
     tools = config["tools"]
     mcp_url = project_mcp_url(root, config, args.mcp_url)
@@ -1773,7 +1832,7 @@ def build_parser() -> argparse.ArgumentParser:
 
     init = subparsers.add_parser("init", help="Scaffold an Invoke project.")
     init.add_argument("name", help="Project directory/name.")
-    init.add_argument("--template", choices=["default", "linear", "crm-guardrail"], default="default")
+    init.add_argument("--template", choices=["default", "linear", "crm-guardrail", "claude-agent"], default="default")
     init.add_argument("--force", action="store_true", help="Write into an existing non-empty directory.")
     init.set_defaults(func=init_command)
 

package/invoke/__init__.py

@@ -0,0 +1,5 @@
+"""Invoke agent deployment and supervision primitives."""
+
+from .deploy import DeployPlan, DeployResult, deploy_claude_agent
+
+__all__ = ["DeployPlan", "DeployResult", "deploy_claude_agent"]

package/invoke/deploy.py

@@ -0,0 +1,229 @@
+"""Modal-backed deployment planning for Claude Agent SDK projects.
+
+This module is intentionally small and import-safe. The public CLI can call
+`deploy_claude_agent(path)` without importing Modal unless the caller actually
+wants to deploy. That lets the local CLI stay lightweight while giving us a
+real place to evolve hosted agent deployment.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import json
+import os
+import shutil
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .onyx.analyzer import OnyxSuggestion, analyze_traces
+from .supervisor.monitor import TraceStore, build_boot_trace
+
+
+DEFAULT_ENTRYPOINTS = ("src/index.ts", "src/index.js", "index.ts", "index.js")
+DEFAULT_MODAL_IMAGE = "invoke/claude-agent-sdk:latest"
+
+
+@dataclass
+class DeployPlan:
+    """A concrete deployment plan for one agent project."""
+
+    project_root: str
+    app_name: str
+    entrypoint: str
+    modal_volume: str
+    modal_image: str = DEFAULT_MODAL_IMAGE
+    env: dict[str, str] = field(default_factory=dict)
+    tracing_enabled: bool = True
+    persistence: dict[str, str] = field(default_factory=dict)
+    robustness: dict[str, bool] = field(default_factory=dict)
+
+
+@dataclass
+class DeployResult:
+    """Result returned by a deploy attempt or dry run."""
+
+    success: bool
+    plan: DeployPlan
+    deployment_id: str
+    status: str
+    message: str
+    modal_app_name: str | None = None
+    trace_path: str | None = None
+    onyx_suggestions: list[OnyxSuggestion] = field(default_factory=list)
+
+
+def slugify(value: str) -> str:
+    cleaned = "".join(ch.lower() if ch.isalnum() else "-" for ch in value)
+    return "-".join(part for part in cleaned.split("-") if part) or "invoke-agent"
+
+
+def now_iso() -> str:
+    return dt.datetime.now(dt.timezone.utc).isoformat()
+
+
+def load_project_config(project_root: Path) -> dict[str, Any]:
+    for name in ("invoke.json", "agent.json", "package.json"):
+        path = project_root / name
+        if path.exists():
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSON in {path}: {exc}") from exc
+            if isinstance(data, dict):
+                return data
+    return {}
+
+
+def infer_entrypoint(project_root: Path, config: dict[str, Any]) -> str:
+    configured = config.get("entrypoint") or config.get("main")
+    candidates = (str(configured),) if configured else DEFAULT_ENTRYPOINTS
+    for candidate in candidates:
+        if candidate and (project_root / candidate).exists():
+            return candidate
+    raise FileNotFoundError(
+        "Could not find an agent entrypoint. Expected one of: "
+        + ", ".join(DEFAULT_ENTRYPOINTS)
+        + ". You can also set `entrypoint` in invoke.json."
+    )
+
+
+def build_deploy_plan(project_path: str | Path, *, app_name: str | None = None) -> DeployPlan:
+    project_root = Path(project_path).expanduser().resolve()
+    if not project_root.exists() or not project_root.is_dir():
+        raise FileNotFoundError(f"Agent project does not exist: {project_root}")
+
+    config = load_project_config(project_root)
+    inferred_name = app_name or config.get("name") or project_root.name
+    slug = slugify(str(inferred_name))
+    entrypoint = infer_entrypoint(project_root, config)
+
+    env_keys = [
+        "ANTHROPIC_API_KEY",
+        "OPENAI_API_KEY",
+        "INVOKE_API_KEY",
+        "INVOKE_BASE_URL",
+    ]
+    env = {key: os.environ[key] for key in env_keys if os.environ.get(key)}
+
+    return DeployPlan(
+        project_root=str(project_root),
+        app_name=slug,
+        entrypoint=entrypoint,
+        modal_volume=f"{slug}-state",
+        env=env,
+        persistence={
+            "kind": "modal_volume",
+            "mount_path": "/state",
+            "trace_path": "/state/traces.jsonl",
+            "checkpoint_path": "/state/checkpoints.jsonl",
+        },
+        robustness={
+            "schema_checks": True,
+            "policy_checks": True,
+            "state_reconciliation": True,
+            "freeze_thaw_hitl": True,
+            "structured_tracing": True,
+        },
+    )
+
+
+def write_local_deploy_record(result: DeployResult) -> Path:
+    root = Path(result.plan.project_root)
+    state_dir = root / ".invoke"
+    state_dir.mkdir(parents=True, exist_ok=True)
+    path = state_dir / "deployment.json"
+    path.write_text(json.dumps(asdict(result), indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return path
+
+
+def copy_template(destination: str | Path, *, force: bool = False) -> Path:
+    """Scaffold a Claude Agent SDK starter project."""
+
+    destination = Path(destination).expanduser().resolve()
+    template_root = Path(__file__).with_name("templates") / "claude-agent-sdk"
+    if destination.exists() and any(destination.iterdir()) and not force:
+        raise FileExistsError(f"{destination} is not empty. Pass force=True to overwrite template files.")
+    destination.mkdir(parents=True, exist_ok=True)
+    for source in template_root.rglob("*"):
+        target = destination / source.relative_to(template_root)
+        if source.is_dir():
+            target.mkdir(parents=True, exist_ok=True)
+            continue
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists() and not force:
+            continue
+        shutil.copyfile(source, target)
+    return destination
+
+
+def deploy_claude_agent(
+    project_path: str | Path,
+    *,
+    app_name: str | None = None,
+    dry_run: bool = False,
+    run_onyx: bool = True,
+) -> DeployResult:
+    """Build and optionally deploy a Claude Agent SDK project to Modal."""
+
+    plan = build_deploy_plan(project_path, app_name=app_name)
+    deployment_id = "dep_" + dt.datetime.now(dt.timezone.utc).strftime("%Y%m%d%H%M%S")
+
+    trace_store = TraceStore(Path(plan.project_root) / ".invoke" / "traces.jsonl")
+    boot_trace = build_boot_trace(plan.app_name, plan.entrypoint, plan.robustness)
+    trace_store.append(boot_trace)
+
+    suggestions = analyze_traces(trace_store.recent(limit=100)) if run_onyx else []
+
+    if dry_run:
+        result = DeployResult(
+            success=True,
+            plan=plan,
+            deployment_id=deployment_id,
+            status="planned",
+            message="Deployment plan generated. Modal deploy was not executed.",
+            trace_path=str(trace_store.path),
+            onyx_suggestions=suggestions,
+        )
+        write_local_deploy_record(result)
+        return result
+
+    from .sandbox import deploy_modal_app
+
+    modal_result = deploy_modal_app(plan)
+    result = DeployResult(
+        success=True,
+        plan=plan,
+        deployment_id=deployment_id,
+        status="deployed",
+        message="Agent deployed to Modal with Invoke tracing and persistence enabled.",
+        modal_app_name=modal_result.get("app_name", plan.app_name),
+        trace_path=str(trace_store.path),
+        onyx_suggestions=suggestions,
+    )
+    write_local_deploy_record(result)
+    return result
+
+
+def main() -> int:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Deploy a Claude Agent SDK project with Invoke.")
+    parser.add_argument("path", help="Agent project path.")
+    parser.add_argument("--app-name")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--template", action="store_true", help="Scaffold a starter project at path.")
+    args = parser.parse_args()
+
+    if args.template:
+        path = copy_template(args.path)
+        print(f"Created Claude Agent SDK template at {path}")
+        return 0
+
+    result = deploy_claude_agent(args.path, app_name=args.app_name, dry_run=args.dry_run)
+    print(json.dumps(asdict(result), indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/invoke/onyx/__init__.py

@@ -0,0 +1,5 @@
+"""Onyx Lite trace analyzer."""
+
+from .analyzer import OnyxSuggestion, analyze_traces
+
+__all__ = ["OnyxSuggestion", "analyze_traces"]

package/invoke/onyx/analyzer.py

@@ -0,0 +1,75 @@
+"""Onyx Lite: trace analysis and concrete repair suggestions."""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class OnyxSuggestion:
+    title: str
+    severity: str
+    reason: str
+    apply: dict[str, Any] = field(default_factory=dict)
+
+
+def _flatten_events(trace: dict[str, Any]) -> list[dict[str, Any]]:
+    events = trace.get("events") or trace.get("trace") or []
+    if isinstance(events, list):
+        return [event for event in events if isinstance(event, dict)]
+    return []
+
+
+def analyze_traces(traces: list[dict[str, Any]]) -> list[OnyxSuggestion]:
+    """Detect repeated failures and emit safe, concrete fixes."""
+
+    if not traces:
+        return []
+
+    outcomes = Counter(str(trace.get("final_outcome") or trace.get("status") or "unknown") for trace in traces)
+    steps = Counter(event.get("step") for trace in traces for event in _flatten_events(trace) if event.get("step"))
+    suggestions: list[OnyxSuggestion] = []
+
+    if outcomes.get("timeout") or steps.get("tool_timeout"):
+        suggestions.append(
+            OnyxSuggestion(
+                title="Add reconciliation before retry",
+                severity="high",
+                reason="Recent traces include timeout patterns where the side effect may have succeeded.",
+                apply={"retry_strategy": "reconcile_before_retry", "unknown_effect": True},
+            )
+        )
+
+    if outcomes.get("idempotent_replay") or steps.get("duplicate_retry_detected"):
+        suggestions.append(
+            OnyxSuggestion(
+                title="Require idempotency keys for this action",
+                severity="medium",
+                reason="Duplicate retry patterns were detected in recent executions.",
+                apply={"idempotency": {"mode": "required", "key_fields": ["customer_id", "amount", "action"]}},
+            )
+        )
+
+    if outcomes.get("blocked_by_policy") or steps.get("policy_evaluated"):
+        suggestions.append(
+            OnyxSuggestion(
+                title="Move policy warning into preflight",
+                severity="medium",
+                reason="Policy blocked work after planning. Warn the agent before it attempts the action.",
+                apply={"preflight": {"policy_preview": True, "risk_threshold": "medium"}},
+            )
+        )
+
+    if not suggestions:
+        suggestions.append(
+            OnyxSuggestion(
+                title="No repeated failure pattern detected",
+                severity="info",
+                reason="Recent traces do not show recurring timeout, duplicate retry, or policy-block patterns.",
+                apply={},
+            )
+        )
+
+    return suggestions

package/invoke/sandbox.py

@@ -0,0 +1,106 @@
+"""Modal sandbox definitions for hosted Invoke agents."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from .deploy import DeployPlan
+
+
+def _import_modal():
+    try:
+        import modal  # type: ignore
+    except ImportError as exc:
+        raise RuntimeError(
+            "Modal is required for hosted agent deployment. Install it with `pip install modal` "
+            "and run `modal setup`, or use `--dry-run` to inspect the deployment plan."
+        ) from exc
+    return modal
+
+
+def modal_objects(plan: DeployPlan):
+    """Return Modal app/image/volume objects for a deployment plan."""
+
+    modal = _import_modal()
+    app = modal.App(plan.app_name)
+    image = (
+        modal.Image.debian_slim(python_version="3.11")
+        .apt_install("nodejs", "npm")
+        .pip_install("anthropic", "httpx")
+        .env(plan.env)
+    )
+    volume = modal.Volume.from_name(plan.modal_volume, create_if_missing=True)
+    return modal, app, image, volume
+
+
+def deploy_modal_app(plan: DeployPlan) -> dict[str, Any]:
+    """Deploy the Modal app skeleton for one Invoke agent.
+
+    The actual Modal CLI invocation happens outside this module. This function
+    validates that Modal is importable and returns the deployable object names,
+    which lets the Python CLI remain deterministic in tests.
+    """
+
+    modal, app, image, volume = modal_objects(plan)
+    project_root = Path(plan.project_root)
+    entrypoint = plan.entrypoint
+
+    @app.function(
+        image=image,
+        volumes={"/state": volume},
+        timeout=60 * 20,
+        secrets=[],
+    )
+    def run_agent(prompt: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Run one agent task inside the Modal sandbox."""
+
+        import json
+        import subprocess
+        import time
+        import uuid
+
+        execution_id = "exec_" + uuid.uuid4().hex[:12]
+        started_at = time.time()
+        trace = {
+            "execution_id": execution_id,
+            "event": "agent_run_started",
+            "prompt": prompt,
+            "context": context or {},
+            "entrypoint": entrypoint,
+            "started_at": started_at,
+        }
+        with open("/state/traces.jsonl", "a", encoding="utf-8") as fh:
+            fh.write(json.dumps(trace, sort_keys=True) + "\n")
+
+        command = ["node", entrypoint, prompt]
+        completed = subprocess.run(
+            command,
+            cwd="/workspace",
+            text=True,
+            capture_output=True,
+            timeout=60 * 15,
+            check=False,
+        )
+        final = {
+            "execution_id": execution_id,
+            "event": "agent_run_completed",
+            "returncode": completed.returncode,
+            "stdout": completed.stdout[-8000:],
+            "stderr": completed.stderr[-8000:],
+            "latency_ms": round((time.time() - started_at) * 1000, 2),
+        }
+        with open("/state/traces.jsonl", "a", encoding="utf-8") as fh:
+            fh.write(json.dumps(final, sort_keys=True) + "\n")
+        return final
+
+    return {
+        "app_name": plan.app_name,
+        "volume": plan.modal_volume,
+        "entrypoint": plan.entrypoint,
+        "project_root": str(project_root),
+        "plan": asdict(plan),
+        "modal_app": app,
+        "modal_run_function": run_agent,
+    }

package/invoke/supervisor/__init__.py

@@ -0,0 +1,23 @@
+"""Supervision primitives for Invoke-hosted agents."""
+
+from .monitor import (
+    Checkpoint,
+    ExecutionTrace,
+    PolicyDecision,
+    TraceEvent,
+    TraceStore,
+    build_boot_trace,
+    evaluate_policy,
+    reconcile_state,
+)
+
+__all__ = [
+    "Checkpoint",
+    "ExecutionTrace",
+    "PolicyDecision",
+    "TraceEvent",
+    "TraceStore",
+    "build_boot_trace",
+    "evaluate_policy",
+    "reconcile_state",
+]

package/invoke/supervisor/monitor.py

@@ -0,0 +1,149 @@
+"""Structured tracing, policy checks, and freeze/thaw checkpoints."""
+
+from __future__ import annotations
+
+import datetime as dt
+import json
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+def utc_now() -> str:
+    return dt.datetime.now(dt.timezone.utc).isoformat()
+
+
+@dataclass
+class TraceEvent:
+    step: str
+    status: str
+    detail: dict[str, Any] = field(default_factory=dict)
+    timestamp: str = field(default_factory=utc_now)
+
+
+@dataclass
+class ExecutionTrace:
+    execution_id: str
+    agent_id: str
+    action: str
+    status: str
+    risk: str
+    events: list[TraceEvent] = field(default_factory=list)
+    final_outcome: str | None = None
+    created_at: str = field(default_factory=utc_now)
+
+
+@dataclass
+class PolicyDecision:
+    effect: str
+    risk: str
+    reason: str
+    requires_approval: bool = False
+    guardrails: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Checkpoint:
+    checkpoint_id: str
+    execution_id: str
+    action: str
+    params: dict[str, Any]
+    context_snapshot: dict[str, Any]
+    created_at: str = field(default_factory=utc_now)
+
+
+class TraceStore:
+    """Append-only JSONL trace store."""
+
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def append(self, trace: ExecutionTrace | dict[str, Any]) -> None:
+        payload = asdict(trace) if hasattr(trace, "__dataclass_fields__") else trace
+        with self.path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(payload, sort_keys=True) + "\n")
+
+    def recent(self, *, limit: int = 50) -> list[dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        lines = self.path.read_text(encoding="utf-8").splitlines()[-limit:]
+        traces: list[dict[str, Any]] = []
+        for line in lines:
+            try:
+                traces.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+        return traces
+
+
+def evaluate_policy(action: str, params: dict[str, Any]) -> PolicyDecision:
+    lowered = action.lower()
+    sql = str(params.get("sql", "")).lower()
+    if action == "database.execute" or "disable row level security" in sql or "drop table" in sql:
+        return PolicyDecision(
+            effect="block",
+            risk="high",
+            reason="Direct database execution can bypass application policy or row-level security.",
+            guardrails=["policy_block", "sandbox_required"],
+        )
+    if any(word in lowered for word in ("delete", "refund", "charge", "transfer")):
+        return PolicyDecision(
+            effect="require_approval",
+            risk="high",
+            reason="Financial or destructive action requires approval and reconciliation.",
+            requires_approval=True,
+            guardrails=["approval", "idempotency_key", "state_reconciliation"],
+        )
+    return PolicyDecision(effect="allow", risk="low", reason="No blocking policy matched.", guardrails=["trace"])
+
+
+def reconcile_state(expected: dict[str, Any], live: dict[str, Any]) -> dict[str, Any]:
+    drift = []
+    for key, expected_value in expected.items():
+        if live.get(key) != expected_value:
+            drift.append({"key": key, "expected": expected_value, "live": live.get(key)})
+    return {
+        "status": "changed" if drift else "valid",
+        "drift": drift,
+        "checked_at": utc_now(),
+    }
+
+
+def freeze_execution(execution_id: str, action: str, params: dict[str, Any], context: dict[str, Any]) -> Checkpoint:
+    return Checkpoint(
+        checkpoint_id="freeze_" + uuid.uuid4().hex[:12],
+        execution_id=execution_id,
+        action=action,
+        params=params,
+        context_snapshot=context,
+    )
+
+
+def thaw_checkpoint(checkpoint: Checkpoint, live_context: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "checkpoint_id": checkpoint.checkpoint_id,
+        "execution_id": checkpoint.execution_id,
+        "revalidation": reconcile_state(checkpoint.context_snapshot, live_context),
+        "thawed_at": utc_now(),
+    }
+
+
+def build_boot_trace(app_name: str, entrypoint: str, robustness: dict[str, bool]) -> ExecutionTrace:
+    trace = ExecutionTrace(
+        execution_id="exec_" + uuid.uuid4().hex[:12],
+        agent_id=app_name,
+        action="invoke.deploy",
+        status="planned",
+        risk="low",
+        final_outcome="deployment_plan_recorded",
+    )
+    trace.events.extend(
+        [
+            TraceEvent("project_loaded", "ok", {"entrypoint": entrypoint}),
+            TraceEvent("persistence_selected", "ok", {"kind": "modal_volume"}),
+            TraceEvent("robustness_layer_enabled", "ok", robustness),
+        ]
+    )
+    return trace

package/invoke/templates/claude-agent-sdk/invoke.json

@@ -0,0 +1,10 @@
+{
+  "name": "my-claude-agent",
+  "entrypoint": "src/index.ts",
+  "runtime": "node",
+  "tools": [],
+  "policy": {
+    "approval_required_for": ["charge", "refund", "delete", "database.execute"],
+    "block": ["database.execute"]
+  }
+}

package/invoke/templates/claude-agent-sdk/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "invoke-claude-agent",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "latest"
+  },
+  "devDependencies": {
+    "tsx": "latest",
+    "typescript": "latest"
+  }
+}

package/invoke/templates/claude-agent-sdk/src/index.ts

@@ -0,0 +1,14 @@
+import { query } from "@anthropic-ai/claude-agent-sdk"
+
+const prompt = process.argv.slice(2).join(" ") || "Summarize what this agent can do."
+
+for await (const message of query({
+  prompt,
+  options: {
+    allowedTools: [],
+  },
+})) {
+  if ("result" in message) {
+    console.log(message.result)
+  }
+}

package/invoke/templates/claude-agent-sdk/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "outDir": "dist",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invokehq/cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "CLI for Invoke, execution reliability infrastructure for AI agents.",
   "license": "Apache-2.0",
   "bin": {
@@ -10,6 +10,13 @@
   "files": [
     "agentify.py",
     "bin",
+    "invoke/*.py",
+    "invoke/onyx/*.py",
+    "invoke/supervisor/*.py",
+    "invoke/templates/claude-agent-sdk/invoke.json",
+    "invoke/templates/claude-agent-sdk/package.json",
+    "invoke/templates/claude-agent-sdk/src/index.ts",
+    "invoke/templates/claude-agent-sdk/tsconfig.json",
     "README.md",
     "pyproject.toml"
   ],

package/pyproject.toml

@@ -24,5 +24,9 @@ dev = ["build", "twine"]
 invoke = "agentify:main"
 agentify = "agentify:main"
 
-[tool.setuptools.py-modules]
-modules = ["agentify"]
+[tool.setuptools]
+py-modules = ["agentify"]
+packages = ["invoke", "invoke.onyx", "invoke.supervisor"]
+
+[tool.setuptools.package-data]
+invoke = ["templates/claude-agent-sdk/*", "templates/claude-agent-sdk/src/*"]