conducto-ai 0.1.0__tar.gz

conducto_ai-0.1.0/.gitignore

@@ -0,0 +1,35 @@
+# Python bytecode
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# Packaging/build output
+build/
+dist/
+*.egg
+*.egg-info/
+.eggs/
+
+# Testing and coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+reports/
+.smoke-venv/
+
+# IDE/editor files
+.idea/
+.vscode/
+
+# Local tool caches
+.uv/

conducto_ai-0.1.0/LICENSE

@@ -0,0 +1,15 @@
+Apache 2.0 License
+
+Copyright 2026 Malcolm Miller
+
+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.

conducto_ai-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.5
+Name: conducto-ai
+Version: 0.1.0
+License: Apache 2.0 License
+        
+        Copyright 2026 Malcolm Miller
+        
+        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.
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: a2a-sdk==1.1.5
+Requires-Dist: cryptography>=44.0.0
+Requires-Dist: packaging>=24.0
+Requires-Dist: pydantic>=2.13.5
+Provides-Extra: mcp
+Requires-Dist: mcp==2.2.0; extra == 'mcp'
+Provides-Extra: microsoft-foundry
+Requires-Dist: azure-ai-projects>=1.0.0b11; extra == 'microsoft-foundry'
+Requires-Dist: azure-identity>=1.17; extra == 'microsoft-foundry'
+Provides-Extra: ollama
+Requires-Dist: httpx<1.0,>=0.28.1; extra == 'ollama'
+Requires-Dist: ollama>=0.5; extra == 'ollama'
+Provides-Extra: openai
+Requires-Dist: httpx<1.0,>=0.28.1; extra == 'openai'
+Requires-Dist: openai>=1.0; extra == 'openai'
+Provides-Extra: opentelemetry
+Requires-Dist: opentelemetry-api==1.37.0; extra == 'opentelemetry'
+Requires-Dist: opentelemetry-sdk==1.37.0; extra == 'opentelemetry'
+Provides-Extra: registration
+Requires-Dist: httpx<1.0,>=0.28.1; extra == 'registration'
+Provides-Extra: test
+Requires-Dist: pytest>=9.1.1; extra == 'test'

conducto_ai-0.1.0/README.md

