ark-agent-runtime 0.1.0a1__py3-none-win_amd64.whl

ark_agent_runtime-0.1.0a1.data/purelib/ark/__init__.py

@@ -0,0 +1,43 @@
+"""ARK Runtime SDK — a thin Python client over the Go ARK runtime and its canonical
+telemetry contract (RunResult / DecisionRecord). Execution, decision traces, cost
+attribution, routing info, tool activity, verification (where available), audit/
+intervention records, and (experimental, opt-in) constrained supervision.
+
+This SDK does not reimplement ARK and makes no unproven claims (e.g. automatic cost
+savings): it exposes the factual telemetry the Go runtime already produces.
+"""
+from typing import Optional
+
+from .client import ARK
+from .errors import ArkError, ArkBridgeError, ArkSupervisionDisabled
+from .session import RunSession, Verdict
+from .models import (
+    RunResult, DecisionRecord, DecisionCost, SupervisionRecord, SupervisionResult,
+    Verification, RoutingDecision, ToolDecision, SupervisionSummary, RoutingSummary, ToolSummary,
+)
+
+
+def trace(task: str, *, supervision: str = "off", task_type: Optional[str] = None,
+          provider: str = "openai", budget: int = 4) -> RunSession:
+    """Open an external-agent trace with a default client. Keep your own agent/model/tools
+    and attach ARK around your runtime:
+
+        import ark
+        with ark.trace("find the top Python web frameworks") as run:
+            ...                                  # your loop reports decisions
+        result = run.result                      # canonical RunResult
+
+    Pass supervision="experimental" to enable run.check(...) gating.
+    """
+    return ARK(supervision=supervision).trace(task, task_type=task_type,
+                                              provider=provider, budget=budget)
+
+
+__all__ = [
+    "ARK", "trace", "RunSession", "Verdict",
+    "ArkError", "ArkBridgeError", "ArkSupervisionDisabled",
+    "RunResult", "DecisionRecord", "DecisionCost", "SupervisionRecord", "SupervisionResult",
+    "Verification", "RoutingDecision", "ToolDecision",
+    "SupervisionSummary", "RoutingSummary", "ToolSummary",
+]
+__version__ = "0.1.0a1"

ark_agent_runtime-0.1.0a1.data/purelib/ark/_bridge/__init__.py

@@ -0,0 +1,8 @@
+"""Home of the bundled ARK bridge binary.
+
+At build time the platform-native `ark-bridge` (or `ark-bridge.exe`) executable is compiled
+from the Go source (cmd/ark-bridge) and placed in this directory, then shipped as package
+data inside the wheel. `ark.bridge._find_binary` locates it here, so an installed package
+needs no Go toolchain and no ARK_BRIDGE_BIN. The binary itself is a build artifact and is not
+committed to source control.
+"""

ark_agent_runtime-0.1.0a1.data/purelib/ark/bridge.py

@@ -0,0 +1,96 @@
+"""Go<->Python transport. Default: invoke the local ark-bridge binary as a subprocess.
+
+The transport is an IMPLEMENTATION DETAIL: the public ARK API does not depend on this
+being a subprocess, so it can later be replaced (e.g. a local service) without changing
+the Python API. Any object with a ``call(request: dict) -> dict`` method works.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+
+from .errors import ArkBridgeError
+
+
+def _bundled_binary() -> "str | None":
+    """The bridge shipped inside the installed wheel (ark/_bridge/ark-bridge[.exe])."""
+    name = "ark-bridge.exe" if os.name == "nt" else "ark-bridge"
+    p = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_bridge", name)
+    return p if os.path.isfile(p) else None
+
+
+def _ensure_executable(path: str) -> None:
+    """Wheels don't always preserve the +x bit for package data; restore it if missing."""
+    if os.name == "nt":
+        return
+    try:
+        mode = os.stat(path).st_mode
+        if not (mode & 0o111):
+            os.chmod(path, mode | 0o111)
+    except OSError:
+        pass
+
+
+def _find_binary() -> str:
+    # 1. explicit override — for developers/debugging (not needed by an installed package)
+    b = os.environ.get("ARK_BRIDGE_BIN")
+    if b and os.path.exists(b):
+        return b
+    # 2. the bundled bridge inside the installed wheel — the normal path, zero setup
+    bundled = _bundled_binary()
+    if bundled:
+        _ensure_executable(bundled)
+        return bundled
+    # 3. a bridge on PATH, then a source-checkout build (developer convenience)
+    p = shutil.which("ark-bridge")
+    if p:
+        return p
+    for guess in (os.path.expanduser("~/ark/ark-bridge-bin"),
+                  os.path.expanduser("~/ark/ark-bridge-test-bin")):
+        if os.path.exists(guess):
+            return guess
+    raise ArkBridgeError(
+        "ark-bridge binary not found. An installed `ark-agent-runtime` wheel bundles it "
+        "automatically; if you are running from a source checkout, build it with "
+        "`go build -o ark-bridge-bin ./cmd/ark-bridge` and set ARK_BRIDGE_BIN."
+    )
+
+
+class SubprocessBridge:
+    def __init__(self, binary: str | None = None, timeout: int = 120):
+        self._bin = binary or _find_binary()
+        self._timeout = timeout
+
+    def call(self, request: dict) -> dict:
+        try:
+            p = subprocess.run([self._bin], input=json.dumps(request).encode(),
+                               capture_output=True, timeout=self._timeout)
+        except (OSError, subprocess.TimeoutExpired) as e:
+            raise ArkBridgeError(f"bridge invocation failed: {e}") from e
+        out = (p.stdout or b"").decode().strip()
+        if not out:
+            err = (p.stderr or b"").decode()[:300]
+            raise ArkBridgeError(f"bridge produced no output (exit {p.returncode}): {err}")
+        data = _parse_json(out)
+        if data is None:
+            raise ArkBridgeError(f"bridge returned non-JSON: {out[:300]}")
+        if isinstance(data, dict) and data.get("error"):
+            raise ArkBridgeError(data["error"])
+        return data
+
+
+def _parse_json(out: str):
+    """The bridge emits a single JSON object (possibly multi-line/indented). Parse the
+    whole payload; tolerate any surrounding text by falling back to the outermost braces."""
+    try:
+        return json.loads(out)
+    except json.JSONDecodeError:
+        i, j = out.find("{"), out.rfind("}")
+        if 0 <= i < j:
+            try:
+                return json.loads(out[i:j + 1])
+            except json.JSONDecodeError:
+                return None
+        return None

