krnla 0.1.0__py3-none-any.whl

krnla/__init__.py

@@ -0,0 +1,22 @@
+from .client import (
+    AgentIdentity,
+    DeclarationResult,
+    InboxAcknowledgement,
+    InboxMessage,
+    KRNLA,
+    LLMResult,
+    MessageResult,
+    SendStatus,
+)
+from .errors import *
+
+__all__ = [
+    "AgentIdentity",
+    "DeclarationResult",
+    "InboxAcknowledgement",
+    "InboxMessage",
+    "KRNLA",
+    "LLMResult",
+    "MessageResult",
+    "SendStatus",
+]

krnla/client.py

@@ -0,0 +1,856 @@
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import socket
+import ssl
+import sys
+import uuid
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Callable, Iterator, Mapping, Protocol, Sequence
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlsplit
+from urllib.request import HTTPRedirectHandler, HTTPSHandler, ProxyHandler, Request, build_opener
+
+from .errors import (
+    KRNLAAgentDisabledError,
+    KRNLAAuthenticationError,
+    KRNLAConfigurationError,
+    KRNLAConflictError,
+    KRNLAConnectionError,
+    KRNLAError,
+    KRNLAForbiddenError,
+    KRNLAInvalidRequestError,
+    KRNLAPolicyBlockedError,
+    KRNLAProtocolError,
+    KRNLARateLimitedError,
+    KRNLARequestCancelledError,
+    KRNLARequestTimeoutError,
+    KRNLAResponseTooLargeError,
+    KRNLAServerError,
+    KRNLAServiceUnavailableError,
+    KRNLAUpstreamTimeoutError,
+    KRNLADestinationNotFoundError,
+)
+
+CONTRACT: dict[str, Any] = json.loads(
+    files("krnla").joinpath("contract.json").read_text(encoding="utf-8")
+)
+
+
+class Response(Protocol):
+    status: int
+    headers: Any
+
+    def read(self, amount: int = -1) -> bytes: ...
+    def readline(self, amount: int = -1) -> bytes: ...
+    def close(self) -> None: ...
+
+
+Transport = Callable[[str, str, Mapping[str, str], bytes | None, float], Response]
+
+
+class _NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req: Any, fp: Any, code: int, msg: str, headers: Any, newurl: str) -> None:
+        return None
+
+
+def _https_context() -> ssl.SSLContext:
+    # Python.org macOS builds may lack a bundled CA path. Trust the OS CA bundle,
+    # never an unverified context, and honor explicitly configured CA paths.
+    paths = ssl.get_default_verify_paths()
+    if (
+        sys.platform == "darwin"
+        and paths.cafile is None
+        and "SSL_CERT_FILE" not in os.environ
+        and "SSL_CERT_DIR" not in os.environ
+        and Path("/etc/ssl/cert.pem").is_file()
+    ):
+        return ssl.create_default_context(cafile="/etc/ssl/cert.pem")
+    return ssl.create_default_context()
+
+
+def _default_transport(
+    method: str, url: str, headers: Mapping[str, str], body: bytes | None, timeout: float
+) -> Response:
+    # Empty ProxyHandler prevents environment proxy discovery from receiving credentials.
+    opener = build_opener(ProxyHandler({}), _NoRedirect(), HTTPSHandler(context=_https_context()))
+    request = Request(url, data=body, headers=dict(headers), method=method)
+    try:
+        return opener.open(request, timeout=timeout)
+    except HTTPError as error:
+        return error
+
+
+@dataclass(frozen=True)
+class AgentIdentity:
+    agent_id: str
+    organization_id: str
+
+
+@dataclass(frozen=True)
+class MessageResult:
+    operation_id: str | None
+    trace_id: str
+    delivery_id: str
+    destination_agent_id: str
+    decision: str
+    matched_policy_id: str | None
+    reason_code: str
+    policy_set_revision: str
+    transport: str
+    outcome: str
+    upstream_status: int | None
+
+
+@dataclass(frozen=True)
+class SendStatus:
+    operation_id: str
+    state: str
+    trace_id: str | None = None
+    delivery_id: str | None = None
+    destination_agent_id: str | None = None
+    decision: str | None = None
+    matched_policy_id: str | None = None
+    reason_code: str | None = None
+    policy_set_revision: str | None = None
+    transport: str | None = None
+
+
+@dataclass(frozen=True)
+class InboxMessage:
+    delivery_id: str
+    lease_id: str
+    source_agent_id: str
+    connection_id: str
+    event_type: str
+    destination_interface: Mapping[str, str | None]
+    content: tuple[Mapping[str, str], ...]
+    queued_at: str
+    expires_at: str
+    lease_expires_at: str
+    delivery_attempt: int
+
+
+@dataclass(frozen=True)
+class InboxAcknowledgement:
+    delivery_id: str
+    acknowledged_at: str
+    duplicate: bool
+
+
+@dataclass(frozen=True)
+class LLMResult:
+    trace_id: str
+    request_id: str
+    request_decision: Mapping[str, Any]
+    transport_outcome: str
+    upstream_status: int | None
+    response_decision: Mapping[str, Any] | None
+    response_content_type: str | None
+    response_body: str | None
+    usage: Mapping[str, int] | None
+
+
+@dataclass(frozen=True)
+class DeclarationResult:
+    version: int
+    revision: str
+    changed: bool
+    declarations: tuple[Mapping[str, Any], ...]
+
+
+ERROR_CLASSES: dict[str, type[KRNLAError]] = {
+    "UNAUTHENTICATED": KRNLAAuthenticationError,
+    "FORBIDDEN": KRNLAForbiddenError,
+    "POLICY_BLOCKED": KRNLAPolicyBlockedError,
+    "AGENT_DISABLED": KRNLAAgentDisabledError,
+    "DESTINATION_NOT_FOUND": KRNLADestinationNotFoundError,
+    "NOT_FOUND": KRNLADestinationNotFoundError,
+    "METHOD_NOT_ALLOWED": KRNLAInvalidRequestError,
+    "INVALID_REQUEST": KRNLAInvalidRequestError,
+    "CONFLICT": KRNLAConflictError,
+    "REQUEST_TOO_LARGE": KRNLAInvalidRequestError,
+    "UNSUPPORTED_MEDIA_TYPE": KRNLAInvalidRequestError,
+    "RATE_LIMITED": KRNLARateLimitedError,
+    "CONFIG_UNAVAILABLE": KRNLAServiceUnavailableError,
+    "UPSTREAM_TIMEOUT": KRNLAUpstreamTimeoutError,
+    "INTERNAL_ERROR": KRNLAServerError,
+}
+
+
+def _configuration(message: str) -> None:
+    raise KRNLAConfigurationError(message, "CONFIGURATION_ERROR")
+
+
+def _gateway_origin(value: str | None) -> str:
+    if not value:
+        _configuration("KRNLA_GATEWAY_URL is required.")
+    assert value is not None
+    if len(value) > CONTRACT["gatewayUrlMaximumLength"] or re.search(r"[\x00-\x20\\?#]", value):
+        _configuration("KRNLA_GATEWAY_URL is invalid.")
+    try:
+        parsed = urlsplit(value)
+        port = parsed.port
+    except ValueError:
+        _configuration("KRNLA_GATEWAY_URL is invalid.")
+    loopback = parsed.hostname in {"localhost", "127.0.0.1", "::1"}
+    if (
+        not parsed.hostname
+        or (parsed.scheme != "https" and not (parsed.scheme == "http" and loopback))
+        or parsed.username is not None
+        or parsed.password is not None
+        or parsed.query
+        or parsed.fragment
+        or parsed.path not in {"", "/"}
+    ):
+        _configuration("KRNLA_GATEWAY_URL must be an HTTPS origin (HTTP is local-only).")
+    host = f"[{parsed.hostname}]" if ":" in parsed.hostname else parsed.hostname
+    return f"{parsed.scheme}://{host}{f':{port}' if port is not None else ''}"
+
+
+def _credential(value: str | None) -> str:
+    if not value:
+        _configuration("KRNLA_API_KEY is required.")
+    assert value is not None
+    if re.fullmatch(CONTRACT["credentialPattern"], value) is None:
+        _configuration("KRNLA_API_KEY is invalid.")
+    return value
+
+
+def _bounded_timeout(value: float, name: str) -> float:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(value)
+        or value < 0.1
+        or value > 120
+    ):
+        _configuration(f"{name} must be between 0.1 and 120 seconds.")
+    return float(value)
+
+
+def _object(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+    return value
+
+
+def _utf16_units(value: str) -> int:
+    try:
+        return len(value.encode("utf-16-le")) // 2
+    except UnicodeError:
+        return 1_000_000_000
+
+
+def _error_from_envelope(value: Any, status: int, ambiguous: bool) -> KRNLAError:
+    envelope = _object(value)
+    details = _object(envelope.get("error"))
+    code = details.get("code")
+    if envelope.get("ok") is not False or not isinstance(code, str) or code not in CONTRACT["errors"]:
+        return KRNLAProtocolError("Gateway error response is invalid.", "PROTOCOL_ERROR", status)
+    definition = CONTRACT["errors"][code]
+    return ERROR_CLASSES.get(code, KRNLAServerError)(
+        definition["message"], code, status, "UNKNOWN" if ambiguous else None
+    )
+
+
+class KRNLA:
+    __slots__ = (
+        "__gateway",
+        "__api_key",
+        "__timeout",
+        "__streaming_inactivity_timeout",
+        "__transport",
+        "_verified_identity",
+        "llm",
+    )
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        gateway_url: str | None = None,
+        timeout: float = 15.0,
+        streaming_inactivity_timeout: float = 10.0,
+        transport: Transport | None = None,
+    ) -> None:
+        self.__gateway = _gateway_origin(
+            gateway_url if gateway_url is not None else os.environ.get("KRNLA_GATEWAY_URL")
+        )
+        self.__api_key = _credential(
+            api_key if api_key is not None else os.environ.get("KRNLA_API_KEY")
+        )
+        self.__timeout = _bounded_timeout(timeout, "timeout")
+        self.__streaming_inactivity_timeout = _bounded_timeout(
+            streaming_inactivity_timeout, "streaming_inactivity_timeout"
+        )
+        self.__transport = transport or _default_transport
+        self._verified_identity: AgentIdentity | None = None
+        self.llm = LLMClient(self)
+
+    @classmethod
+    def connect(
+        cls,
+        *,
+        api_key: str | None = None,
+        gateway_url: str | None = None,
+        timeout: float = 15.0,
+        streaming_inactivity_timeout: float = 10.0,
+        transport: Transport | None = None,
+    ) -> KRNLA:
+        client = cls(
+            api_key=api_key,
+            gateway_url=gateway_url,
+            timeout=timeout,
+            streaming_inactivity_timeout=streaming_inactivity_timeout,
+            transport=transport,
+        )
+        client._verified_identity = client.me()
+        return client
+
+    @property
+    def identity(self) -> AgentIdentity | None:
+        return self._verified_identity
+
+    def __repr__(self) -> str:
+        return f'KRNLA(gateway="{self.__gateway}", credential="[REDACTED]")'
+
+    __str__ = __repr__
+
+    def me(self) -> AgentIdentity:
+        data = self._json("identity", "GET", None, ambiguous=False)
+        return AgentIdentity(agent_id=self._string(data, "agentId"), organization_id=self._string(data, "organizationId"))
+
+    def send(
+        self,
+        *,
+        agent: str,
+        data: Mapping[str, str],
+        event: str | None = None,
+    ) -> MessageResult:
+        if len(data) < 1 or len(data) > CONTRACT["request"]["maximumContentFields"]:
+            raise KRNLAInvalidRequestError("Message data has an invalid field count.", "INVALID_REQUEST")
+        content: list[dict[str, str]] = []
+        for field_id, text in data.items():
+            if (
+                re.fullmatch(r"[A-Za-z][A-Za-z0-9_.-]*", field_id) is None
+                or len(field_id) > CONTRACT["request"]["maximumFieldIdLength"]
+                or not isinstance(text, str)
+                or _utf16_units(text) > CONTRACT["request"]["maximumFieldTextUtf16CodeUnits"]
+            ):
+                raise KRNLAInvalidRequestError("Message data is invalid.", "INVALID_REQUEST")
+            content.append({"id": field_id, "text": text})
+        body: dict[str, Any] = {"destinationAgentId": agent, "content": content}
+        if event is not None:
+            body["eventType"] = event
+        response = self._json("messages", "POST", body, ambiguous=True)
+        if (
+            response.get("operationId") is not None
+            or response.get("decision") not in {"ALLOW", "BLOCK", "REDACT"}
+            or response.get("outcome") not in CONTRACT["messageOutcomes"]
+            or response.get("transport") not in {"INBOX", "DIRECT_PUSH"}
+            or (response.get("outcome") == "BLOCKED") != (response.get("decision") == "BLOCK")
+            or not (response.get("matchedPolicyId") is None or isinstance(response.get("matchedPolicyId"), str))
+            or not self._valid_status(response.get("upstreamStatus"))
+        ):
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        return MessageResult(
+            operation_id=response.get("operationId"),
+            trace_id=self._string(response, "traceId"),
+            delivery_id=self._string(response, "deliveryId"),
+            destination_agent_id=self._string(response, "destinationAgentId"),
+            decision=self._string(response, "decision"),
+            matched_policy_id=response.get("matchedPolicyId"),
+            reason_code=self._string(response, "reasonCode"),
+            policy_set_revision=self._string(response, "policySetRevision"),
+            transport=self._string(response, "transport"),
+            outcome=self._string(response, "outcome"),
+            upstream_status=response.get("upstreamStatus"),
+        )
+
+    def emit(self, event: str, data: Mapping[str, str], *, target: str) -> MessageResult:
+        return self.send(agent=target, event=event, data=data)
+
+    def send_connection(
+        self,
+        *,
+        connection: str,
+        data: Mapping[str, str],
+        operation_id: str | None = None,
+    ) -> MessageResult:
+        if re.fullmatch(
+            r"[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}",
+            connection,
+            re.IGNORECASE,
+        ) is None:
+            raise KRNLAInvalidRequestError(
+                "Connection identifier is invalid.", "INVALID_REQUEST"
+            )
+        if len(data) < 1 or len(data) > CONTRACT["request"]["maximumContentFields"]:
+            raise KRNLAInvalidRequestError(
+                "Message data has an invalid field count.", "INVALID_REQUEST"
+            )
+        content: list[dict[str, str]] = []
+        for field_id, text in data.items():
+            if (
+                re.fullmatch(r"[A-Za-z][A-Za-z0-9_.-]*", field_id) is None
+                or len(field_id) > CONTRACT["request"]["maximumFieldIdLength"]
+                or not isinstance(text, str)
+                or _utf16_units(text)
+                > CONTRACT["request"]["maximumFieldTextUtf16CodeUnits"]
+            ):
+                raise KRNLAInvalidRequestError("Message data is invalid.", "INVALID_REQUEST")
+            content.append({"id": field_id, "text": text})
+        operation_id = operation_id or f"op_{uuid.uuid4().hex}"
+        if re.fullmatch(CONTRACT["sendOperationPattern"], operation_id) is None:
+            raise KRNLAInvalidRequestError(
+                "Send operation identifier is invalid.", "INVALID_REQUEST"
+            )
+        try:
+            response = self._json(
+                "messages",
+                "POST",
+                {"connectionId": connection, "operationId": operation_id, "content": content},
+                ambiguous=True,
+                operation_id=operation_id,
+            )
+        except KRNLAError as error:
+            error.operation_id = operation_id
+            raise
+        if (
+            response.get("operationId") != operation_id
+            or response.get("decision") not in {"ALLOW", "BLOCK", "REDACT"}
+            or response.get("outcome") not in CONTRACT["messageOutcomes"]
+            or response.get("transport") not in {"INBOX", "DIRECT_PUSH"}
+            or (response.get("outcome") == "BLOCKED") != (response.get("decision") == "BLOCK")
+            or not (
+                response.get("matchedPolicyId") is None
+                or isinstance(response.get("matchedPolicyId"), str)
+            )
+            or not self._valid_status(response.get("upstreamStatus"))
+        ):
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        return MessageResult(
+            operation_id=response.get("operationId"),
+            trace_id=self._string(response, "traceId"),
+            delivery_id=self._string(response, "deliveryId"),
+            destination_agent_id=self._string(response, "destinationAgentId"),
+            decision=self._string(response, "decision"),
+            matched_policy_id=response.get("matchedPolicyId"),
+            reason_code=self._string(response, "reasonCode"),
+            policy_set_revision=self._string(response, "policySetRevision"),
+            transport=self._string(response, "transport"),
+            outcome=self._string(response, "outcome"),
+            upstream_status=response.get("upstreamStatus"),
+        )
+
+    def get_send_status(self, *, operation_id: str) -> SendStatus:
+        if re.fullmatch(CONTRACT["sendOperationPattern"], operation_id) is None:
+            raise KRNLAInvalidRequestError(
+                "Send operation identifier is invalid.", "INVALID_REQUEST"
+            )
+        response = self._json(
+            f'{CONTRACT["paths"]["sendStatus"]}/{operation_id}',
+            "GET",
+            None,
+            ambiguous=False,
+        )
+        state = response.get("state")
+        if response.get("operationId") != operation_id or state not in {
+            "NOT_FOUND", "BLOCKED", "QUEUED", "LEASED", "ACKNOWLEDGED", "EXPIRED", "FAILED"
+        }:
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        if state == "NOT_FOUND":
+            return SendStatus(operation_id=operation_id, state=state)
+        if response.get("transport") != "INBOX":
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        return SendStatus(
+            operation_id=operation_id,
+            state=state,
+            trace_id=self._string(response, "traceId"),
+            delivery_id=self._string(response, "deliveryId"),
+            destination_agent_id=self._string(response, "destinationAgentId"),
+            decision=self._string(response, "decision"),
+            matched_policy_id=response.get("matchedPolicyId"),
+            reason_code=self._string(response, "reasonCode"),
+            policy_set_revision=self._string(response, "policySetRevision"),
+            transport="INBOX",
+        )
+
+    def poll_inbox(self, *, limit: int = 1) -> tuple[InboxMessage, ...]:
+        if type(limit) is not int or not 1 <= limit <= CONTRACT["inbox"]["maximumBatchSize"]:
+            raise KRNLAInvalidRequestError("Inbox batch size is invalid.", "INVALID_REQUEST")
+        data = self._json(f'{CONTRACT["paths"]["inbox"]}?limit={limit}', "GET", None, ambiguous=False)
+        messages = data.get("messages")
+        if not isinstance(messages, list) or len(messages) > limit:
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        result: list[InboxMessage] = []
+        for item in messages:
+            value = _object(item)
+            content = value.get("content")
+            interface = _object(value.get("destinationInterface"))
+            if (
+                re.fullmatch(r"dl_[0-9a-f]{32}", str(value.get("deliveryId"))) is None
+                or re.fullmatch(r"ls_[0-9a-f]{32}", str(value.get("leaseId"))) is None
+                or not isinstance(content, list)
+                or type(value.get("deliveryAttempt")) is not int
+            ):
+                raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+            result.append(InboxMessage(
+                delivery_id=self._string(value, "deliveryId"),
+                lease_id=self._string(value, "leaseId"),
+                source_agent_id=self._string(value, "sourceAgentId"),
+                connection_id=self._string(value, "connectionId"),
+                event_type=self._string(value, "eventType"),
+                destination_interface=interface,
+                content=tuple(_object(field) for field in content),
+                queued_at=self._string(value, "queuedAt"),
+                expires_at=self._string(value, "expiresAt"),
+                lease_expires_at=self._string(value, "leaseExpiresAt"),
+                delivery_attempt=value["deliveryAttempt"],
+            ))
+        return tuple(result)
+
+    def acknowledge(self, *, delivery_id: str, lease_id: str) -> InboxAcknowledgement:
+        if re.fullmatch(r"dl_[0-9a-f]{32}", delivery_id) is None or re.fullmatch(r"ls_[0-9a-f]{32}", lease_id) is None:
+            raise KRNLAInvalidRequestError("Inbox acknowledgement is invalid.", "INVALID_REQUEST")
+        data = self._json(
+            f'{CONTRACT["paths"]["inbox"]}/{delivery_id}/acknowledge',
+            "POST",
+            {"leaseId": lease_id},
+            ambiguous=False,
+        )
+        if data.get("deliveryId") != delivery_id or data.get("state") != "ACKNOWLEDGED" or not isinstance(data.get("acknowledgedAt"), str) or type(data.get("duplicate")) is not bool:
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        return InboxAcknowledgement(delivery_id, data["acknowledgedAt"], data["duplicate"])
+
+    def declare(
+        self,
+        *,
+        emits: Sequence[str | Mapping[str, str | None]] = (),
+        accepts: Sequence[str | Mapping[str, str | None]] = (),
+    ) -> DeclarationResult:
+        body = {
+            "version": 1,
+            "emits": [self._declaration(item) for item in emits],
+            "receives": [self._declaration(item) for item in accepts],
+        }
+        keys = [
+            (kind, item["name"], item["version"])
+            for kind, items in (("EVENT_EMIT", body["emits"]), ("EVENT_RECEIVE", body["receives"]))
+            for item in items
+        ]
+        if len(keys) > CONTRACT["declarations"]["maximumPerAgent"] or len(set(keys)) != len(keys):
+            raise KRNLAInvalidRequestError(
+                "Interface declaration set is invalid.", "INVALID_REQUEST"
+            )
+        return self._declaration_result(self._json("interfaces", "PUT", body, ambiguous=False))
+
+    def declarations(self) -> DeclarationResult:
+        return self._declaration_result(self._json("interfaces", "GET", None, ambiguous=False))
+
+    def _llm_generate(self, provider_config_id: str, inputs: Sequence[Mapping[str, str]]) -> LLMResult:
+        response = self._json(
+            "llm", "POST", {"providerConfigId": provider_config_id, "input": list(inputs)}, ambiguous=True
+        )
+        usage = response.get("usage")
+        valid_usage = usage is None or (
+            isinstance(usage, dict)
+            and all(
+                isinstance(usage.get(key), int) and not isinstance(usage.get(key), bool) and usage[key] >= 0
+                for key in ("inputTokens", "outputTokens", "totalTokens")
+            )
+        )
+        if (
+            response.get("transportOutcome") not in CONTRACT["transportOutcomes"]
+            or not self._valid_status(response.get("upstreamStatus"))
+            or not (response.get("responseContentType") is None or isinstance(response.get("responseContentType"), str))
+            or not (response.get("responseBody") is None or isinstance(response.get("responseBody"), str))
+            or not (response.get("responseDecision") is None or isinstance(response.get("responseDecision"), dict))
+            or not valid_usage
+        ):
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        return LLMResult(
+            trace_id=self._string(response, "traceId"),
+            request_id=self._string(response, "requestId"),
+            request_decision=_object(response.get("requestDecision")),
+            transport_outcome=self._string(response, "transportOutcome"),
+            upstream_status=response.get("upstreamStatus"),
+            response_decision=response.get("responseDecision"),
+            response_content_type=response.get("responseContentType"),
+            response_body=response.get("responseBody"),
+            usage=usage,
+        )
+
+    def _llm_stream(self, provider_config_id: str, inputs: Sequence[Mapping[str, str]]) -> Iterator[Mapping[str, Any]]:
+        body = self._body({"providerConfigId": provider_config_id, "stream": True, "input": list(inputs)})
+        response = self._open("llm", "POST", body, ambiguous=True)
+        try:
+            if not 200 <= response.status < 300:
+                payload = self._read_json_response(response)
+                raise _error_from_envelope(payload, response.status, True)
+            content_type = str(response.headers.get("content-type", "")).lower()
+            if not content_type.startswith("application/x-ndjson"):
+                raise KRNLAProtocolError("Gateway streaming response is invalid.", "PROTOCOL_ERROR", response.status, "UNKNOWN")
+            total = 0
+            started = False
+            completed = False
+            next_sequence = 0
+            released_bytes = 0
+            while True:
+                line = response.readline(CONTRACT["response"]["maximumJsonBytes"] + 1)
+                if not line:
+                    break
+                total += len(line)
+                if len(line) > CONTRACT["response"]["maximumJsonBytes"] or total > CONTRACT["response"]["maximumStreamBytes"]:
+                    raise KRNLAResponseTooLargeError("Gateway stream exceeded the SDK limit.", "RESPONSE_TOO_LARGE", None, "UNKNOWN")
+                try:
+                    frame = _object(json.loads(line.decode("utf-8")))
+                except (UnicodeError, json.JSONDecodeError):
+                    raise KRNLAProtocolError("Gateway stream frame is invalid.", "PROTOCOL_ERROR", None, "UNKNOWN") from None
+                if frame.get("version") != 1 or frame.get("type") not in {"start", "data", "complete", "error"}:
+                    raise KRNLAProtocolError("Gateway stream frame is invalid.", "PROTOCOL_ERROR", None, "UNKNOWN")
+                kind = frame["type"]
+                expected = {
+                    "start": {"version", "type", "traceId", "requestId", "requestDecision", "upstreamStatus"},
+                    "data": {"version", "type", "sequence", "text"},
+                    "complete": {"version", "type", "transportOutcome", "releasedBytes"},
+                    "error": {"version", "type", "code", "transportOutcome", "releasedBytes"},
+                }
+                if set(frame) != expected[kind] or completed or (kind == "start") != (not started):
+                    raise KRNLAProtocolError("Gateway stream order is invalid.", "PROTOCOL_ERROR", None, "UNKNOWN")
+                if kind == "start":
+                    if (not isinstance(frame["traceId"], str) or not isinstance(frame["requestId"], str)
+                        or not isinstance(frame["requestDecision"], dict)
+                        or isinstance(frame["upstreamStatus"], bool)
+                        or not isinstance(frame["upstreamStatus"], int)
+                        or not 100 <= frame["upstreamStatus"] <= 599):
+                        raise KRNLAProtocolError("Gateway stream frame is invalid.", "PROTOCOL_ERROR", None, "UNKNOWN")
+                    started = True
+                if frame.get("type") == "data" and (
+                    not isinstance(frame.get("text"), str)
+                    or isinstance(frame.get("sequence"), bool)
+                    or not isinstance(frame.get("sequence"), int)
+                    or frame["sequence"] != next_sequence
+                    or _utf16_units(frame["text"])
+                    > CONTRACT["response"]["maximumStreamFrameTextUtf16CodeUnits"]
+                ):
+                    raise KRNLAProtocolError(
+                        "Gateway stream frame is invalid.",
+                        "PROTOCOL_ERROR",
+                        None,
+                        "UNKNOWN",
+                    )
+                if kind == "data":
+                    next_sequence += 1
+                    released_bytes += len(frame["text"].encode("utf-8"))
+                if kind in {"complete", "error"} and (
+                    isinstance(frame["releasedBytes"], bool)
+                    or not isinstance(frame["releasedBytes"], int)
+                    or frame["releasedBytes"] < 0
+                ):
+                    raise KRNLAProtocolError("Gateway stream frame is invalid.", "PROTOCOL_ERROR", None, "UNKNOWN")
+                if kind == "complete":
+                    if frame["transportOutcome"] != "ACKNOWLEDGED" or frame["releasedBytes"] != released_bytes:
+                        raise KRNLAProtocolError("Gateway stream frame is invalid.", "PROTOCOL_ERROR", None, "UNKNOWN")
+                    completed = True
+                if frame.get("type") == "error":
+                    code = frame.get("code")
+                    outcome = frame.get("transportOutcome")
+                    if (
+                        not isinstance(code, str)
+                        or code not in CONTRACT["errors"]
+                        or outcome not in {"ACKNOWLEDGED", "UNKNOWN"}
+                    ):
+                        raise KRNLAProtocolError(
+                            "Gateway stream frame is invalid.",
+                            "PROTOCOL_ERROR",
+                            None,
+                            "UNKNOWN",
+                        )
+                    raise ERROR_CLASSES.get(code, KRNLAServerError)(
+                        CONTRACT["errors"][code]["message"],
+                        code,
+                        None,
+                        "UNKNOWN" if outcome == "UNKNOWN" else None,
+                    )
+                yield frame
+            if not completed:
+                raise KRNLAProtocolError("Gateway stream ended without completion.", "PROTOCOL_ERROR", None, "UNKNOWN")
+        except socket.timeout:
+            raise KRNLARequestTimeoutError("Streaming response timed out.", "REQUEST_TIMEOUT", None, "UNKNOWN") from None
+        except (URLError, OSError):
+            raise KRNLAConnectionError("Gateway connection failed.", "CONNECTION_ERROR", None, "UNKNOWN") from None
+        except KRNLAError:
+            raise
+        except Exception:
+            raise KRNLAConnectionError("Gateway connection failed.", "CONNECTION_ERROR", None, "UNKNOWN") from None
+        finally:
+            try:
+                response.close()
+            except Exception:
+                pass
+
+    def _headers(self, operation_id: str | None = None) -> Mapping[str, str]:
+        return {
+            "Authorization": f"Bearer {self.__api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json, application/x-ndjson",
+            "User-Agent": f"KRNLA-Python-SDK/{CONTRACT['sdkVersion']}",
+            **({"X-KRNLA-Operation-ID": operation_id} if operation_id else {}),
+        }
+
+    def _body(self, value: Any) -> bytes:
+        try:
+            body = json.dumps(value, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        except (TypeError, ValueError, UnicodeError):
+            raise KRNLAInvalidRequestError("Request is invalid.", "INVALID_REQUEST") from None
+        if len(body) > CONTRACT["request"]["maximumBytes"]:
+            raise KRNLAInvalidRequestError("Request exceeds the Gateway limit.", "REQUEST_TOO_LARGE")
+        return body
+
+    def _open(
+        self,
+        path: str,
+        method: str,
+        body: bytes | None,
+        *,
+        ambiguous: bool,
+        operation_id: str | None = None,
+    ) -> Response:
+        try:
+            return self.__transport(
+                method,
+                f"{self.__gateway}{path if path.startswith('/') else CONTRACT['paths'][path]}",
+                self._headers(operation_id),
+                body,
+                self.__streaming_inactivity_timeout if path == "llm" and body and b'"stream":true' in body else self.__timeout,
+            )
+        except (TimeoutError, socket.timeout):
+            raise KRNLARequestTimeoutError("Gateway request timed out.", "REQUEST_TIMEOUT", None, "UNKNOWN" if ambiguous else None) from None
+        except (URLError, OSError):
+            raise KRNLAConnectionError("Gateway connection failed.", "CONNECTION_ERROR", None, "UNKNOWN" if ambiguous else None) from None
+        except Exception:
+            raise KRNLAConnectionError("Gateway connection failed.", "CONNECTION_ERROR", None, "UNKNOWN" if ambiguous else None) from None
+
+    def _json(
+        self,
+        path: str,
+        method: str,
+        value: Any,
+        *,
+        ambiguous: bool,
+        operation_id: str | None = None,
+    ) -> dict[str, Any]:
+        response = self._open(
+            path,
+            method,
+            None if value is None else self._body(value),
+            ambiguous=ambiguous,
+            operation_id=operation_id,
+        )
+        try:
+            payload = self._read_json_response(response)
+            if not 200 <= response.status < 300:
+                raise _error_from_envelope(payload, response.status, ambiguous)
+            envelope = _object(payload)
+            if envelope.get("ok") is not True:
+                raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR", response.status)
+            return _object(envelope.get("data"))
+        except (TimeoutError, socket.timeout):
+            raise KRNLARequestTimeoutError("Gateway response timed out.", "REQUEST_TIMEOUT", None, "UNKNOWN" if ambiguous else None) from None
+        except (URLError, OSError):
+            raise KRNLAConnectionError("Gateway connection failed.", "CONNECTION_ERROR", None, "UNKNOWN" if ambiguous else None) from None
+        except KRNLAError:
+            raise
+        except Exception:
+            raise KRNLAConnectionError("Gateway connection failed.", "CONNECTION_ERROR", None, "UNKNOWN" if ambiguous else None) from None
+        finally:
+            try:
+                response.close()
+            except Exception:
+                pass
+
+    def _read_json_response(self, response: Response) -> Any:
+        maximum = CONTRACT["response"]["maximumJsonBytes"]
+        source = response.read(maximum + 1)
+        if len(source) > maximum:
+            raise KRNLAResponseTooLargeError("Gateway response exceeded the SDK limit.", "RESPONSE_TOO_LARGE")
+        try:
+            return json.loads(source.decode("utf-8"))
+        except (UnicodeError, json.JSONDecodeError):
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR", response.status) from None
+
+    @staticmethod
+    def _string(data: Mapping[str, Any], key: str) -> str:
+        value = data.get(key)
+        if not isinstance(value, str):
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        return value
+
+    @staticmethod
+    def _valid_status(value: Any) -> bool:
+        return value is None or (type(value) is int and 100 <= value <= 599)
+
+    @staticmethod
+    def _declaration(item: str | Mapping[str, str | None]) -> dict[str, str | None]:
+        value = (
+            {"name": item, "version": None}
+            if isinstance(item, str)
+            else {"name": item.get("name"), "version": item.get("version")}
+        )
+        name = value["name"]
+        version = value["version"]
+        if (
+            not isinstance(name, str)
+            or re.fullmatch(r"[A-Za-z][A-Za-z0-9_.:-]*", name) is None
+            or len(name) > CONTRACT["declarations"]["maximumNameLength"]
+            or not (
+                version is None
+                or (
+                    isinstance(version, str)
+                    and re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.:-]*", version)
+                    is not None
+                    and len(version) <= CONTRACT["declarations"]["maximumVersionLength"]
+                )
+            )
+        ):
+            raise KRNLAInvalidRequestError(
+                "Interface declaration is invalid.", "INVALID_REQUEST"
+            )
+        return value
+
+    @staticmethod
+    def _declaration_result(data: Mapping[str, Any]) -> DeclarationResult:
+        declarations = data.get("declarations")
+        if data.get("version") != 1 or not isinstance(data.get("revision"), str) or not isinstance(data.get("changed"), bool) or not isinstance(declarations, list) or len(declarations) > CONTRACT["declarations"]["maximumPerAgent"]:
+            raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+        checked = []
+        for item in declarations:
+            value = _object(item)
+            if (
+                value.get("kind") not in CONTRACT["declarations"]["kinds"]
+                or not isinstance(value.get("name"), str)
+                or not (value.get("interfaceVersion") is None or isinstance(value.get("interfaceVersion"), str))
+                or value.get("source") != "DECLARED"
+                or value.get("state") != "ACTIVE"
+            ):
+                raise KRNLAProtocolError("Gateway response is invalid.", "PROTOCOL_ERROR")
+            checked.append(value)
+        return DeclarationResult(1, data["revision"], data["changed"], tuple(checked))
+
+
+class LLMClient:
+    def __init__(self, client: KRNLA) -> None:
+        self.__client = client
+
+    def generate(self, *, provider_config_id: str, input: Sequence[Mapping[str, str]]) -> LLMResult:
+        return self.__client._llm_generate(provider_config_id, input)
+
+    def stream(self, *, provider_config_id: str, input: Sequence[Mapping[str, str]]) -> Iterator[Mapping[str, Any]]:
+        return self.__client._llm_stream(provider_config_id, input)

