crowe-agent-core 0.1.0__tar.gz

crowe_agent_core-0.1.0/LICENSE

@@ -0,0 +1,115 @@
+Crowe Logic Proprietary Software License
+Copyright (c) 2026 Crowe Logic, Inc. All rights reserved.
+
+SPDX-License-Identifier: LicenseRef-Proprietary
+
+This software is proprietary and confidential. It is licensed, not sold. Your
+right to use it comes only from this license.
+
+1. DEFINITIONS
+
+   "Software" means the crowe-logic package, its source code, configuration,
+   system prompts, model definitions, documentation, and any updates provided
+   to you.
+
+   "Crowe Logic" means Crowe Logic, Inc.
+
+   "Plan" means a current, paid subscription to a Crowe Logic offering, or the
+   no-cost tier Crowe Logic makes available, each subject to its own posted
+   terms and usage limits.
+
+2. GRANT
+
+   Subject to your compliance with this license, Crowe Logic grants you a
+   limited, non-exclusive, non-transferable, revocable right to download,
+   install, and run the Software on machines you control, for your own internal
+   or business purposes, for as long as you hold an applicable Plan.
+
+3. RESTRICTIONS
+
+   You may not:
+
+   (a) redistribute, publish, sublicense, sell, rent, lease, or lend the
+       Software or any part of it, including its system prompts and model
+       configuration, whether modified or not;
+
+   (b) create or distribute derivative works of the Software;
+
+   (c) reverse engineer, decompile, or disassemble the Software except to the
+       extent applicable law expressly permits despite this restriction;
+
+   (d) remove, obscure, or alter any copyright, license, or attribution notice;
+
+   (e) use the Software to build or operate a product or service that competes
+       with Crowe Logic offerings;
+
+   (f) circumvent, disable, or interfere with any licensing, entitlement,
+       metering, or usage-limit mechanism, or access paid capabilities without
+       an applicable Plan.
+
+4. OWNERSHIP
+
+   Crowe Logic retains all right, title, and interest in the Software,
+   including all intellectual property rights. No rights are granted except
+   those expressly stated here.
+
+5. THIRD-PARTY COMPONENTS
+
+   The Software depends on third-party packages that are not covered by this
+   license and remain governed by their own license terms. This license applies
+   only to material authored by Crowe Logic. Nothing here restricts your rights
+   in those third-party components.
+
+6. FEEDBACK
+
+   If you send Crowe Logic suggestions or feedback about the Software, Crowe
+   Logic may use it without obligation or compensation to you. You retain
+   ownership of anything you author using the Software.
+
+7. TERM AND TERMINATION
+
+   This license takes effect when you first obtain the Software and continues
+   while you hold an applicable Plan. It terminates automatically if you breach
+   any term, or when your Plan lapses. On termination you must stop using the
+   Software and delete all copies. Sections 3 through 10 survive termination.
+
+8. NO WARRANTY
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. The Software
+   orchestrates third-party language models whose outputs may be inaccurate. You are
+   responsible for reviewing and verifying all outputs before relying on them.
+
+9. LIMITATION OF LIABILITY
+
+   TO THE MAXIMUM EXTENT PERMITTED BY LAW, CROWE LOGIC SHALL NOT BE LIABLE FOR
+   ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR EXEMPLARY DAMAGES, OR
+   FOR ANY LOST PROFITS, REVENUE, DATA, OR GOODWILL, ARISING OUT OF OR RELATED
+   TO THE SOFTWARE. CROWE LOGIC'S TOTAL AGGREGATE LIABILITY SHALL NOT EXCEED
+   THE AMOUNTS YOU PAID CROWE LOGIC FOR THE SOFTWARE IN THE TWELVE MONTHS
+   PRECEDING THE CLAIM.
+
+10. GOVERNING LAW
+
+    This license is governed by the laws of the State of Arizona, United States,
+    excluding its conflict-of-laws rules. The state and federal courts located
+    in Maricopa County, Arizona shall have exclusive jurisdiction over any
+    dispute arising out of this license.
+
+11. ENTIRE AGREEMENT
+
+    This license is the entire agreement between you and Crowe Logic regarding
+    the Software and supersedes any prior understanding. If any provision is
+    found unenforceable, the remainder stays in effect.
+
+--------------------------------------------------------------------------------
+
+NOTE ON EARLIER RELEASES
+
+Versions of this package published before 0.7.1 shipped an Apache License 2.0
+text. Those releases were distributed under that license, and this license does
+not, and cannot, retroactively change the terms under which they were
+obtained. This license governs version 0.7.1 and later.
+
+Licensing questions: michael@crowelogic.com

