from intrupt_py_sdk.core.client import ApprovalClient

client = ApprovalClient(
    base_url="http://localhost:8080",  # URL of the running approval API
    api_key="sk_org_...",              # API key from your dashboard
)

from intrupt_py_sdk.adapters.langgraph import approval_required
from intrupt_py_sdk.adapters.approval_middleware import ApprovalMiddleware

# Construct once at startup — subsequent calls return the same instance
ApprovalMiddleware(
    base_url=os.getenv("AEGMIS_BASE_URL", "http://localhost:8080"),
    api_key=os.getenv("AEGMIS_API_KEY"),
)

# Retrieve the configured client anywhere
client = ApprovalMiddleware.get_client()

from intrupt_py_sdk.adapters.langgraph import ApprovalGraph
from intrupt_py_sdk.adapters.approval_middleware import ApprovalMiddleware

# HTTP approval flow (intrupt API)
approval_graph = ApprovalGraph(
    graph=graph,
    callback_url="http://localhost:8081/resume",
    callback_secret=os.getenv("AGENT_RESUME_SECRET", ""),
)

# Inline async channel (console, email, Slack, policy engine)
approval_graph = ApprovalGraph(
    graph=graph,
    on_approval_async=my_async_fn,
    timeout=1.5,
)

import hmac
import os
import uuid
from typing import Annotated, TypedDict

from dotenv import load_dotenv
from fastapi import FastAPI, HTTPException, Request
from langchain_core.messages import BaseMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, StateGraph
from langgraph.prebuilt import ToolNode
from langgraph.graph.message import add_messages

from intrupt_py_sdk.adapters.approval_middleware import ApprovalMiddleware
from intrupt_py_sdk.adapters.langgraph import ApprovalGraph, approval_required

load_dotenv()

ApprovalMiddleware(
    base_url=os.getenv("AEGMIS_BASE_URL"),
    api_key=os.getenv("AEGMIS_API_KEY"),
)
AGENT_PUBLIC_URL = os.getenv("AGENT_PUBLIC_URL", "http://localhost:8081")
_RESUME_SECRET   = os.getenv("AGENT_RESUME_SECRET", "")


# ── State ────────────────────────────────────────────────────────────────────
class AgentState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]


# ── Tools ────────────────────────────────────────────────────────────────────
@tool
def get_stock_price(symbol: str) -> dict:
    """Fetch latest stock price for a given symbol."""
    return {"symbol": symbol, "price": 150.00}   # replace with real API call


@tool
@approval_required(
    action="buy_stock",
    message="Approve buying shares",
    channel="slack",
    args=["symbol", "quantity", "amount"],
)
def buy_stock(symbol: str, quantity: int, amount: float) -> dict:
    """Purchase a stock. Requires human approval before execution."""
    return {"status": "success", "symbol": symbol, "quantity": quantity}


tools = [get_stock_price, buy_stock]
llm   = ChatOpenAI().bind_tools(tools)


# ── Graph ────────────────────────────────────────────────────────────────────
def chat_node(state: AgentState):
    return {"messages": [llm.invoke(state["messages"])]}

def route(state: AgentState) -> str:
    last = state["messages"][-1]
    return "tools" if getattr(last, "tool_calls", None) else "END"

memory = MemorySaver()
graph  = (
    StateGraph(AgentState)
    .add_node("chat_node", chat_node)
    .add_node("tools", ToolNode(tools))
    .add_edge(START, "chat_node")
    .add_conditional_edges("chat_node", route)
    .add_edge("tools", "chat_node")
    .compile(checkpointer=memory)
)

approval_graph = ApprovalGraph(
    graph=graph,
    callback_url=f"{AGENT_PUBLIC_URL}/resume",
    callback_secret=_RESUME_SECRET,
)


# ── FastAPI ──────────────────────────────────────────────────────────────────
app = FastAPI()


@app.post("/call-tool")
async def call_tool(request: Request):
    payload = await request.json()
    if not payload.get("message"):
        raise HTTPException(status_code=400, detail="'message' required")
    thread_id = payload.get("thread_id") or str(uuid.uuid4())
    if payload.get("thread_id") and approval_graph.pending(thread_id):
        raise HTTPException(status_code=409, detail="thread has a pending approval")
    result = await approval_graph.ainvoke(
        {"messages": [{"role": "user", "content": payload["message"]}]},
        thread_id,
    )
    # result["status"] == "pending_approval"  → {"thread_id", "approval_id"}
    # result["status"] == "complete"          → {"thread_id", "messages", "result"}
    #   result["result"] contains the full graph state (custom fields included)
    return result


@app.post("/resume")
async def resume(request: Request):
    # Auth check is skipped when AGENT_RESUME_SECRET is not set
    if _RESUME_SECRET and not hmac.compare_digest(request.headers.get("X-Agent-Secret", ""), _RESUME_SECRET):
        raise HTTPException(status_code=401, detail="invalid X-Agent-Secret")
    payload   = await request.json()
    thread_id = payload.get("thread_id")
    if not thread_id or "approved" not in payload:
        raise HTTPException(status_code=400, detail="thread_id and approved required")
    if not approval_graph.pending(thread_id):
        raise HTTPException(status_code=409, detail="thread is not paused on an approval")
    return await approval_graph.aresume(
        thread_id,
        approved=bool(payload["approved"]),
        approval_id=payload.get("approval_id"),
    )


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8081)