krnla/contract.json

@@ -0,0 +1,59 @@
+{
+  "apiVersion": 1,
+  "sdkVersion": "0.1.0",
+  "paths": {
+    "identity": "/api/gateway/v1/identity",
+    "interfaces": "/api/gateway/v1/interfaces",
+    "messages": "/api/gateway/v1/messages",
+    "sendStatus": "/api/gateway/v1/messages",
+    "inbox": "/api/gateway/v1/inbox",
+    "llm": "/api/gateway/v1/llm"
+  },
+  "credentialPattern": "^krn_live_[0-9a-f]{32}_[A-Za-z0-9_-]{43}$",
+  "sendOperationPattern": "^op_[0-9a-f]{32}$",
+  "gatewayUrlMaximumLength": 2048,
+  "request": {
+    "maximumBytes": 65536,
+    "maximumContentFields": 8,
+    "maximumFieldIdLength": 64,
+    "maximumFieldTextUtf16CodeUnits": 32768
+  },
+  "response": {
+    "maximumJsonBytes": 65536,
+    "maximumStreamBytes": 1048576,
+    "maximumStreamFrameTextUtf16CodeUnits": 8192
+  },
+  "declarations": {
+    "kinds": ["EVENT_EMIT", "EVENT_RECEIVE"],
+    "maximumPerAgent": 256,
+    "maximumNameLength": 128,
+    "maximumVersionLength": 64
+  },
+  "transportOutcomes": ["BLOCKED", "NOT_SENT", "ACKNOWLEDGED", "UNKNOWN"],
+  "messageOutcomes": ["BLOCKED", "NOT_SENT", "QUEUED", "ACKNOWLEDGED", "UNKNOWN"],
+  "inbox": {
+    "maximumBatchSize": 20,
+    "maximumPendingPerAgent": 500,
+    "maximumPendingPerOrganization": 10000,
+    "ttlSeconds": 86400,
+    "leaseSeconds": 120,
+    "maximumDeliveryAttempts": 20
+  },
+  "errors": {
+    "UNAUTHENTICATED": { "status": 401, "message": "Authentication is required." },
+    "FORBIDDEN": { "status": 403, "message": "Access is not permitted." },
+    "POLICY_BLOCKED": { "status": 403, "message": "Request blocked by an organization policy." },
+    "AGENT_DISABLED": { "status": 403, "message": "Agent is disabled." },
+    "DESTINATION_NOT_FOUND": { "status": 404, "message": "Destination was not found." },
+    "NOT_FOUND": { "status": 404, "message": "Resource was not found." },
+    "METHOD_NOT_ALLOWED": { "status": 405, "message": "Method is not allowed." },
+    "INVALID_REQUEST": { "status": 400, "message": "Request is invalid." },
+    "CONFLICT": { "status": 409, "message": "Request conflicts with the current resource state." },
+    "REQUEST_TOO_LARGE": { "status": 413, "message": "Request is too large." },
+    "UNSUPPORTED_MEDIA_TYPE": { "status": 415, "message": "Content type is not supported." },
+    "RATE_LIMITED": { "status": 429, "message": "Request rate limit exceeded." },
+    "CONFIG_UNAVAILABLE": { "status": 503, "message": "Required configuration is unavailable." },
+    "UPSTREAM_TIMEOUT": { "status": 504, "message": "Upstream request timed out." },
+    "INTERNAL_ERROR": { "status": 500, "message": "Request could not be completed." }
+  }
+}