crowe_agent_core-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: crowe-agent-core
+Version: 0.1.0
+Summary: Crowe Agent Kernel — the one provider-agnostic agent loop the Crowe ecosystem mounts.
+Author-email: Michael Crowe <michael@crowelogic.com>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://crowelogic.com/foundry/
+Project-URL: Release notes, https://pypi.org/project/crowe-agent-core/#history
+Keywords: agent,kernel,llm,tool-calling,crowe-logic
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: adapters
+Requires-Dist: httpx>=0.28.0; extra == "adapters"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "test"
+Dynamic: license-file
+
+# crowe-agent-core
+
+The **Crowe Agent Kernel** — one provider-agnostic, capability-gated agent loop
+that every Crowe surface mounts (foundry CLI, `crowelm-dp`, Cortex, `cla`, the
+Terminal). It replaces the sprawl of divergent per-provider loops with a single
+kernel + thin transport adapters.
+
+Canonical architecture doc:
+`crowe-agent-team/docs/superpowers/specs/2026-07-02-crowe-agent-kernel-architecture.md`
+
+## The shape
+
+```
+Kernel.run(role, messages) -> async stream of normalized Events
+        │
+        ├─ TransportAdapter   (per-provider; the ONLY thing that varies)
+        ├─ ToolRegistry       (federates Python/Go/MCP tools)
+        ├─ HookChain          (pre_turn / pre_tool_use / post_tool_use / stop)
+        │     └─ CapabilityGate   (CCCP guardedCall(); human/agent actor split)
+        └─ Role               (roles/<name>.role.json — a clone is data)
+```
+
+- **One loop, many transports.** Providers implement `TransportAdapter.stream()`
+  and nothing else. DeepParallel is an adapter (one turn = one cluster synthesis),
+  not its own loop.
+- **Every dispatch is gated.** Tool calls pass the capability choke point before
+  running. The gate is a hook; add cost caps / human-confirm as more hooks.
+- **Agents are data.** A role file selects prompt, backend, tool allowlist, and
+  gate policy. A subagent is a kernel instance with a different role.
+
+## Status
+
+Scaffold. The kernel loop, adapter contract, tool registry, hook/capability
+seam, and role loader are implemented and tested with a deterministic
+`ScriptedAdapter`. Real adapters (openai_compat, anthropic, deepparallel) and the
+CMP event mapping are the next phase — see the build sequence in the arch doc.
+
+## Develop
+
+```bash
+uv venv --python 3.11 .venv
+uv pip install --python .venv/bin/python -e ".[test]"
+.venv/bin/python -m pytest -q
+```

crowe_agent_core-0.1.0/README.md

@@ -0,0 +1,44 @@
+# crowe-agent-core
+
+The **Crowe Agent Kernel** — one provider-agnostic, capability-gated agent loop
+that every Crowe surface mounts (foundry CLI, `crowelm-dp`, Cortex, `cla`, the
+Terminal). It replaces the sprawl of divergent per-provider loops with a single
+kernel + thin transport adapters.
+
+Canonical architecture doc:
+`crowe-agent-team/docs/superpowers/specs/2026-07-02-crowe-agent-kernel-architecture.md`
+
+## The shape
+
+```
+Kernel.run(role, messages) -> async stream of normalized Events
+        │
+        ├─ TransportAdapter   (per-provider; the ONLY thing that varies)
+        ├─ ToolRegistry       (federates Python/Go/MCP tools)
+        ├─ HookChain          (pre_turn / pre_tool_use / post_tool_use / stop)
+        │     └─ CapabilityGate   (CCCP guardedCall(); human/agent actor split)
+        └─ Role               (roles/<name>.role.json — a clone is data)
+```
+
+- **One loop, many transports.** Providers implement `TransportAdapter.stream()`
+  and nothing else. DeepParallel is an adapter (one turn = one cluster synthesis),
+  not its own loop.
+- **Every dispatch is gated.** Tool calls pass the capability choke point before
+  running. The gate is a hook; add cost caps / human-confirm as more hooks.
+- **Agents are data.** A role file selects prompt, backend, tool allowlist, and
+  gate policy. A subagent is a kernel instance with a different role.
+
+## Status
+
+Scaffold. The kernel loop, adapter contract, tool registry, hook/capability
+seam, and role loader are implemented and tested with a deterministic
+`ScriptedAdapter`. Real adapters (openai_compat, anthropic, deepparallel) and the
+CMP event mapping are the next phase — see the build sequence in the arch doc.
+
+## Develop
+
+```bash
+uv venv --python 3.11 .venv
+uv pip install --python .venv/bin/python -e ".[test]"
+.venv/bin/python -m pytest -q
+```

