import wire

# 1. Build your graph as normal
graph = build_my_langgraph()

# 2. Wrap it — one call adds all governance
governed = wire.deploy(graph, backend="langgraph", max_iterations=50, max_cost_usd=1.0)

# 3. Run exactly as before
result = await governed.ainvoke({"messages": [{"role": "user", "content": "Analyse Q3 spend"}]})

# 4. Verify the cryptographic audit trail
wire.AuditChain.verify("wire-audit.jsonl")

from wire.primitives import LoopGuard

guard = LoopGuard(max_iterations=100, window_seconds=60)

@guard
async def agent_step(state):
    # Automatically tracked — raises LoopGuardError if limit hit
    return await my_llm_call(state)

# Or use context manager style:
async with LoopGuard(max_iterations=50) as guard:
    result = await governed.ainvoke(state)

from wire.primitives import AuditChain

# Records are auto-written by wire.deploy(); you can also write manually:
chain = AuditChain(path="wire-audit.jsonl")
chain.record(event="tool_call", agent="planner", payload={"tool": "web_search", "query": "..."})

# Verify integrity at any time — returns True or raises AuditIntegrityError
AuditChain.verify("wire-audit.jsonl")

# Export to Parquet for SIEM ingestion
chain.export("wire-audit.parquet", format="parquet")

from wire.primitives import Budget

budget = Budget(
    max_tokens=100_000,
    max_cost_usd=2.50,
    warn_at_pct=80,          # emit warning event at 80 %
    on_breach="raise",       # or "pause" | "checkpoint"
)

# Attach to a governed graph
governed = wire.deploy(graph, backend="langgraph", budget=budget)

# Inspect at runtime
print(budget.status())
# {'tokens_used': 12400, 'cost_usd': 0.31, 'pct': 12.4, 'status': 'ok'}

from wire.primitives import HITLGate

gate = HITLGate(
    trigger="before_tool_call",    # or "after_tool_call" | "on_cost_threshold"
    cost_threshold_usd=0.50,
    notify_url="https://hooks.example.com/wire-hitl",
    timeout_seconds=3600,          # auto-reject after 1 h
)

governed = wire.deploy(graph, backend="langgraph", hitl=gate)

# Approve / reject from CLI:
# wire hitl approve 
# wire hitl reject   --reason "Out of scope"

from wire.primitives import IdempotencyGuard

# In-memory (dev / single process)
guard = IdempotencyGuard(backend="memory", ttl_seconds=3600)

# Redis (multi-process / multi-host)
guard = IdempotencyGuard(backend="redis", url="redis://localhost:6379", ttl_seconds=86400)

# PostgreSQL (persistent, auditable)
guard = IdempotencyGuard(backend="postgres", dsn="postgresql://user:pass@localhost/wire")

# DynamoDB (AWS-native, serverless)
guard = IdempotencyGuard(backend="dynamodb", table="wire-idempotency", region="us-east-1")

governed = wire.deploy(graph, backend="langgraph", idempotency=guard)
# Duplicate invocations with the same key return the cached result immediately

from wire.primitives import SLATracker

sla = SLATracker(
    warn_seconds=30,
    breach_seconds=120,
    on_breach="emit_event",        # or "raise" | "checkpoint_and_raise"
)

governed = wire.deploy(graph, backend="langgraph", sla=sla)

# Query SLA status
print(sla.report())
# {'elapsed_s': 18.4, 'status': 'ok', 'warn_pct': 61, 'breaches_today': 0}

from wire.primitives import PolicyEnforcer, Policy

policy = PolicyEnforcer(rules=[
    Policy(action="deny",  match={"tool": "shell_exec", "args.cmd": {"$contains": "rm -rf"}}),
    Policy(action="allow", match={"tool": "web_search"}),
    Policy(action="allow", match={"tool": "read_file",  "args.path": {"$startswith": "/data/"}}),
    Policy(action="deny",  match={"tool": "*"}),   # default deny
])

governed = wire.deploy(graph, backend="langgraph", policy=policy)

governed = wire.deploy(
    graph,                         # Your agent graph / crew / team / assistant
    backend="langgraph",           # "langgraph" | "crewai" | "autogen" | "openai" | "foundry" | "auto"
    max_iterations=100,            # LoopGuard limit
    max_cost_usd=5.0,              # Budget (USD)
    max_tokens=200_000,            # Budget (tokens)
    hitl=None,                     # HITLGate instance or config dict
    idempotency=None,              # IdempotencyGuard instance
    sla=None,                      # SLATracker instance
    policy=None,                   # PolicyEnforcer instance
    compliance=None,               # CompliancePreset enum
    audit_path="wire-audit.jsonl", # AuditChain output file
    metrics=True,                  # Enable Prometheus metrics
)

from langgraph.graph import StateGraph
import wire