from intrupt_py_sdk.core.client import ApprovalError

try:
    result = graph.invoke({"messages": [...]}, config=config)
except ApprovalError as e:
    # Approval API unreachable or returned an error
    print(f"Approval failed: {e}")

import os
from intrupt_py_sdk.core import observability

# Safe to call unconditionally: a None endpoint disables emission.
observability.init(
    os.getenv("AEGMIS_OTLP_ENDPOINT"),   # e.g. https://obs.aegmis.com
    service_name="finance-agent",
)

import { generateText, stepCountIs, tool } from "ai";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";
import { ApprovalMiddleware, ApprovalRunner } from "intrupt-js-sdk";
import { approvalRequired } from "intrupt-js-sdk/vercel";

ApprovalMiddleware.configure({
  baseUrl: process.env.AEGMIS_BASE_URL, // http://localhost:8080
  apiKey: process.env.AEGMIS_API_KEY,   // sk_org_org_..._<hash>
});

const purchaseStock = approvalRequired(
  { action: "purchase_stock", message: "Approve buying shares", channel: "slack", args: ["symbol", "quantity"] },
  "purchase_stock",
)(tool({
  description: "Buy shares of a stock.",
  inputSchema: z.object({ symbol: z.string(), quantity: z.number() }),
  execute: async ({ symbol, quantity }) => ({ status: "success", symbol, quantity }),
}));

const runner = new ApprovalRunner({
  callbackUrl: "http://localhost:8081/resume",
  callbackSecret: process.env.AGENT_RESUME_SECRET,
  invoke: (input) =>
    generateText({ model: openai("gpt-4o-mini"), tools: { purchaseStock }, stopWhen: stepCountIs(5), prompt: String(input) }),
  formatResult: (raw, threadId) => ({ status: "complete", thread_id: threadId, result: (raw as any).text }),
});

// 1. Start a run — returns { status: "pending_approval", approval_id } if a gated tool fires.
const pending = await runner.run("thread-1", "buy 10 shares of AAPL");

// 2. When the human decides (your /resume endpoint), unblock the tool:
await runner.resume("thread-1", true, pending.approval_id as string);
const final = await runner.waitForResult("thread-1");

import { createTool } from "@mastra/core/tools";
import { z } from "zod";
import { ApprovalMiddleware } from "intrupt-js-sdk";
import { approvalRequired } from "intrupt-js-sdk/mastra";

ApprovalMiddleware.configure({
  baseUrl: process.env.AEGMIS_BASE_URL,
  apiKey: process.env.AEGMIS_API_KEY,
});

export const purchaseStock = approvalRequired({
  action: "purchase_stock",
  message: "Approve stock purchase?",
  channel: "slack",
  args: ["symbol", "quantity"],
})(
  createTool({
    id: "purchase_stock",
    description: "Buy shares of a stock.",
    inputSchema: z.object({ symbol: z.string(), quantity: z.number() }),
    // Mastra >= 1.0 passes the validated input as the first arg.
    execute: async (inputData) => ({ status: "success", ...inputData }),
  }),
);

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { gateHandler } from "intrupt-js-sdk/langchain"; // same export from /langgraph

const purchaseStock = tool(
  gateHandler(
    async ({ symbol, quantity }) => ({ status: "success", symbol, quantity }),
    { name: "purchase_stock", description: "Buy shares." },
    { action: "purchase_stock", message: "Approve buying shares", channel: "slack", args: ["symbol", "quantity"] },
  ),
  {
    name: "purchase_stock",
    description: "Buy shares.",
    schema: z.object({ symbol: z.string(), quantity: z.number() }),
  },
);

import { ApprovalGraph } from "intrupt-js-sdk/langgraph";

const approvalGraph = new ApprovalGraph({
  graph,                                            // your compiled StateGraph
  callbackUrl: process.env.AGENT_PUBLIC_URL + "/resume",
  callbackSecret: process.env.AGENT_RESUME_SECRET,
});

let result = await approvalGraph.run(threadId, { messages: [{ role: "user", content: msg }] });
// if result.status === "pending_approval": wait for the /resume callback, then:
result = await approvalGraph.resume(threadId, true, result.approval_id);

import { ApprovalRunner } from "intrupt-js-sdk";
import { createApprovalServer } from "intrupt-js-sdk/server";

const runner = new ApprovalRunner({ /* callbackUrl, invoke, formatResult */ });

// port + resumeSecret default from AGENT_PUBLIC_URL / AGENT_RESUME_SECRET
createApprovalServer({ runner });

import express from "express";
import crypto from "node:crypto";
import { ApprovalMiddleware, ApprovalRunner } from "intrupt-js-sdk";
// ...plus the Mastra agent + gated purchaseStock tool from above...