ark_agent_runtime-0.1.0a1.data/purelib/ark/client.py

@@ -0,0 +1,82 @@
+"""The ARK client — the front door to the ARK runtime.
+
+    from ark import ARK
+    ark = ARK()
+    result = ark.run(task="find the top Python web frameworks on GitHub")
+    print(result.success, result.total_cost, result.decisions)
+
+Experimental constrained supervision is explicit and off by default:
+
+    ark = ARK(supervision="experimental")
+
+The Go runtime is the source of truth; this client only submits requests and parses the
+canonical RunResult. It reimplements no routing/supervision/cost/verification/retry logic.
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .bridge import SubprocessBridge
+from .errors import ArkSupervisionDisabled
+from .models import RunResult, SupervisionRecord, SupervisionResult
+from .session import RunSession
+
+
+class ARK:
+    def __init__(self, supervision: str = "off", bridge=None):
+        if supervision not in ("off", "experimental"):
+            raise ValueError("supervision must be 'off' or 'experimental'")
+        self.supervision = supervision
+        self._bridge = bridge or SubprocessBridge()
+
+    def run(self, task: Optional[str] = None, agent: Any = None, *,
+            mode: str = "mock", config: Optional[str] = None) -> RunResult:
+        """Run a task through the Go ARK runtime and return the canonical RunResult.
+
+        mode="mock" (default) runs the real runtime deterministically with no API cost;
+        mode="live" uses the provider configured in agent.yaml (needs a real key).
+        """
+        if not task and agent is None:
+            raise ValueError("run() requires a task")
+        req: dict = {"kind": "run", "task": task or "", "mode": mode, "supervision": self.supervision}
+        if isinstance(agent, str):  # agent given as a config path
+            req["config"] = agent
+        if config:
+            req["config"] = config
+        return RunResult.from_dict(self._bridge.call(req))
+
+    def trace(self, task: str, *, task_type: Optional[str] = None,
+              provider: str = "openai", budget: int = 4) -> RunSession:
+        """Open an external-agent trace: keep your own agent/model/tools and attach ARK
+        around your runtime. Use as a context manager:
+
+            with ark.trace("book the 2nd-cheapest flight") as run:
+                ...                       # your loop
+                run.record(action="tool_call", model="gpt-4o", input_tokens=..., ...)
+            result = run.result           # canonical RunResult
+
+        Supervision follows this client's setting: ARK(supervision="experimental").trace(...)
+        enables run.check(...). ARK never executes your agent — you do.
+        """
+        return RunSession(task, task_type=task_type, supervision=self.supervision,
+                          provider=provider, budget=budget)
+
+    def supervise(self, constraint: str, proposed: dict, evidence: dict,
+                  retry_count: int = 0, budget: int = 4) -> SupervisionResult:
+        """Evaluate one agent-authored action against a runtime-derived constraint.
+
+        Experimental: requires ARK(supervision="experimental"). Returns a verdict
+        (ALLOW/REJECT/REQUIRE_EVIDENCE/RECOVERY_EXHAUSTED); ARK never authors the action.
+        """
+        if self.supervision != "experimental":
+            raise ArkSupervisionDisabled(
+                "constrained supervision is experimental and off by default; "
+                "create ARK(supervision='experimental')")
+        data = self._bridge.call({
+            "kind": "supervise", "supervision": "experimental", "constraint": constraint,
+            "proposed": proposed, "evidence": evidence, "retry_count": retry_count, "budget": budget,
+        })
+        return SupervisionResult(
+            verdict=data.get("verdict"), reason=data.get("reason"),
+            record=SupervisionRecord.from_dict(data.get("supervision")),
+        )

ark_agent_runtime-0.1.0a1.data/purelib/ark/errors.py

@@ -0,0 +1,14 @@
+"""SDK error types. Runtime/bridge failures map to ArkBridgeError; using experimental
+supervision without opting in raises ArkSupervisionDisabled."""
+
+
+class ArkError(Exception):
+    """Base class for all ARK SDK errors."""
+
+
+class ArkBridgeError(ArkError):
+    """The Go bridge/runtime failed, was unreachable, or returned an error."""
+
+
+class ArkSupervisionDisabled(ArkError):
+    """Constrained supervision was used without opting in (it is experimental/off by default)."""

ark_agent_runtime-0.1.0a1.data/purelib/ark/integrations/__init__.py

@@ -0,0 +1,7 @@
+"""Framework integrations for ARK.
+
+Each integration is a THIN adapter that maps a framework's native lifecycle onto the generic
+`ark.trace()` session primitives (`run.record(...)`, `run.check(...)`). Adapters never
+reimplement routing, supervision, retries, pricing, or telemetry — those live in Go behind
+the session. Integrations import their framework lazily, so `import ark` never requires it.
+"""

ark_agent_runtime-0.1.0a1.data/purelib/ark/integrations/langgraph.py

@@ -0,0 +1,243 @@
+"""LangGraph / LangChain integration for ARK — a thin adapter over `ark.trace()`.
+
+    LangGraph lifecycle/events  ->  ARK generic trace/check/record  ->  Go ARK telemetry + supervision
+
+It maps LangChain's callback events onto the generic session and (optionally) gates proposed
+tool calls. It reimplements NOTHING — no routing, supervision, retries, pricing, or telemetry;
+every field is either reported straight from a LangChain event or derived by Go ARK. What the
+adapter can observe automatically vs. what the developer must supply:
+
+  observed automatically by the adapter (from LangChain callbacks)
+    - model calls (start/end), model name, input/output tokens  -> ARK derives cost
+    - tool calls: name, args, outcome/error, latency
+  the developer must still supply (ARK cannot infer it from the graph)
+    - which tool to supervise, the applicable constraint, and the trusted runtime evidence
+      (e.g. the retrieved, priced options) passed to `ark_supervise_tool(...)`
+
+Interception audit (LangGraph 1.x / langchain-core 1.x): LangChain callback handlers are
+OBSERVATIONAL — `on_tool_start` cannot cleanly veto an execution. The clean, framework-native
+pre-execution gate is the tool itself: a tool is a plain callable, so wrapping it lets ARK
+check the proposed action BEFORE the real logic runs and, on a non-ALLOW verdict, return the
+runtime-derived suggestion as the tool result — which LangGraph's own agent loop feeds back to
+the model to REPLAN. `ark_supervise_tool` uses exactly that; it fakes no interception.
+(`create_react_agent`'s `post_model_hook` / `interrupt_before=["tools"]` are alternative
+native gates; the tool wrapper is the thinnest and works with any graph.)
+
+Sync graphs only (the common `.invoke(...)` path); async/parallel tool fan-out is out of scope.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+try:
+    from langchain_core.callbacks import BaseCallbackHandler
+    from langchain_core.tools import BaseTool, StructuredTool
+except ModuleNotFoundError as e:  # optional dependency — give a clear, actionable message
+    raise ImportError(
+        "ARK's LangGraph integration requires the optional 'langgraph' extra. "
+        "Install it with:  pip install 'ark-agent-runtime[langgraph]'  "
+        "(or:  pip install langgraph langchain-core ). "
+        "The core ARK SDK (import ark) does not need it."
+    ) from e
+
+from ..session import RunSession, Verdict
+
+
+class ArkCallbackHandler(BaseCallbackHandler):
+    """A LangChain callback handler that reports every model/tool event to an ARK trace.
+
+        with ark.trace("...") as run:
+            agent.invoke(inputs, config={"callbacks": [ArkCallbackHandler(run)]})
+        result = run.result
+
+    Pass ``record_tools=False`` when tools are gated with :func:`ark_supervise_tool` (the
+    wrapper records those tool decisions itself, so the handler should record only the model
+    turns to avoid double-counting).
+    """
+
+    # this handler only reports; it never blocks or mutates the run.
+    raise_error = False
+
+    def __init__(self, run: RunSession, *, record_tools: bool = True):
+        self._run = run
+        self._record_tools = record_tools
+        self._llm_start: Dict[Any, float] = {}
+        self._llm_model: Dict[Any, Optional[str]] = {}
+        self._tool_start: Dict[Any, float] = {}
+        self._tool_meta: Dict[Any, Tuple[str, Optional[dict]]] = {}
+
+    # ---- model calls -> cost-bearing decisions ----
+    def on_chat_model_start(self, serialized, messages, *, run_id, **kwargs):
+        self._begin_llm(run_id, serialized, kwargs)
+
+    def on_llm_start(self, serialized, prompts, *, run_id, **kwargs):
+        self._begin_llm(run_id, serialized, kwargs)
+
+    def _begin_llm(self, run_id, serialized, kwargs):
+        self._llm_start[run_id] = time.monotonic()
+        ip = kwargs.get("invocation_params") or {}
+        name = ip.get("model") or ip.get("model_name")
+        if not name and serialized:
+            name = (serialized.get("kwargs") or {}).get("model_name") or serialized.get("name")
+        self._llm_model[run_id] = name
+
+    def on_llm_end(self, response, *, run_id, **kwargs):
+        model, in_tok, out_tok, tool_names = _llm_end_fields(response)
+        if not model:
+            model = self._llm_model.get(run_id)
+        latency_ms = _elapsed_ms(self._llm_start.pop(run_id, None))
+        self._llm_model.pop(run_id, None)
+        # a model turn that proposed tool(s) is a "model_call"; a final turn is "complete".
+        # cost is DERIVED by ARK from the reported tokens+model — the adapter computes none.
+        self._run.record(
+            action="model_call" if tool_names else "complete",
+            model=model, input_tokens=in_tok, output_tokens=out_tok,
+            latency_ms=latency_ms, outcome=("proposed_tools" if tool_names else "stop"),
+        )
+
+    def on_llm_error(self, error, *, run_id, **kwargs):
+        latency_ms = _elapsed_ms(self._llm_start.pop(run_id, None))
+        self._run.record(action="model_call", model=self._llm_model.pop(run_id, None),
+                         latency_ms=latency_ms, outcome=f"error: {type(error).__name__}",
+                         error=_err(error), executed=False)
+
+    # ---- tool executions -> tool-activity decisions (no token cost) ----
+    def on_tool_start(self, serialized, input_str, *, run_id, inputs=None, **kwargs):
+        if not self._record_tools:
+            return
+        self._tool_start[run_id] = time.monotonic()
+        name = (serialized or {}).get("name") or "tool"
+        self._tool_meta[run_id] = (name, inputs if isinstance(inputs, dict) else None)
+
+    def on_tool_end(self, output, *, run_id, **kwargs):
+        if not self._record_tools:
+            return
+        name, args = self._tool_meta.pop(run_id, ("tool", None))
+        latency_ms = _elapsed_ms(self._tool_start.pop(run_id, None))
+        self._run.record(action="tool_call", tool=name, tool_args=args,
+                         latency_ms=latency_ms, outcome="success")
+
+    def on_tool_error(self, error, *, run_id, **kwargs):
+        if not self._record_tools:
+            return
+        name, args = self._tool_meta.pop(run_id, ("tool", None))
+        latency_ms = _elapsed_ms(self._tool_start.pop(run_id, None))
+        self._run.record(action="tool_call", tool=name, tool_args=args, latency_ms=latency_ms,
+                         outcome=f"error: {type(error).__name__}", error=_err(error))
+
+
+def build_agent(model: Any, tools: Any, **kwargs) -> Any:
+    """Construct a LangGraph ReAct-style agent using the SUPPORTED constructor for the
+    installed version — ``langchain.agents.create_agent`` (LangGraph/LangChain 1.x) when
+    available, else ``langgraph.prebuilt.create_react_agent`` (older, deprecation silenced).
+
+    This is only a convenience so callers avoid the deprecation churn; ARK's observation and
+    supervision hooks work identically with either constructor (verified). It builds nothing
+    ARK-specific — the returned agent is a plain LangGraph graph you invoke yourself.
+    """
+    try:
+        from langchain.agents import create_agent  # LangChain 1.x, the supported path
+        return create_agent(model, tools, **kwargs)
+    except ModuleNotFoundError:
+        import warnings
+        from langgraph.prebuilt import create_react_agent
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")  # its own move-to-langchain deprecation notice
+            return create_react_agent(model, tools, **kwargs)
+
+
+def ark_supervise_tool(run: RunSession, tool: Any, *, constraint: str,
+                       evidence: "dict | Callable[[dict], dict]",
+                       proposed: "Optional[Callable[[dict], dict]]" = None) -> StructuredTool:
+    """Wrap a LangGraph/LangChain tool so ARK gates each proposed call before it executes.
+
+    ``constraint`` names the runtime constraint (e.g. "rank"); ``evidence`` is the trusted
+    runtime evidence — a static dict or a ``fn(tool_args) -> dict`` computed from the call.
+    ``proposed`` maps the tool args to the ProposedAction dict (default: ``{"option": <first
+    arg>}``). On ALLOW the real tool runs and the executed telemetry is recorded on the SAME
+    decision as the verdict (``of=verdict``); on any non-ALLOW verdict the tool does NOT run
+    and ARK's suggestion is returned as the tool result, so LangGraph's loop replans.
+
+    The wrapper calls only ``run.check`` / ``run.record`` — the verdict, retry budget, and
+    recovery all come from Go ARK. Requires the trace to be opened with supervision enabled.
+    """
+    base = tool if isinstance(tool, BaseTool) else StructuredTool.from_function(tool)
+    raw: Callable = base.func if getattr(base, "func", None) is not None else base.invoke
+    name, description, args_schema = base.name, base.description, base.args_schema
+
+    def supervised(**kwargs):
+        ev = evidence(kwargs) if callable(evidence) else evidence
+        prop = proposed(kwargs) if callable(proposed) else _default_proposed(kwargs)
+        verdict: Verdict = run.check(proposed_action=prop, constraint=constraint,
+                                     evidence=ev or {}, action="tool_call", tool=name)
+        if verdict.allowed:
+            try:
+                result = raw(**kwargs)
+            except Exception as exc:  # a supervised action that was allowed but then failed
+                run.record(action="tool_call", tool=name, tool_args=kwargs,
+                           outcome=f"error: {type(exc).__name__}", error=_err(exc),
+                           executed=True, of=verdict)
+                raise  # let LangGraph handle the tool error natively
+            run.record(action="tool_call", tool=name, tool_args=kwargs,
+                       outcome="success", of=verdict)
+            return result
+        run.record(action="tool_call", tool=name, tool_args=kwargs,
+                   outcome=f"rejected:{verdict.verdict}", executed=False, of=verdict)
+        # returned to LangGraph as the ToolMessage -> the model re-proposes (replan).
+        hint = f" Suggested: {verdict.suggested}." if verdict.suggested else ""
+        return f"ARK blocked this action ({verdict.verdict}): {verdict.reason or 'constraint not satisfied'}.{hint}"
+
+    return StructuredTool.from_function(func=supervised, name=name,
+                                        description=description, args_schema=args_schema)
+
+
+# ---- helpers (pure mapping over LangChain event shapes; no ARK logic) ----
+
+import re as _re
+
+# scrub obvious secret shapes from an error string so a provider error can never leak a key.
+_SECRET_RE = _re.compile(
+    r"(sk-[A-Za-z0-9_\-]{6,}|ghp_[A-Za-z0-9]{6,}|Bearer\s+[A-Za-z0-9._\-]{6,}|"
+    r"api[_-]?key\s*[=:]\s*\S+)", _re.IGNORECASE)
+
+
+def _err(exc: BaseException, limit: int = 300) -> str:
+    """A compact, secret-scrubbed error string for the canonical DecisionRecord.error field."""
+    msg = _SECRET_RE.sub("[redacted]", str(exc))[:limit]
+    return f"{type(exc).__name__}: {msg}" if msg else type(exc).__name__
+
+
+def _default_proposed(args: dict) -> dict:
+    for v in args.values():
+        return {"option": v}
+    return {"fields": args}
+
+
+def _elapsed_ms(start: Optional[float]) -> int:
+    return int((time.monotonic() - start) * 1000) if start else 0
+
+
+def _llm_end_fields(response) -> Tuple[Optional[str], int, int, List[str]]:
+    """Extract (model, input_tokens, output_tokens, proposed_tool_names) from an LLMResult,
+    tolerating both the modern usage_metadata path and the legacy llm_output path."""
+    model: Optional[str] = None
+    in_tok = out_tok = 0
+    tool_names: List[str] = []
+    gens = getattr(response, "generations", None) or []
+    msg = getattr(gens[0][0], "message", None) if gens and gens[0] else None
+    if msg is not None:
+        um = getattr(msg, "usage_metadata", None) or {}
+        in_tok = int(um.get("input_tokens") or 0)
+        out_tok = int(um.get("output_tokens") or 0)
+        rm = getattr(msg, "response_metadata", None) or {}
+        model = rm.get("model_name") or rm.get("model")
+        tool_names = [tc.get("name") for tc in (getattr(msg, "tool_calls", None) or []) if tc.get("name")]
+    lo = getattr(response, "llm_output", None) or {}
+    if not model:
+        model = lo.get("model_name") or lo.get("model")
+    if in_tok == 0 and out_tok == 0:
+        tu = lo.get("token_usage") or lo.get("usage") or {}
+        in_tok = int(tu.get("prompt_tokens") or tu.get("input_tokens") or 0)
+        out_tok = int(tu.get("completion_tokens") or tu.get("output_tokens") or 0)
+    return model, in_tok, out_tok, tool_names