builder = StateGraph(MyState)
builder.add_node("planner", planner_node)
builder.add_node("executor", executor_node)
builder.add_edge("planner", "executor")
graph = builder.compile()

governed = wire.deploy(graph, backend="langgraph", max_iterations=50, max_cost_usd=1.0)

result = await governed.ainvoke({"messages": [{"role": "user", "content": "Run the report"}]})

from crewai import Crew, Agent, Task
import wire

researcher = Agent(role="Researcher", goal="Find the latest AI papers", backstory="...")
writer     = Agent(role="Writer",     goal="Summarise findings",         backstory="...")
crew = Crew(agents=[researcher, writer], tasks=[Task(description="Weekly AI digest", agent=writer)])

governed = wire.deploy(crew, backend="crewai", max_iterations=20, max_cost_usd=0.50)

result = governed.kickoff()       # wire wraps kickoff transparently

from autogen import AssistantAgent, UserProxyAgent
import wire

assistant  = AssistantAgent("assistant", llm_config={"model": "gpt-4o"})
user_proxy = UserProxyAgent("user_proxy", human_input_mode="NEVER")

governed = wire.deploy(
    (user_proxy, assistant),
    backend="autogen",
    max_iterations=30,
    policy=wire.PolicyEnforcer.from_yaml("policy.yaml"),
)

governed.initiate_chat(assistant, message="Summarise last quarter's revenue data")

from agents import Agent, Runner
import wire

agent = Agent(
    name="Analyst",
    instructions="You are a financial analyst. Be precise and cite sources.",
    model="gpt-4o",
)

governed = wire.deploy(agent, backend="openai", max_iterations=25, max_cost_usd=0.75)

result = await governed.run("What are the top 3 risks in our Q4 pipeline?")

from azure.ai.projects import AIProjectClient
import wire

project = AIProjectClient.from_connection_string(os.environ["AZURE_AI_PROJECT_CONN"])
agent   = project.agents.create_agent(model="gpt-4o", name="FoundryAgent", instructions="...")

governed = wire.deploy(
    agent,
    backend="foundry",
    max_iterations=40,
    compliance=wire.CompliancePreset.HIPAA,
    audit_path="wire-audit.jsonl",
)

thread = governed.create_thread()
governed.create_message(thread_id=thread.id, role="user", content="Analyse patient data trends")

import wire

workforce = wire.hire("Monitor AWS costs. Open Jira P1 on breach. Escalate to ops.")
print(workforce.describe())

# Spin up asynchronously with full governance options
workforce = await wire.hire_async(
    "Scan S3 buckets for PII. Alert security team. Generate compliance report.",
    compliance=wire.CompliancePreset.HIPAA,
    max_cost_usd=10.0,
    notify_slack="https://hooks.slack.com/services/T.../B.../xxx",
)

await workforce.run()

# Stream events as they happen
async for event in workforce.stream():
    print(f"[{event.agent}] {event.type}: {event.summary}")

from wire.visibility import WorkforceDashboard

dash = WorkforceDashboard(workforce=workforce)
await dash.start()     # Launches full-screen TUI in current terminal

from wire.visibility.web_dashboard import WebDashboard

web = WebDashboard(dashboard=dash, port=8080, api_key="your-secret-key")
await web.start()

# Open http://localhost:8080 — authenticate with the API key
# Supports: agent timeline, cost waterfall, event log, HITL queue

# Live dashboard for a running workforce
wire dashboard --workforce cost-monitor-v1

# Replay from an audit log
wire dashboard --replay wire-audit.jsonl

from wire.visibility import DriftDetector

detector = DriftDetector(
    baseline="wire-audit-baseline.jsonl",
    sensitivity=0.15,           # flag if metric deviates > 15 %
    metrics=["tool_call_rate", "avg_cost_per_step", "token_distribution"],
)

report = detector.scan("wire-audit-current.jsonl")
print(report.summary())
# Drift detected in: avg_cost_per_step (+34%) — investigate before promoting

from wire.visibility import TimeTravel

tt = TimeTravel.from_audit("wire-audit.jsonl")

# Replay from a specific step
for frame in tt.replay(from_step=12, to_step=25):
    print(f"Step {frame.step}: {frame.agent} → {frame.action}")
    print(f"  State: {frame.state_summary}")

# Branch: modify state at step 15 and re-run
branched = await tt.branch(at_step=15, state_patch={"budget_usd": 2.0})
result = await branched.run()

import wire

# Apply SOC-2 compliance to any deployment
governed = wire.deploy(graph, backend="langgraph", compliance=wire.CompliancePreset.SOC2)

# Other presets
wire.deploy(graph, backend="langgraph", compliance=wire.CompliancePreset.HIPAA)
wire.deploy(graph, backend="langgraph", compliance=wire.CompliancePreset.GDPR)
wire.deploy(graph, backend="langgraph", compliance=wire.CompliancePreset.NIST)