crowe_agent_core-0.1.0/crowe_agent_core/__init__.py

@@ -0,0 +1,52 @@
+"""crowe-agent-core — the one agent kernel the Crowe ecosystem mounts.
+
+See docs: crowe-agent-team/docs/superpowers/specs/2026-07-02-crowe-agent-kernel-architecture.md
+"""
+
+from __future__ import annotations
+
+from crowe_agent_core.capability import (
+    AllowAllPolicy,
+    AllowlistPolicy,
+    CapabilityGate,
+    CapabilityPolicy,
+    SensitivePathPolicy,
+)
+from crowe_agent_core.hooks import Hook, HookChain, HookContext, HookDecision
+from crowe_agent_core.kernel import Kernel
+from crowe_agent_core.protocol import (
+    Event,
+    EventType,
+    Message,
+    ToolCall,
+    ToolResult,
+)
+from crowe_agent_core.protocol_cmp import cmp_stream, to_cmp_event
+from crowe_agent_core.roles import Role, load_role
+from crowe_agent_core.tools.registry import ToolRegistry, ToolSpec
+
+__version__ = "0.0.1"
+
+__all__ = [
+    "Kernel",
+    "Message",
+    "Event",
+    "EventType",
+    "ToolCall",
+    "ToolResult",
+    "ToolRegistry",
+    "ToolSpec",
+    "Role",
+    "load_role",
+    "Hook",
+    "HookChain",
+    "HookContext",
+    "HookDecision",
+    "CapabilityGate",
+    "CapabilityPolicy",
+    "AllowAllPolicy",
+    "AllowlistPolicy",
+    "SensitivePathPolicy",
+    "cmp_stream",
+    "to_cmp_event",
+]

crowe_agent_core-0.1.0/crowe_agent_core/adapters/__init__.py

@@ -0,0 +1,14 @@
+from crowe_agent_core.adapters.anthropic import AnthropicAdapter
+from crowe_agent_core.adapters.base import AdapterChunk, TransportAdapter
+from crowe_agent_core.adapters.openai_compat import OpenAICompatAdapter
+from crowe_agent_core.adapters.scripted import ScriptedAdapter
+from crowe_agent_core.adapters.single_turn import SingleTurnAdapter
+
+__all__ = [
+    "TransportAdapter",
+    "AdapterChunk",
+    "ScriptedAdapter",
+    "OpenAICompatAdapter",
+    "AnthropicAdapter",
+    "SingleTurnAdapter",
+]

crowe_agent_core-0.1.0/crowe_agent_core/adapters/anthropic.py