ark_agent_runtime-0.1.0a1.data/purelib/ark/models.py

@@ -0,0 +1,229 @@
+"""Typed Python mirror of the canonical ARK telemetry contract (pkg/telemetry).
+
+These objects mirror the Go `RunResult` / `DecisionRecord` JSON exactly — they do not
+invent a new schema, and they never fabricate a value the runtime reported as absent
+(missing fields stay ``None``). No routing/supervision/cost/verification logic lives here;
+this is a passive view over what the Go runtime produced.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+def _f(d: dict, k: str, default=None):
+    return d.get(k, default)
+
+
+@dataclass(frozen=True)
+class DecisionCost:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    input_cost: float = 0.0
+    output_cost: float = 0.0
+    model_cost: float = 0.0
+    tool_cost: float = 0.0
+    total_cost: float = 0.0
+
+    @classmethod
+    def from_dict(cls, d: Optional[dict]) -> "DecisionCost":
+        d = d or {}
+        return cls(
+            input_tokens=_f(d, "input_tokens", 0),
+            output_tokens=_f(d, "output_tokens", 0),
+            input_cost=_f(d, "input_cost", 0.0),
+            output_cost=_f(d, "output_cost", 0.0),
+            model_cost=_f(d, "model_cost", 0.0),
+            tool_cost=_f(d, "tool_cost", 0.0),
+            total_cost=_f(d, "total_cost", 0.0),
+        )
+
+
+@dataclass(frozen=True)
+class Verification:
+    method: Optional[str] = None
+    passed: Optional[bool] = None
+    score: Optional[float] = None
+    confidence: Optional[float] = None
+    issues: Optional[list] = None
+
+    @classmethod
+    def from_dict(cls, d: Optional[dict]) -> Optional["Verification"]:
+        if not d:
+            return None
+        return cls(_f(d, "method"), _f(d, "passed"), _f(d, "score"), _f(d, "confidence"), _f(d, "issues"))
+
+
+@dataclass(frozen=True)
+class SupervisionRecord:
+    applicable_constraint: Optional[str] = None
+    verdict: Optional[str] = None  # ALLOW / REJECT / REQUIRE_EVIDENCE / RECOVERY_EXHAUSTED
+    trusted_evidence_ref: Optional[str] = None
+    rejection_reason: Optional[str] = None
+    retry_number: Optional[int] = None
+    suggested_from_evidence: Optional[str] = None
+    executed: Optional[bool] = None
+
+    @classmethod
+    def from_dict(cls, d: Optional[dict]) -> Optional["SupervisionRecord"]:
+        if not d:
+            return None
+        return cls(
+            _f(d, "applicable_constraint"), _f(d, "verdict"), _f(d, "trusted_evidence_ref"),
+            _f(d, "rejection_reason"), _f(d, "retry_number"), _f(d, "suggested_from_evidence"),
+            _f(d, "executed"),
+        )
+
+
+@dataclass(frozen=True)
+class RoutingDecision:
+    """A view of a decision's routing: which model, and why."""
+    model: Optional[str] = None
+    routing_reason: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class ToolDecision:
+    """A view of a decision's tool activity (args are a redacted reference, never secrets)."""
+    tool: Optional[str] = None
+    tool_args_ref: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class DecisionRecord:
+    id: str
+    sequence: int
+    decision_type: str
+    timestamp: Optional[str] = None
+    action: Optional[str] = None
+    model: Optional[str] = None
+    routing_reason: Optional[str] = None
+    tool: Optional[str] = None
+    tool_args_ref: Optional[str] = None
+    cost: DecisionCost = field(default_factory=DecisionCost)
+    latency_ms: int = 0
+    verification: Optional[Verification] = None
+    supervision: Optional[SupervisionRecord] = None
+    outcome: Optional[str] = None
+    error: Optional[str] = None
+    executed: bool = False
+
+    @property
+    def latency(self) -> int:
+        return self.latency_ms
+
+    @property
+    def routing(self) -> RoutingDecision:
+        return RoutingDecision(self.model, self.routing_reason)
+
+    @property
+    def tool_decision(self) -> ToolDecision:
+        return ToolDecision(self.tool, self.tool_args_ref)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "DecisionRecord":
+        return cls(
+            id=d["id"], sequence=d["sequence"], decision_type=d["decision_type"],
+            timestamp=_f(d, "timestamp"), action=_f(d, "action"), model=_f(d, "model"),
+            routing_reason=_f(d, "routing_reason"), tool=_f(d, "tool"), tool_args_ref=_f(d, "tool_args_ref"),
+            cost=DecisionCost.from_dict(_f(d, "cost")), latency_ms=_f(d, "latency_ms", 0),
+            verification=Verification.from_dict(_f(d, "verification")),
+            supervision=SupervisionRecord.from_dict(_f(d, "supervision")),
+            outcome=_f(d, "outcome"), error=_f(d, "error"), executed=_f(d, "executed", False),
+        )
+
+
+@dataclass(frozen=True)
+class SupervisionSummary:
+    enabled: bool = False
+    interventions: int = 0
+    by_verdict: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Optional[dict]) -> "SupervisionSummary":
+        d = d or {}
+        return cls(_f(d, "enabled", False), _f(d, "interventions", 0), _f(d, "by_verdict") or {})
+
+
+@dataclass(frozen=True)
+class RoutingSummary:
+    by_model: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Optional[dict]) -> "RoutingSummary":
+        return cls((d or {}).get("by_model") or {})
+
+
+@dataclass(frozen=True)
+class ToolSummary:
+    calls: int = 0
+    by_tool: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: Optional[dict]) -> "ToolSummary":
+        d = d or {}
+        return cls(_f(d, "calls", 0), _f(d, "by_tool") or {})
+
+
+@dataclass(frozen=True)
+class RunResult:
+    run_id: str
+    task: str
+    success: bool
+    decisions: list  # list[DecisionRecord]
+    task_type: Optional[str] = None
+    started_at: Optional[str] = None
+    completed_at: Optional[str] = None
+    termination_reason: Optional[str] = None
+    output: Optional[str] = None
+    total_tokens: int = 0
+    total_latency_ms: int = 0
+    total_cost: float = 0.0
+    cost_by_model: dict = field(default_factory=dict)
+    cost_by_tool: dict = field(default_factory=dict)
+    cost_by_action: dict = field(default_factory=dict)
+    cost_by_supervision: Optional[dict] = None
+    supervision: SupervisionSummary = field(default_factory=SupervisionSummary)
+    routing: RoutingSummary = field(default_factory=RoutingSummary)
+    tools: ToolSummary = field(default_factory=ToolSummary)
+    providers: dict = field(default_factory=dict)
+    errors: Optional[list] = None
+    raw: Optional[dict] = None  # the exact JSON the runtime returned
+
+    @property
+    def total_latency(self) -> int:
+        return self.total_latency_ms
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "RunResult":
+        return cls(
+            run_id=d["run_id"], task=_f(d, "task", ""), success=_f(d, "success", False),
+            decisions=[DecisionRecord.from_dict(x) for x in (_f(d, "decisions") or [])],
+            task_type=_f(d, "task_type"), started_at=_f(d, "started_at"), completed_at=_f(d, "completed_at"),
+            termination_reason=_f(d, "termination_reason"), output=_f(d, "output"),
+            total_tokens=_f(d, "total_tokens", 0), total_latency_ms=_f(d, "total_latency_ms", 0),
+            total_cost=_f(d, "total_cost", 0.0),
+            cost_by_model=_f(d, "cost_by_model") or {}, cost_by_tool=_f(d, "cost_by_tool") or {},
+            cost_by_action=_f(d, "cost_by_action") or {}, cost_by_supervision=_f(d, "cost_by_supervision"),
+            supervision=SupervisionSummary.from_dict(_f(d, "supervision")),
+            routing=RoutingSummary.from_dict(_f(d, "routing")),
+            tools=ToolSummary.from_dict(_f(d, "tools")),
+            providers=_f(d, "providers") or {}, errors=_f(d, "errors"), raw=d,
+        )
+
+
+@dataclass(frozen=True)
+class SupervisionResult:
+    """Result of one constrained-supervision evaluation. ARK validates/gates; it never
+    authors the replacement action — the agent re-proposes."""
+    verdict: str  # ALLOW / REJECT / REQUIRE_EVIDENCE / RECOVERY_EXHAUSTED
+    reason: Optional[str] = None
+    record: Optional[SupervisionRecord] = None
+
+    @property
+    def allowed(self) -> bool:
+        return self.verdict == "ALLOW"
+
+    @property
+    def suggested_from_evidence(self) -> Optional[str]:
+        return self.record.suggested_from_evidence if self.record else None