krnla/errors.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+
+class KRNLAError(Exception):
+    def __init__(
+        self,
+        message: str,
+        code: str,
+        status: int | None = None,
+        outcome: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.status = status
+        self.outcome = outcome
+        self.operation_id: str | None = None
+
+
+class KRNLAConfigurationError(KRNLAError):
+    pass
+
+
+class KRNLAAuthenticationError(KRNLAError):
+    pass
+
+
+class KRNLAForbiddenError(KRNLAError):
+    pass
+
+
+class KRNLAPolicyBlockedError(KRNLAError):
+    pass
+
+
+class KRNLAAgentDisabledError(KRNLAError):
+    pass
+
+
+class KRNLADestinationNotFoundError(KRNLAError):
+    pass
+
+
+class KRNLARateLimitedError(KRNLAError):
+    pass
+
+
+class KRNLAInvalidRequestError(KRNLAError):
+    pass
+
+
+class KRNLAConflictError(KRNLAError):
+    pass
+
+
+class KRNLAServiceUnavailableError(KRNLAError):
+    pass
+
+
+class KRNLAUpstreamTimeoutError(KRNLAError):
+    pass
+
+
+class KRNLAServerError(KRNLAError):
+    pass
+
+
+class KRNLAProtocolError(KRNLAError):
+    pass
+
+
+class KRNLAResponseTooLargeError(KRNLAError):
+    pass
+
+
+class KRNLARequestTimeoutError(KRNLAError):
+    pass
+
+
+class KRNLARequestCancelledError(KRNLAError):
+    pass
+
+
+class KRNLAConnectionError(KRNLAError):
+    pass

krnla/py.typed

@@ -0,0 +1 @@
+

krnla-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: krnla
+Version: 0.1.0
+Summary: First-party Python client for the KRNLA Gateway API v1
+Author: KRNLA
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://krnla.com
+Project-URL: Documentation, https://krnla.com/docs/
+Project-URL: Repository, https://github.com/ZenSched/krnla.git
+Project-URL: Support, https://krnla.com/support/
+Keywords: ai-agents,governance,security,gateway
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# KRNLA Python SDK 0.1.0
+
+An unprivileged, standard-library client for KRNLA Gateway API v1.
+Install version 0.1.0 from the official registry after its release:
+
+```sh
+python -m pip install krnla==0.1.0
+```
+
+Configure `KRNLA_API_KEY` in the agent's secret manager and set
+`KRNLA_GATEWAY_URL=https://gateway.krnla.com`. Keep credentials out of source code.
+
+```python
+import os
+
+from krnla import KRNLA
+
+krnla = KRNLA.connect()
+print(krnla.identity.agent_id)
+
+delivery = krnla.send_connection(
+    connection=os.environ["KRNLA_CONNECTION_ID"],
+    data={"reportId": "synthetic-123"},
+)
+print(delivery.outcome)
+
+for message in krnla.poll_inbox():
+    process_message(message.content)
+    krnla.acknowledge(
+        delivery_id=message.delivery_id,
+        lease_id=message.lease_id,
+    )
+```
+
+The one-call bootstrap validates configuration and verifies identity. It does not
+capture existing arbitrary traffic or claim online presence. Use `send`, `emit`,
+`declare`, and `llm.generate`/`llm.stream` for supported governed operations. No
+decorators or action registration are required. The [developer guide](https://krnla.com/docs/)
+explains outcomes, examples, security boundaries, and deferred capabilities. A configured
+connection ID selects a server-managed route; the agent never receives the destination URL or
+verification secret. New connections use durable inbox delivery by default: a send returns
+`QUEUED`, retrieval leases a message, and `acknowledge` records successful destination
+processing. Delivery is at-least-once.
+If a send times out or loses its connection, read the typed error's `operation_id` and
+call `get_send_status(operation_id=...)`. Replaying the identical send with that
+operation ID returns the original result; changed input is rejected. Reconcile within
+seven days.

krnla-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+krnla/__init__.py,sha256=6uyBWc7vXVFqybZMhRzA97yn3Z5zNfgKCsq0a1zEog4,371
+krnla/client.py,sha256=4YtMvfux0XC3MSA7T4rpooG7gAOWT2P4KOOGjE1pHCQ,36826
+krnla/contract.json,sha256=flWK5pQDE57LB0NyDTCsqR_rbzf_yNAOlQ8N89MeB_s,2581
+krnla/errors.py,sha256=zOSWl3Y1gcgI65NYv0tJAVD1yaFeYdZN5ZhJOCYa76c,1303
+krnla/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+krnla-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+krnla-0.1.0.dist-info/METADATA,sha256=T9pJzQ0S94Wv49leN7d55VjfnMw0Jkfidbo2i-qn3G0,2590
+krnla-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+krnla-0.1.0.dist-info/top_level.txt,sha256=yd3v9VE4nd1BeB-VhesKUoy42Z9xQLnJIojMjjZXzAw,6
+krnla-0.1.0.dist-info/RECORD,,

krnla-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

krnla-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 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.

krnla-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+krnla