ApprovalMiddleware.configure({
  baseUrl: process.env.AEGMIS_BASE_URL,
  apiKey: process.env.AEGMIS_API_KEY,
});

const runner = new ApprovalRunner({
  callbackUrl: process.env.AGENT_PUBLIC_URL + "/resume", // platform POSTs decisions here
  callbackSecret: process.env.AGENT_RESUME_SECRET,
  invoke: (input) => agent.generate(String(input)),
  formatResult: (raw, threadId) => ({ status: "complete", thread_id: threadId, result: raw.text }),
});

const app = express();
app.use(express.json());

// Start a turn — returns pending_approval if a gated tool opens a gate.
app.post("/call-tool", async (req, res) => {
  const threadId = req.body.thread_id ?? crypto.randomUUID();
  res.json(await runner.run(threadId, req.body.message));
});

// The approval platform calls this once a human approves / rejects.
app.post("/resume", async (req, res) => {
  const secret = process.env.AGENT_RESUME_SECRET ?? "";
  const got = req.header("X-Agent-Secret") ?? "";
  if (secret && (got.length !== secret.length ||
      !crypto.timingSafeEqual(Buffer.from(got), Buffer.from(secret)))) {
    return res.status(401).json({ detail: "invalid X-Agent-Secret" });
  }
  const { thread_id, approved, approval_id } = req.body;
  let result = await runner.resume(thread_id, approved, approval_id);
  if (result.status === "accepted") result = await runner.waitForResult(thread_id);
  res.json(result);
});

app.listen(8081, () => console.log("agent listening on :8081"));

curl -sX POST http://localhost:8081/call-tool \
  -H 'Content-Type: application/json' \
  -d '{"message": "buy 10 shares of AAPL"}'

# → { "status": "pending_approval", "approval_id": "appr_9f…", "thread_id": "b1c2…" }

curl -sX POST http://localhost:8081/resume \
  -H 'Content-Type: application/json' \
  -H "X-Agent-Secret: $AGENT_RESUME_SECRET" \
  -d '{"thread_id": "b1c2…", "approved": true, "approval_id": "appr_9f…"}'

# → { "status": "complete", "result": "Purchase order placed for 10 shares of AAPL." }

const runner = new ApprovalRunner({
  invoke,
  // Decide approvals in-process instead of calling the backend API.
  onApprovalAsync: async (threadId, payload) => {
    return { approval_id: "local_" + threadId };
  },
});

// run() returns pending_approval with that id; resolve the gate however you decide:
await runner.resume(threadId, /* approved */ true, "local_" + threadId);

AEGMIS_OTLP_ENDPOINT=https://obs.aegmis.com   # unset → observability is off
# AEGMIS_ENABLE_TRACING=false                # kill switch, default true

git clone https://github.com/Aegmis/agent-hooks.git
cd agent-hooks
python3 build.py                              # build every port's self-contained hook

bash hooks/<agent>-intrupt-hook/install.sh    # swap <agent> for your CLI

POST /org/{org_id}/approval
Authorization: Bearer sk_org_abc123_xxxx
Content-Type: application/json

{
  "adapter":     "claude",              // ← which coding tool sent this
  "action":      "bash_command",
  "tool_name":   "Bash",
  "tool_kwargs": { "command": "git push --force origin main" },
  "message":     "Claude Code wants to run a shell command",
  "channel":     "slack"
}

{
  "policy_id": "pol_abc123",          // set by the server on creation
  "name": "Large stock purchase",
  "description": "Route big trades to the finance team",
  "enabled": true,

  // Triggers — which tool calls this policy applies to
  "trigger_tool_names": ["purchase_stock"],   // match on tool name
  "trigger_actions":    ["purchase_stock"],   // match on action string

  // Conditions — which kwargs values activate this policy
  "conditions": {
    "logic": "OR",
    "rules": {
      "amount":   { ">": 10000 },
      "quantity": { ">": 100 }
    }
  },

  // Who should approve when this policy matches
  "approver_type": "user",          // "user" or "group"
  "approver_id":   "U012ABC",       // Slack user ID or group ID

  "channel":  "slack",              // notification channel
  "priority": 100,                  // lower = evaluated first
  "created_by": "user_xyz"
}

AEGMIS_API_KEY=sk_org_abc123_xxxxxxxxxxxxxxxx

# Production
AEGMIS_BASE_URL=https://api.aegmis.com

python -c "import secrets; print(secrets.token_hex(32))"

AGENT_RESUME_SECRET=your_64_char_hex_value_here

# Required
AEGMIS_BASE_URL=https://api.aegmis.com
AEGMIS_API_KEY=sk_org_abc123_xxxxxxxxxxxxxxxx

# Approvals — ON by default (real human approval); set false to auto-approve
AEGMIS_APPROVAL=true

# Strongly recommended for production
AGENT_RESUME_SECRET=your_64_char_hex_value_here
AGENT_PUBLIC_URL=https://your-agent.example.com

# Your LLM provider
OPENAI_API_KEY=sk-...
# or
ANTHROPIC_API_KEY=sk-ant-...