from wire.enterprise import RBACPolicy, Role, Permission

policy = RBACPolicy(
    roles=[
        Role("ops-engineer",  permissions=[Permission("tool.*"), Permission("hitl.approve")]),
        Role("data-analyst",  permissions=[Permission("tool.read_*"), Permission("tool.query_*")]),
        Role("auditor",       permissions=[Permission("audit.*")]),
    ],
    default_role="data-analyst",
)

governed = wire.deploy(graph, backend="langgraph", rbac=policy)

# Check permissions programmatically
policy.can("ops-engineer", "hitl.approve")   # True
policy.can("data-analyst", "tool.shell_exec") # False

from wire.enterprise import TenantRegistry

registry = TenantRegistry(backend="postgres", dsn=os.environ["DATABASE_URL"])

# Register a tenant
registry.register("acme-corp", config={
    "max_cost_usd": 50.0,
    "compliance": "SOC2",
    "audit_backend": "s3",
    "s3_bucket": "acme-wire-audit",
})

# Deploy with tenant isolation
governed = wire.deploy(graph, backend="langgraph", tenant=registry.get("acme-corp"))

from wire.audit import S3AuditBackend, PostgresAuditBackend

# Amazon S3 — immutable object storage, lifecycle policies
audit_backend = S3AuditBackend(
    bucket="my-wire-audit",
    prefix="wire-logs/",
    kms_key_id="arn:aws:kms:...",    # optional server-side encryption
    object_lock=True,                 # WORM compliance
)

# PostgreSQL — queryable, existing SIEM-friendly
audit_backend = PostgresAuditBackend(
    dsn="postgresql://user:pass@db.example.com/wire",
    table="wire_audit_events",
    retention_days=365,
)

governed = wire.deploy(graph, backend="langgraph", audit_backend=audit_backend)

import wire
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain

chain = LLMChain(llm=ChatOpenAI(model="gpt-4o"), prompt=my_prompt)

governed_chain = wire.wrap_chain(chain, max_cost_usd=0.25, max_iterations=10)

result = await governed_chain.ainvoke({"topic": "climate change impacts"})

import wire
from llama_index.core import VectorStoreIndex

index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()

governed_qe = wire.wrap_query_engine(
    query_engine,
    max_cost_usd=0.10,
    audit_path="rag-audit.jsonl",
)

response = await governed_qe.aquery("What are the key findings?")

import wire

@wire.tool(
    audit=True,
    policy=wire.PolicyEnforcer.from_yaml("tools-policy.yaml"),
    max_cost_usd=0.05,
)
async def search_web(query: str) -> str:
    """Search the web for current information."""
    results = await my_search_client.search(query)
    return results.top_result

# The decorated tool is now auto-discovered by any wire.deploy() call
governed = wire.deploy(graph, backend="langgraph")

import wire

# Increase budget limit on a live deployment
wire.patch(governed, budget=wire.Budget(max_cost_usd=10.0))

# Swap policy rules in production
wire.patch(governed, policy=wire.PolicyEnforcer.from_yaml("new-policy.yaml"))

# From CLI:
# wire patch apply --target cost-monitor-v1 --budget '{"max_cost_usd": 10.0}'

import wire

# Auto-detect framework, apply default governance
governed = wire.auto(graph)

# Or set a risk profile: "low" | "medium" | "high" | "paranoid"
governed = wire.auto(graph, risk_profile="high")
# high: max_iterations=25, max_cost_usd=1.0, hitl=True, compliance=SOC2

from wire.observability import EventStore

store = EventStore.open("wire-audit.jsonl")

# Query: all tool calls in the last hour that cost more than $0.10
events = store.query(
    type="tool_call",
    after=datetime.utcnow() - timedelta(hours=1),
    where=lambda e: e.cost_usd > 0.10,
)

for event in events:
    print(f"{event.ts} | {event.agent} | {event.tool} | ${event.cost_usd:.4f}")

# Replay a filtered subset — useful for reproducing bugs
replayer = store.replay(events, speed=2.0)   # 2x real-time
async for frame in replayer:
    print(frame)

from wire.observability import MetricsCollector

collector = MetricsCollector(
    port=9090,
    labels={"env": "production", "service": "agent-platform"},
)

governed = wire.deploy(graph, backend="langgraph", metrics=collector)
await collector.start()   # http://localhost:9090/metrics

# Exposed metrics:
# wire_iterations_total{agent, backend}          counter
# wire_cost_usd_total{agent, backend}            counter
# wire_tokens_total{agent, backend, model}       counter
# wire_hitl_pending{workforce}                   gauge
# wire_sla_breach_total{agent}                   counter
# wire_budget_utilisation_pct{agent}             gauge
# wire_audit_events_total{type}                  counter

pip install wire-ai        # installs the 'wire' CLI
wire --help                # list all commands
wire --version             # print version