@@ -0,0 +1,210 @@
+"""Anthropic Messages API transport adapter.
+
+The native Anthropic wire shape differs from OpenAI: the system prompt is a
+top-level param (not a message), assistant tool requests are ``tool_use``
+content blocks, and tool results go back as ``tool_result`` blocks inside a
+*user* message. Streaming arrives as typed events (``content_block_start`` /
+``content_block_delta`` with ``text_delta`` / ``thinking_delta`` /
+``input_json_delta`` / ``message_delta``). This adapter normalizes all of that
+into the same :class:`AdapterChunk` stream the kernel consumes, so the one loop
+serves Claude too.
+
+Client-agnostic: accepts any object exposing ``.messages.create(stream=True)``
+(the ``anthropic`` SDK client or a test double).
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from typing import Any
+
+from crowe_agent_core.adapters.base import AdapterChunk, TransportAdapter
+from crowe_agent_core.adapters.openai_compat import _parse_args
+from crowe_agent_core.protocol import Message, ToolCall
+
+
+def _to_anthropic(messages: list[Message]) -> tuple[str, list[dict[str, Any]]]:
+    """Return (system_prompt, anthropic_messages). Groups consecutive tool
+    results into a single following user message, as the API requires."""
+    system = ""
+    out: list[dict[str, Any]] = []
+    pending_results: list[dict[str, Any]] = []
+
+    def flush() -> None:
+        nonlocal pending_results
+        if pending_results:
+            out.append({"role": "user", "content": pending_results})
+            pending_results = []
+
+    for m in messages:
+        if m.role == "system":
+            system = m.content
+            continue
+        if m.role == "tool":
+            pending_results.append(
+                {
+                    "type": "tool_result",
+                    "tool_use_id": m.tool_call_id,
+                    "content": m.content,
+                }
+            )
+            continue
+        flush()
+        if m.role == "assistant":
+            blocks: list[dict[str, Any]] = []
+            if m.content:
+                blocks.append({"type": "text", "text": m.content})
+            for tc in m.tool_calls:
+                blocks.append(
+                    {"type": "tool_use", "id": tc.id, "name": tc.name, "input": tc.arguments}
+                )
+            out.append({"role": "assistant", "content": blocks or (m.content or " ")})
+        else:  # user
+            out.append({"role": "user", "content": m.content})
+    flush()
+    return system, out
+
+
+def _to_anthropic_tools(
+    tools: list[dict[str, Any]], *, cache_last: bool = False
+) -> list[dict[str, Any]]:
+    """Convert OpenAI-style tool schemas to Anthropic ``input_schema`` shape.
+
+    ``cache_last`` marks the final tool with ``cache_control: ephemeral``,
+    which tells Anthropic to cache the whole (stable, reused-every-turn)
+    tools prefix — cached input is ~10x cheaper than fresh input.
+    """
+    out: list[dict[str, Any]] = []
+    for t in tools:
+        fn = t.get("function", t)
+        out.append(
+            {
+                "name": fn.get("name"),
+                "description": fn.get("description", ""),
+                "input_schema": fn.get("parameters", {"type": "object", "properties": {}}),
+            }
+        )
+    if cache_last and out:
+        out[-1] = {**out[-1], "cache_control": {"type": "ephemeral"}}
+    return out
+
+
+def _mark_conversation_cached(amsgs: list[dict[str, Any]]) -> None:
+    """Add a cache breakpoint at the end of the conversation (in place).
+
+    Marks the last content block of the last message with
+    ``cache_control: ephemeral`` so Anthropic caches the entire history
+    prefix. In a multi-turn tool loop each turn reuses the prior turn's
+    cached prefix (5-min TTL), so only the newest tokens pay full price —
+    where "input dominates agentic volume". A string content is promoted to
+    a one-block list so the marker has somewhere to live. No-op on empty.
+    """
+    if not amsgs:
+        return
+    last = amsgs[-1]
+    content = last.get("content")
+    if isinstance(content, str):
+        last["content"] = [
+            {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
+        ]
+    elif isinstance(content, list) and content:
+        content[-1] = {**content[-1], "cache_control": {"type": "ephemeral"}}
+
+
+class AnthropicAdapter(TransportAdapter):
+    backend_id = "anthropic"
+
+    def __init__(
+        self,
+        client: Any,
+        model: str,
+        *,
+        max_tokens: int = 4096,
+        cache_system: bool = True,
+        cache_tools: bool = True,
+        cache_conversation: bool = True,
+        extra_params: dict[str, Any] | None = None,
+    ) -> None:
+        self._client = client
+        self._model = model
+        self._max_tokens = max_tokens
+        self._cache_system = cache_system
+        self._cache_tools = cache_tools
+        self._cache_conversation = cache_conversation
+        self._extra = dict(extra_params or {})
+
+    async def stream(
+        self,
+        messages: list[Message],
+        tools: list[dict[str, Any]],
+    ) -> AsyncIterator[AdapterChunk]:
+        system, amsgs = _to_anthropic(messages)
+        system_block: Any = system
+        if self._cache_system and system:
+            system_block = [
+                {"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}
+            ]
+
+        if self._cache_conversation:
+            _mark_conversation_cached(amsgs)
+
+        create_kwargs: dict[str, Any] = {
+            "model": self._model,
+            "max_tokens": self._max_tokens,
+            "messages": amsgs,
+            "stream": True,
+        }
+        if system:
+            create_kwargs["system"] = system_block
+        create_kwargs.update(self._extra)
+        if tools:
+            create_kwargs["tools"] = _to_anthropic_tools(
+                tools, cache_last=self._cache_tools
+            )
+
+        stream = self._client.messages.create(**create_kwargs)
+
+        blocks: dict[int, dict[str, str]] = {}
+        stop_reason = "end_turn"
+
+        for event in stream:
+            etype = getattr(event, "type", None)
+            if etype == "content_block_start":
+                cb = getattr(event, "content_block", None)
+                if cb is not None and getattr(cb, "type", None) == "tool_use":
+                    blocks[event.index] = {
+                        "id": cb.id,
+                        "name": cb.name,
+                        "input": "",
+                    }
+            elif etype == "content_block_delta":
+                d = getattr(event, "delta", None)
+                dtype = getattr(d, "type", None) if d else None
+                if dtype == "thinking_delta":
+                    yield AdapterChunk(kind="reasoning", text=getattr(d, "thinking", "") or "")
+                elif dtype == "text_delta":
+                    yield AdapterChunk(kind="text", text=getattr(d, "text", "") or "")
+                elif dtype == "input_json_delta":
+                    blk = blocks.get(getattr(event, "index", -1))
+                    if blk is not None:
+                        blk["input"] += getattr(d, "partial_json", "") or ""
+            elif etype == "message_delta":
+                d = getattr(event, "delta", None)
+                sr = getattr(d, "stop_reason", None) if d else None
+                if sr:
+                    stop_reason = sr
+
+        for idx in sorted(blocks):
+            blk = blocks[idx]
+            yield AdapterChunk(
+                kind="tool_call",
+                tool_call=ToolCall(
+                    id=blk["id"],
+                    name=(blk["name"] or "").strip() or "invalid_tool_call",
+                    arguments=_parse_args(blk["input"]),
+                ),
+            )
+
+        if blocks or stop_reason == "tool_use":
+            stop_reason = "tool_use"
+        yield AdapterChunk(kind="done", stop_reason=stop_reason)

crowe_agent_core-0.1.0/crowe_agent_core/adapters/base.py

@@ -0,0 +1,58 @@
+"""Transport adapter contract — the ONLY thing that varies per provider.
+
+An adapter does exactly one job: given the conversation and the available tool
+schemas, stream back normalized chunks (text/reasoning deltas and structured
+tool-call requests) and a terminal ``done`` chunk carrying the stop reason. It
+does NOT run the tool-calling loop — that is the kernel's job. This inversion is
+what lets one loop serve OpenAI-compat, Anthropic-native, NVIDIA, Ollama,
+watsonx, the sovereign Azure gateway, and DeepParallel (where one "turn" is a
+full cluster synthesis) without divergent loops.
+"""
+
+from __future__ import annotations
+
+import abc
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from crowe_agent_core.protocol import Message, ToolCall
+
+
+@dataclass
+class AdapterChunk:
+    """One streamed unit from a provider, normalized.
+
+    ``kind``:
+      - "text"      -> ``text`` holds an answer delta
+      - "reasoning" -> ``text`` holds a hidden-reasoning delta
+      - "tool_call" -> ``tool_call`` holds a (possibly partial-then-complete) call
+      - "done"      -> ``stop_reason`` is "end_turn" | "tool_use" | "length"
+    """
+
+    kind: Literal["text", "reasoning", "tool_call", "done"]
+    text: str = ""
+    tool_call: ToolCall | None = None
+    stop_reason: str | None = None
+    meta: dict[str, Any] = field(default_factory=dict)
+
+
+class TransportAdapter(abc.ABC):
+    """Base class for provider adapters. Subclasses implement :meth:`stream`."""
+
+    #: Stable id used by role files to select a backend (e.g. "openai_compat").
+    backend_id: str = "abstract"
+
+    @abc.abstractmethod
+    def stream(
+        self,
+        messages: list[Message],
+        tools: list[dict[str, Any]],
+    ) -> AsyncIterator[AdapterChunk]:
+        """Stream normalized chunks for one model turn.
+
+        Implementations are async generators. They must emit a terminal
+        ``AdapterChunk(kind="done", stop_reason=...)`` so the kernel knows
+        whether to continue (tool_use) or finish (end_turn).
+        """
+        raise NotImplementedError