ark_agent_runtime-0.1.0a1.data/purelib/ark/session.py

@@ -0,0 +1,235 @@
+"""External-agent integration: ``with ark.trace(...) as run:``.
+
+The developer keeps their own agent/model/tools and drives their own loop. Inside the
+trace they REPORT what happened (``run.record(...)``) and, optionally, ask ARK to gate a
+proposed action before executing it (``run.check(...)``). On exit ARK returns the canonical
+``RunResult`` — the same contract ``ARK.run`` produces.
+
+This module is a THIN line-protocol client over a persistent ``ark-bridge --session``
+process. All session state that ARK owns — retry counters, verdict semantics, recovery
+logic, stable decision IDs, cost pricing, aggregate derivation — lives in Go, so Python
+never reimplements or drifts from it. Fields ARK cannot observe (model, tokens, tool,
+latency, verification, routing) are reported by the developer and are marked as such in
+``run.provenance``; they are never presented as if ARK observed them directly.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+from typing import Any, Optional
+
+from .bridge import _find_binary
+from .errors import ArkError, ArkBridgeError, ArkSupervisionDisabled
+from .models import RunResult
+
+
+class Verdict:
+    """One supervision verdict, and the stable handle for the decision it created.
+
+    Pass it back as ``run.record(..., of=verdict)`` so the executed telemetry lands on the
+    SAME DecisionRecord as the verdict — an unambiguous proposal -> execution audit chain.
+    ``suggested`` is runtime-derived EVIDENCE (e.g. the rank-2 option id); ARK never authors
+    the replacement action — your agent re-proposes.
+    """
+
+    def __init__(self, d: dict):
+        self.decision_id: Optional[str] = d.get("decision_id")
+        self.verdict: Optional[str] = d.get("verdict")
+        self.reason: Optional[str] = d.get("reason")
+        self.retry_number: Optional[int] = d.get("retry_number")
+        self.suggested: Optional[str] = d.get("suggested") or None
+        self.allowed: bool = bool(d.get("allowed"))
+
+    def __repr__(self) -> str:
+        return (f"Verdict(verdict={self.verdict!r}, allowed={self.allowed}, "
+                f"suggested={self.suggested!r}, id={self.decision_id!r})")
+
+
+class _SessionProc:
+    """A persistent ``ark-bridge --session`` subprocess speaking one JSON object per line.
+
+    The transport is an implementation detail behind ``RunSession`` — it can be swapped for a
+    local service later without changing the public API. It carries NO session logic: it just
+    forwards a command dict and returns the parsed response dict.
+    """
+
+    def __init__(self, binary: Optional[str] = None, timeout: int = 120):
+        self._bin = binary or _find_binary()
+        self._timeout = timeout
+        self._p: Optional[subprocess.Popen] = None
+
+    def start(self) -> None:
+        self._p = subprocess.Popen(
+            [self._bin, "--session"],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=0,
+        )
+
+    def send(self, cmd: dict) -> dict:
+        if self._p is None or self._p.poll() is not None:
+            raise ArkBridgeError("session process is not running")
+        payload = (json.dumps(cmd) + "\n").encode()
+        try:
+            self._p.stdin.write(payload)
+            self._p.stdin.flush()
+            out = self._p.stdout.readline()
+        except (OSError, BrokenPipeError) as e:
+            raise ArkBridgeError(f"session transport failed: {e}") from e
+        if not out:
+            err = (self._p.stderr.read() or b"")[:300].decode(errors="replace")
+            raise ArkBridgeError(f"session ended without a response: {err}")
+        try:
+            data = json.loads(out.decode())
+        except json.JSONDecodeError as e:
+            raise ArkBridgeError(f"session returned non-JSON: {out[:200]!r}") from e
+        if isinstance(data, dict) and data.get("error"):
+            raise ArkBridgeError(data["error"])
+        return data
+
+    def close(self) -> None:
+        if self._p is None:
+            return
+        try:
+            if self._p.stdin and not self._p.stdin.closed:
+                self._p.stdin.close()
+            self._p.wait(timeout=5)
+        except Exception:
+            try:
+                self._p.kill()
+            except Exception:
+                pass
+        finally:
+            self._p = None
+
+
+class RunSession:
+    """A single ARK trace around an external agent's run. Use as a context manager.
+
+    ``supervision="experimental"`` is required to call ``check``; observe-only traces omit it.
+    """
+
+    def __init__(self, task: str, *, task_type: Optional[str] = None, supervision: str = "off",
+                 provider: str = "openai", budget: int = 4, run_id: Optional[str] = None,
+                 transport: Optional[_SessionProc] = None):
+        if supervision not in ("off", "experimental"):
+            raise ValueError("supervision must be 'off' or 'experimental'")
+        self.task = task
+        self.run_id: Optional[str] = run_id
+        self._task_type = task_type
+        self._supervision = supervision
+        self._provider = provider
+        self._budget = budget
+        self._proc = transport or _SessionProc()
+        self._result: Optional[RunResult] = None
+        self._provenance: Optional[dict] = None
+        self._finished = False
+        self._started = False
+
+    # -- lifecycle -----------------------------------------------------------------
+    def __enter__(self) -> "RunSession":
+        self._proc.start()
+        r = self._proc.send({
+            "cmd": "start", "task": self.task, "task_type": self._task_type or "",
+            "supervision": self._supervision, "provider": self._provider,
+            "budget": self._budget, "run_id": self.run_id or "",
+        })
+        self.run_id = r.get("run_id")
+        self._started = True
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        try:
+            if self._started and not self._finished:
+                self.finish(
+                    success=exc_type is None,
+                    termination_reason=None if exc_type is None else f"exception: {exc_type.__name__}",
+                )
+        finally:
+            self._proc.close()
+        return False  # never suppress the developer's exception
+
+    # -- supervision gate ----------------------------------------------------------
+    def check(self, proposed_action: Any, constraint: str, evidence: dict, *,
+              action: str = "tool_call", tool: Optional[str] = None) -> Verdict:
+        """Gate a proposed action BEFORE executing it. Synchronous, non-authoring.
+
+        Returns a :class:`Verdict`. ARK owns the retry budget and verdict semantics; on a
+        non-ALLOW verdict your agent re-authors the next action and calls ``check`` again.
+        """
+        if not self._started:
+            raise ArkError("check() outside an open trace")
+        if self._supervision != "experimental":
+            raise ArkSupervisionDisabled(
+                "constrained supervision is experimental and off by default; "
+                "open the trace with supervision='experimental'")
+        r = self._proc.send({
+            "cmd": "check", "action": action, "tool": tool or "",
+            "constraint": constraint, "proposed": _as_proposed(proposed_action),
+            "evidence": evidence or {},
+        })
+        return Verdict(r)
+
+    # -- telemetry report ----------------------------------------------------------
+    def record(self, *, action: Optional[str] = None, model: Optional[str] = None,
+               tool: Optional[str] = None, tool_args: Optional[dict] = None,
+               input_tokens: Optional[int] = None, output_tokens: Optional[int] = None,
+               cost: Optional[float] = None, latency_ms: Optional[int] = None,
+               routing_reason: Optional[str] = None, verification: Optional[dict] = None,
+               outcome: Optional[str] = None, error: Optional[str] = None,
+               executed: bool = True, of: "Verdict | str | None" = None) -> Optional[str]:
+        """Report one decision's telemetry. With ``of=<verdict>`` it completes the decision
+        that ``check`` created; otherwise it records a fresh (unsupervised) decision.
+
+        Everything here is REPORTED by your runtime — ARK derives only ids/ordering and, when
+        you give tokens+model but no ``cost``, the cost (via ARK's pricing tables). Pass
+        ``error`` for a real failure: it populates the canonical DecisionRecord.error field
+        (aggregated into RunResult.errors); ``outcome`` is kept separately for compatibility.
+        """
+        if not self._started:
+            raise ArkError("record() outside an open trace")
+        of_id = of.decision_id if isinstance(of, Verdict) else of
+        r = self._proc.send({
+            "cmd": "record", "action": action or "", "model": model or "",
+            "tool": tool or "", "tool_args": tool_args,
+            "input_tokens": input_tokens or 0, "output_tokens": output_tokens or 0,
+            "cost": cost, "latency_ms": latency_ms or 0,
+            "routing_reason": routing_reason or "", "verification": verification,
+            "outcome": outcome or "", "error": error or "",
+            "executed": executed, "of": of_id or "",
+        })
+        return r.get("decision_id")
+
+    def finish(self, *, success: bool = True, termination_reason: Optional[str] = None,
+               output: Optional[str] = None) -> RunResult:
+        """End the trace and return the canonical RunResult. Called automatically on exit."""
+        if self._finished:
+            return self._result  # type: ignore[return-value]
+        r = self._proc.send({
+            "cmd": "finish", "success": success,
+            "termination_reason": termination_reason or "", "output": output or "",
+        })
+        self._result = RunResult.from_dict(r["run_result"])
+        self._provenance = r.get("provenance")
+        self._finished = True
+        return self._result
+
+    # -- results -------------------------------------------------------------------
+    @property
+    def result(self) -> RunResult:
+        if self._result is None:
+            raise ArkError("run result is not available until the trace finishes")
+        return self._result
+
+    @property
+    def provenance(self) -> Optional[dict]:
+        """Per-decision {reported:[...], derived:[...]} split — which facts came from your
+        runtime vs which ARK generated. Available after the trace finishes."""
+        return self._provenance
+
+
+def _as_proposed(p: Any) -> dict:
+    """Accept a bare option id, ``{"option": ...}``, or a full ProposedAction-shaped dict."""
+    if isinstance(p, dict):
+        if "option" in p or "kind" in p or "fields" in p:
+            return p
+        return {"fields": p}
+    return {"option": str(p)}

ark_agent_runtime-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: ark-agent-runtime
+Version: 0.1.0a1
+Summary: ARK Runtime SDK — attach ARK decision telemetry, cost attribution, and (experimental) constrained supervision around your existing agent.
+Author: Abhishek Tripathi
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/atripati/ark
+Project-URL: Repository, https://github.com/atripati/ark
+Keywords: ark,agent,llm,telemetry,cost,supervision,observability,langgraph
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.2; extra == "langgraph"
+Requires-Dist: langchain-core>=0.3; extra == "langgraph"
+Dynamic: license-file
+
+# ARK Runtime SDK (`ark-agent-runtime`)
+
+Attach ARK's decision telemetry, cost attribution, and (experimental) constrained supervision
+around your existing agent — you keep your model, your tools, and your runtime.
+
+```bash
+pip install ark-agent-runtime
+```
+
+```python
+from ark import ARK
+
+# run a task through the ARK runtime and get the canonical RunResult
+result = ARK().run(task="find the top Python web frameworks on GitHub")
+print(result.success, result.total_cost, [d.model for d in result.decisions])
+```
+
+The wheel bundles the ARK runtime bridge for your platform — **no Go toolchain, no build step,
+no `ARK_BRIDGE_BIN`.** `import ark` needs no other dependencies.
+
+## Attach ARK around your own agent
+
+```python
+import ark
+
+with ark.trace("book the 2nd-cheapest flight") as run:
+    # ... your agent loop; you own the model and tools ...
+    run.record(action="tool_call", model="gpt-4o", tool="search",
+               input_tokens=449, output_tokens=16, outcome="success")
+result = run.result          # canonical RunResult (same schema as ARK.run)
+```
+
+Experimental constrained supervision is **off by default** and opt-in:
+
+```python
+ark.ARK(supervision="experimental")
+```
+
+## LangGraph integration (optional)
+
+```bash
+pip install "ark-agent-runtime[langgraph]"
+```
+
+```python
+from ark.integrations.langgraph import ArkCallbackHandler, ark_supervise_tool, build_agent
+```
+
+Without the extra, `import ark` still works; importing the integration prints a clear install
+message.
+
+## What you get
+
+- Canonical `RunResult` / `DecisionRecord` telemetry (decision-level).
+- Decision-level cost attribution (routing-aware, deterministic model pricing).
+- Routing, tool activity, verification (where available), and errors.
+- Experimental constrained supervision (ALLOW / REJECT / REQUIRE_EVIDENCE / RECOVERY_EXHAUSTED).
+
+The SDK does not reimplement ARK; it is a thin client over the bundled ARK runtime and makes
+no unproven claims.

ark_agent_runtime-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,15 @@
+ark_agent_runtime-0.1.0a1.data/purelib/ark/__init__.py,sha256=og_TiEyZnBbVCrRjDjdaNGGvJkgqDFHEaEZb8BW4p60,2005
+ark_agent_runtime-0.1.0a1.data/purelib/ark/bridge.py,sha256=PSzz5NaB7KAnZIYaonpKiIzQq1xslbbFRguRj-XUAho,3727
+ark_agent_runtime-0.1.0a1.data/purelib/ark/client.py,sha256=-0MitCWe_VgeUfoG87n7Y5tlurwuVyXAQ18O4jQBXmM,3936
+ark_agent_runtime-0.1.0a1.data/purelib/ark/errors.py,sha256=RcQ-9JE1kMVV5zKAJyyDGqkFx6CeRSl_4tb0qKuMJT0,491
+ark_agent_runtime-0.1.0a1.data/purelib/ark/models.py,sha256=rVcx6f2xuckgOQTAPRQ2g1nXYVclzhlDvs4UnGveuTY,8419
+ark_agent_runtime-0.1.0a1.data/purelib/ark/session.py,sha256=p4py6VlZJO0JIXpfNkdq1WuzLMoPHJzqY_WntT9d10w,11008
+ark_agent_runtime-0.1.0a1.data/purelib/ark/_bridge/__init__.py,sha256=y0wdDUrW7lZ-CKpLS7e0ZdIZuT2UbQShenbiTACv2iU,450
+ark_agent_runtime-0.1.0a1.data/purelib/ark/_bridge/ark-bridge.exe,sha256=HCV2uL1yAFygam_QibuC0Ve3SoZUguTaxaLfH2fGrVs,7158784
+ark_agent_runtime-0.1.0a1.data/purelib/ark/integrations/__init__.py,sha256=sMb48TLyjsHyk-GeYGp3yYlwUxXDJE_khxJ3ei44wDA,412
+ark_agent_runtime-0.1.0a1.data/purelib/ark/integrations/langgraph.py,sha256=1wWH1rbRD2toRZON_HsdrJXgrSZviXxZUhGChMnEvm4,12870
+ark_agent_runtime-0.1.0a1.dist-info/licenses/LICENSE,sha256=Pd-b5cKP4n2tFDpdx27qJSIq0d1ok0oEcGTlbtL6QMU,11560
+ark_agent_runtime-0.1.0a1.dist-info/METADATA,sha256=NS-_p-vJA0CTn_m0CAwF2UeCSIEQvHe4572DB0F8k14,2987
+ark_agent_runtime-0.1.0a1.dist-info/WHEEL,sha256=Zx98gwb_dQKckJK3HEOVKnxxD52EfU_PXDG_usMJ2ng,98
+ark_agent_runtime-0.1.0a1.dist-info/top_level.txt,sha256=GvM87AHKwkkvIN4c8QP2WILF2jp67ns1g_pv5owIQXQ,4
+ark_agent_runtime-0.1.0a1.dist-info/RECORD,,

ark_agent_runtime-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

ark_agent_runtime-0.1.0a1.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ark_agent_runtime-0.1.0a1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ark