@@ -0,0 +1,207 @@
+# Conducto
+
+Conducto is a capability-first Python framework for building governed multi-agent systems.
+
+The project is designed around a simple goal: define an agent capability once, then discover and
+invoke it through the same typed contract whether the target runs in the current process, behind an
+A2A endpoint, in a container, or in Microsoft Foundry. Deployment should change configuration and
+transport—not agent business logic.
+
+## Why Conducto?
+
+Agent systems often couple model prompts, tool definitions, service discovery, networking, and
+authorization into one runtime. That makes agent-to-agent calls difficult to test, secure, and move
+between environments.
+
+Conducto separates those responsibilities:
+
+- **Typed capabilities:** Python decorators reflect regular methods into validated capability
+  schemas and deterministic Agent Cards.
+- **Provider-neutral models:** Agents use opaque model references and structured-output contracts
+  instead of importing vendor SDKs.
+- **Governed execution:** Authorization, approvals, audit, deadlines, cancellation, and typed
+  failures surround capability execution.
+- **Capability-first discovery:** Callers ask for an allowed capability rather than hardcoding a
+  particular deployment.
+- **Transport-independent invocation:** Local and remote calls share validation, context,
+  serialization, and result semantics.
+- **Portable deployments:** The same agent contract is intended to progress from one process to
+  containers, Microsoft Foundry, and optional cross-organization federation.
+- **Protocol conformance:** Checked-in schemas and fixtures pin observable wire behavior.
+
+## What Conducto is for
+
+Conducto is intended for systems where an application must coordinate specialized agents without
+giving every model unrestricted access to every tool or deployment:
+
+- an operations agent that delegates evidence gathering to documentation and diagnostic agents
+- a business workflow that requires scoped authority and human approval before protected actions
+- a local agent composition that later moves behind authenticated network boundaries
+- a hybrid deployment that combines in-process, containerized, and Foundry-hosted agents
+- independently deployed Python agents that must follow the same observable contract
+
+Conducto is not intended to be another general-purpose chat UI or a vendor-specific model wrapper.
+Its primary concern is the controlled discovery, delegation, and execution of typed agent
+capabilities.
+
+## Current status
+
+The repository currently develops the **pre-v1 Python reference SDK** directly from the repository
+root.
+Implemented foundations include:
+
+- `@a2a_agent`, `@a2a_capability`, and `@tool` metadata
+- deterministic Agent Card generation
+- local agent registration, policy-filtered discovery, and opaque capability bindings
+- model-mediated routing and bounded model-selected delegation
+- validated capability invocation and typed result envelopes
+- provider-neutral model configuration and per-run model isolation
+- authorization scopes and approval challenges
+- structured, correlation-safe runtime logging
+- pinned A2A 1.0 transport and governed remote-agent catalog contracts
+- bounded Ollama and OpenAI-compatible provider adapters
+- optional MCP export and OpenTelemetry integration
+
+Container deployment, Foundry integration, durable workflow orchestration, and federation remain
+roadmap work. No v1 API has shipped: common application entry points live in
+`conducto`, specialized contracts in their owning `conducto.core` packages, and deterministic
+test providers in `conducto.testing`.
+
+## Intended execution model
+
+```mermaid
+flowchart LR
+    U[Application or user] --> O[Orchestrator]
+    O --> G[Agent gateway]
+    G --> P[Policy-filtered capability discovery]
+    P --> L[Local agent]
+    P --> R[Remote A2A agent]
+    P --> F[Foundry-hosted agent]
+
+    L --> X[Shared invocation pipeline]
+    R --> X
+    F --> X
+
+    X --> V[Validation and guardrails]
+    V --> E[Capability execution]
+    E --> T[Typed result and provenance]
+```
+
+The registry/catalog describes what agents exist. The gateway decides which eligible target and
+transport to use. The runtime owns execution context, model resolution, security, auditing,
+deadlines, cancellation, and results. Keeping these boundaries separate allows local behavior to
+remain the reference for every later deployment.
+
+## Python quick start
+
+Requirements: Python 3.12 or newer and [`uv`](https://docs.astral.sh/uv/).
+
+```bash
+uv sync --locked --group dev
+uv run python examples/quickstart.py
+```
+
+A minimal capability looks like:
+
+```python
+from conducto import BaseAgent, a2a_agent, a2a_capability
+
+
+@a2a_agent(
+    name="InventoryAgent",
+    version="1.0.0",
+    description="Answers inventory questions.",
+)
+class InventoryAgent(BaseAgent):
+    @a2a_capability(description="Return the available quantity for one SKU.")
+    def get_quantity(self, sku: str) -> dict[str, object]:
+        return {"sku": sku, "quantity": 12}
+```
+
+For a complete installed-package verification:
+
+```bash
+uv run pytest -m acceptance
+uv build
+wheel=$(ls dist/*.whl)
+uv run --no-project --with "$wheel" python examples/quickstart.py
+uv run --no-project --with "$wheel" python scripts/smoke_test.py
+```
+
+Optional integrations are installed with package extras such as
+`conducto-ai[registration]`, `conducto-ai[mcp]`, `conducto-ai[ollama]`,
+`conducto-ai[openai]`, `conducto-ai[microsoft-foundry]`, and
+`conducto-ai[opentelemetry]`.
+
+## Architecture principles
+
+1. **Python and contracts first.** Python establishes the reference behavior.
+2. **Local before remote.** In-process execution establishes semantics before network transport.
+3. **Capabilities before endpoints.** Agent code targets compatible capabilities, not deployment
+   addresses.
+4. **Policy before model exposure.** Unauthorized or incompatible tools never enter a model's
+   toolbox.
+5. **No authority amplification.** Delegation can preserve or reduce scopes, budgets, and
+   deadlines, never expand them.
+6. **Typed failures over hidden fallbacks.** Transport, policy, validation, approval, timeout, and
+   execution failures remain distinguishable.
+7. **Local reproducibility.** Core behavior must remain usable without cloud credentials, network
+   services, or model downloads.
+
+Read the [Python SDK architecture](./docs/architecture.md),
+[security model](./docs/security-and-governance.md), and
+[deployment topology guide](./docs/deployment-and-federation.md) for details.
+
+## Roadmap
+
+The active roadmap is tracked in [GitHub milestones](https://github.com/malcmiller/conducto-ai/milestones):
+
+1. Python local agent flow
+2. Python security and governance
+3. Python agent chaining and local gateway
+4. Python A2A network transport
+5. Python exporters, observability, and packaging
+6. Python model runtimes and Microsoft Foundry
+7. Python hybrid deployment and workflow orchestration
+8. Cross-organization federation
+
+The required product progression is **local Python → governed Python chaining → Python network
+transport → operational packaging → containers and Foundry → hybrid workflows → optional
+federation**.
+
+## Repository layout
+
+```text
+.
+├── src/conducto/                Python package
+├── tests/                       Unit, acceptance, and golden tests
+├── examples/                    Runnable application examples
+├── scripts/                     Release and installed-package verification
+├── docs/                        Product and SDK documentation
+├── pyproject.toml               Package and tool configuration
+└── uv.lock                      Reproducible dependency lock
+```
+
+## Documentation
+
+- [Documentation index](./docs/README.md)
+- [Python SDK architecture](./docs/architecture.md)
+- [Python SDK reference](./docs/sdk-reference.md)
+- [Python security and governance](./docs/security-and-governance.md)
+- [Communication and standards](./docs/communication-and-standards.md)
+- [Deployment and federation](./docs/deployment-and-federation.md)
+- [Repository automation and agent guidance](./docs/repository-automation.md)
+- [Development guide](./docs/development-guide.md)
+- [Release guide](./docs/releasing.md)
+
+## Contributing
+
+Choose an issue from the [roadmap](https://github.com/malcmiller/conducto-ai/issues), confirm its
+dependencies are complete, and keep implementation aligned with its acceptance criteria. See the
+[Python SDK development guide](./docs/development-guide.md) for setup and validation and
+[repository automation documentation](./docs/repository-automation.md) for agent instructions and
+workflows.
+
+## License
+
+Conducto is licensed under the [Apache License 2.0](./LICENSE).

conducto_ai-0.1.0/docs/README.md

@@ -0,0 +1,52 @@
+# Conducto repository documentation
+
+This directory contains product, protocol, deployment, automation, and Python
+SDK documentation for the flattened Python-only repository.
+
+## What this repository contains
+
+- `README.md` at the repository root introduces the Conducto vision and roadmap.
+- `src/conducto/` contains the shipped Python package (`conducto-ai`).
+- `docs/` documents the product, implementation, and public API.
+- `tests/` records expected behavior through unit, golden, and acceptance tests.
+
+## Documentation map
+
+- [Repository overview](./repository-overview.md) — repository purpose, structure, and key concepts.
+- [Communication paths and standards](./communication-and-standards.md) — A2A sequencing, local orchestration, container transport, and Microsoft Foundry-based model routing.
+- [Conducto A2A 1.0 profile](./a2a-1-profile.md) — pinned protocol provenance, feature matrix, compatibility policy, conformance fixtures, and update procedure.
+- [Deployment topologies and federation](./deployment-and-federation.md) — local, container, Foundry, hybrid, and cross-organization scenarios plus ownership, trust, catalog, and workflow orchestration.
+- [Repository automation and agent guidance](./repository-automation.md) — coding-agent instructions, required validation, CI behavior, branch protection, and workflow maintenance.
+- [Architecture](./architecture.md) — component boundaries and end-to-end data flow.
+- [SDK reference](./sdk-reference.md) — supported public imports and API contracts.
+- [Development guide](./development-guide.md) — local validation and contribution workflow.
+- [Releasing](./releasing.md) — trusted publishing, rehearsal, verification, and recovery.
+- [Agents and registration](./agents-and-registration.md)
+- [Gateway and discovery](./gateway-and-discovery.md)
+- [Orchestration and delegation](./orchestration-and-delegation.md)
+- [Providers and models](./providers-and-models.md)
+- [Runtime and invocation](./runtime-and-invocation.md)
+- [Security and governance](./security-and-governance.md)
+
+## Quick start
+
+```python
+from conducto import BaseAgent, a2a_agent, a2a_capability
+
+@a2a_agent(name="AuditAgent", version="1.0", description="Evaluates transaction risk.")
+class AuditAgent(BaseAgent):
+    @a2a_capability(description="Evaluates transaction risk against compliance rules.")
+    def evaluate_transaction_risk(self, vendor_id: str, amount: float) -> dict:
+        return {
+            "vendor_id": vendor_id,
+            "status": "APPROVED",
+            "risk_score": 0.05,
+        }
+```
+
+The Python SDK uses structured metadata to reflect methods into A2A-compatible
+Agent Cards and deterministic routing payloads.
+
+## Scope note
+
+The implementation and repository are Python-only.

conducto_ai-0.1.0/pyproject.toml

@@ -0,0 +1,89 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/conducto"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/conducto", "README.md", "LICENSE", "pyproject.toml"]
+
+[project]
+name = "conducto-ai"
+version = "0.1.0"
+requires-python = ">=3.12"
+license = { file = "LICENSE" }
+dependencies = [
+    "a2a-sdk==1.1.5",
+    "cryptography>=44.0.0",
+    "packaging>=24.0",
+    "pydantic>=2.13.5",
+]
+
+[project.optional-dependencies]
+registration = [
+    "httpx>=0.28.1,<1.0",
+]
+mcp = [
+    "mcp==2.2.0",
+]
+ollama = [
+    "httpx>=0.28.1,<1.0",
+    "ollama>=0.5",
+]
+openai = [
+    "httpx>=0.28.1,<1.0",
+    "openai>=1.0",
+]
+microsoft-foundry = [
+    "azure-ai-projects>=1.0.0b11",
+    "azure-identity>=1.17",
+]
+test = [
+    "pytest>=9.1.1",
+]
+opentelemetry = [
+    "opentelemetry-api==1.37.0",
+    "opentelemetry-sdk==1.37.0",
+]
+
+[dependency-groups]
+dev = [
+    "conducto-ai[mcp,opentelemetry,test]",
+    "mypy>=1.14",
+    "ruff>=0.9",
+    "types-protobuf==7.35.1.20260906",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src", "tests"]
+extend-exclude = ["*.md"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = ["UP040", "UP047"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.mypy]
+python_version = "3.12"
+packages = ["conducto"]
+mypy_path = "src"
+strict = true
+warn_unused_ignores = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "acceptance: Milestone 1 quick-start acceptance flow (stable aggregate check).",
+    "golden: Schema/golden-fixture tests pinning public wire contracts.",
+    "ollama: Opt-in tests against an already running local Ollama daemon.",
+    "vllm: Opt-in tests against an already running local vLLM OpenAI-compatible server.",
+    "lm_studio: Opt-in tests against an already running local LM Studio OpenAI-compatible server.",
+]
+
+[tool.uv.sources]
+conducto-ai = { workspace = true }

conducto_ai-0.1.0/src/conducto/__init__.py

@@ -0,0 +1,38 @@
+"""Application-facing entry points for the pre-v1 Conducto SDK.
+
+Import specialized contracts from their owning ``conducto.core`` packages,
+adapters from ``conducto.providers``, and deterministic fakes from
+``conducto.testing``. Importing Conducto does not configure clients or logging.
+"""
+
+from .core.agent import BaseAgent
+from .core.decorators import a2a_agent, a2a_capability, tool
+from .core.model_config import (
+    AgentModelConfig,
+    ModelReference,
+    ModelRequirement,
+    RunConfig,
+    RuntimeConfig,
+)
+from .core.orchestrator import OrchestratorAgent
+from .core.registry import AgentRegistry
+from .core.run_context import RunContext, get_run_context, require_run_context
+from .core.runtime import Runtime
+
+__all__ = [
+    "AgentModelConfig",
+    "AgentRegistry",
+    "BaseAgent",
+    "ModelReference",
+    "ModelRequirement",
+    "OrchestratorAgent",
+    "RunConfig",
+    "RunContext",
+    "Runtime",
+    "RuntimeConfig",
+    "a2a_agent",
+    "a2a_capability",
+    "get_run_context",
+    "require_run_context",
+    "tool",
+]

conducto_ai-0.1.0/src/conducto/a2a/__init__.py

@@ -0,0 +1,115 @@
+"""Public A2A 1.0 contracts and Conducto result mapping helpers."""
+
+from __future__ import annotations
+
+import json
+
+from a2a.types.a2a_pb2 import Artifact, Part, Task, TaskState
+from google.protobuf.struct_pb2 import Struct
+
+from conducto.core.a2a_profile import (
+    A2A_JSONRPC_BINDING,
+    A2A_NORMATIVE_COMMIT,
+    A2A_NORMATIVE_PROTO_SHA256,
+    A2A_NORMATIVE_SOURCE,
+    A2A_NORMATIVE_TAG,
+    A2A_PROTOCOL_RELEASE,
+    A2A_PROTOCOL_VERSION,
+    A2A_PYTHON_SDK_PACKAGE,
+    A2A_PYTHON_SDK_VERSION,
+    CONDUCTO_PARAMETER_EXTENSION_URI,
+    MAX_ARTIFACT_PARTS,
+    MAX_HISTORY_MESSAGES,
+    MAX_MESSAGE_PARTS,
+    MAX_METADATA_BYTES,
+    MAX_TASK_ARTIFACTS,
+    SUPPORTED_JSONRPC_METHODS,
+    SUPPORTED_MEDIA_TYPES,
+    SUPPORTED_REQUIRED_EXTENSIONS,
+    TERMINAL_TASK_STATES,
+    A2AProtocolError,
+    parse_agent_card,
+    parse_message,
+    parse_task,
+    validate_jsonrpc_method,
+    validate_task_transition,
+)
+from conducto.core.invocation_results import (
+    InvocationApprovalRequired,
+    InvocationCancelled,
+    InvocationFailure,
+    InvocationResult,
+    InvocationSuccess,
+    InvocationTimeout,
+)
+
+
+def invocation_result_to_task(result: InvocationResult, *, task_id: str, context_id: str) -> Task:
+    """Map a completed local invocation to a sanitized terminal A2A task.
+
+    Args:
+        result: Outcome returned by the shared Conducto invocation pipeline.
+        task_id: Server-owned A2A task identifier.
+        context_id: A2A context identifier shared by follow-up work.
+
+    Returns:
+        A terminal A2A task with no local exception details.
+    """
+    task = Task(id=task_id, context_id=context_id)
+    state = TaskState.TASK_STATE_FAILED
+    metadata: dict[str, str] = {}
+    if isinstance(result, InvocationSuccess):
+        state = TaskState.TASK_STATE_COMPLETED
+        task.artifacts.append(
+            Artifact(
+                artifact_id=f"{task_id}-result",
+                name="result",
+                parts=[Part(text=json.dumps(result.value, ensure_ascii=True, sort_keys=True))],
+            )
+        )
+    elif isinstance(result, InvocationCancelled):
+        state = TaskState.TASK_STATE_CANCELED
+    elif isinstance(result, InvocationTimeout):
+        metadata["reason"] = "timeout"
+    elif isinstance(result, InvocationApprovalRequired):
+        state = TaskState.TASK_STATE_INPUT_REQUIRED
+        metadata["reason"] = "approval_required"
+    elif isinstance(result, InvocationFailure):
+        metadata["reason"] = "capability_failure"
+    else:
+        metadata["reason"] = type(result).__name__
+    task.status.state = state
+    if metadata:
+        task.metadata.CopyFrom(Struct())
+        task.metadata.update(metadata)
+    return task
+
+
+__all__ = [
+    "A2A_JSONRPC_BINDING",
+    "A2A_NORMATIVE_COMMIT",
+    "A2A_NORMATIVE_PROTO_SHA256",
+    "A2A_NORMATIVE_SOURCE",
+    "A2A_NORMATIVE_TAG",
+    "A2A_PROTOCOL_RELEASE",
+    "A2A_PROTOCOL_VERSION",
+    "A2A_PYTHON_SDK_PACKAGE",
+    "A2A_PYTHON_SDK_VERSION",
+    "A2AProtocolError",
+    "CONDUCTO_PARAMETER_EXTENSION_URI",
+    "invocation_result_to_task",
+    "MAX_ARTIFACT_PARTS",
+    "MAX_HISTORY_MESSAGES",
+    "MAX_MESSAGE_PARTS",
+    "MAX_METADATA_BYTES",
+    "MAX_TASK_ARTIFACTS",
+    "SUPPORTED_JSONRPC_METHODS",
+    "SUPPORTED_MEDIA_TYPES",
+    "SUPPORTED_REQUIRED_EXTENSIONS",
+    "TERMINAL_TASK_STATES",
+    "parse_agent_card",
+    "parse_message",
+    "parse_task",
+    "validate_jsonrpc_method",
+    "validate_task_transition",
+]

conducto_ai-0.1.0/src/conducto/adapters/__init__.py

@@ -0,0 +1,29 @@
+"""Metadata-only catalog for first-party optional provider adapters.
+
+Importing this package never imports a provider SDK, resolves credentials,
+constructs a client, performs network I/O, or mutates the environment.
+Concrete adapters are selected only by trusted application code and are
+introduced independently of the core runtime.
+"""
+
+from .catalog import (
+    AdapterDependencyError,
+    AdapterSpec,
+    DiscoveredExternalAdapter,
+    ExternalAdapterSpec,
+    available_adapter_specs,
+    discover_external_adapters,
+    load_external_adapter,
+    require_adapter,
+)
+
+__all__ = [
+    "AdapterDependencyError",
+    "AdapterSpec",
+    "DiscoveredExternalAdapter",
+    "ExternalAdapterSpec",
+    "available_adapter_specs",
+    "discover_external_adapters",
+    "load_external_adapter",
+    "require_adapter",
+]