Operate one policy across the full agent boundary.

from imladri import Imladri

imladri = Imladri.from_env()

@imladri.action("cloud.deploy", strict_preflight=True)
def deploy_release(release):
    return deployer.deploy(release)

tools = imladri.wrap_tools(
    {"customer.read": customer_lookup, "email.send": send_email},
    strict_tools=["email.send"],
)

intent = {"service": release.service, "version": release.version}
imladri.preflight("cloud.deploy", intent=intent)
deployer.deploy(release)

const agent = new ConstitutionalAgent({
  agentId: process.env.IMLADRI_AGENT_ID!,
  apiKey: process.env.IMLADRI_API_KEY!,
  apiUrl: process.env.IMLADRI_API_URL!,
  preflightUrl: process.env.IMLADRI_PREFLIGHT_URL,
});

const deployRelease = agent.action(
  "cloud.deploy",
  async (changeSet: ReleasePlan) => cloud.deploy(changeSet),
  {
    strictPreflight: true,
    intent: (changeSet) => ({ service: changeSet.service, version: changeSet.version }),
  },
);

await agent.runSandboxedAction("deploy.preview", {
  command: "node",
  args: ["scripts/check-release.mjs"],
  workspaceFiles: [{ path: "plan.json", content: "{}" }],
  outputPaths: ["reports/preview.txt"],
});

import {
  ConstitutionalAgent,
  createLangChainMiddleware,
  createOpenAIAgentsToolGuard,
  normalizeOpenAIAgentsToolName,
  wrapLangChainTools,
  wrapLangGraphNodes,
  wrapLlamaIndexTools,
  wrapOpenAIAgentsTools,
  wrapVercelAITools,
  wrapMastraTools,
} from "@imladri/sdk";
import { Agent, tool as openAIAgentsTool } from "@openai/agents";
import { tool as aiTool } from "ai";
import { FunctionTool as LlamaIndexFunctionTool } from "llamaindex";
import { tool } from "langchain";
import { traceable } from "langsmith/traceable";
import * as z from "zod";

const agent = new ConstitutionalAgent({ agentId, apiKey, apiUrl, preflightUrl });

const tracedCustomerLookup = tool(
  traceable(async ({ customerId }) => `customer:${customerId}`, {
    name: "customer.lookup",
    run_type: "tool",
  }),
  {
    name: "customer.lookup",
    description: "Look up a customer by id.",
    schema: z.object({ customerId: z.string() }),
  },
);

const guardedLangChainTools = wrapLangChainTools(agent, [tracedCustomerLookup], {
  strictTools: ["credential.export", "cloud.deploy"],
});

const langChainMiddleware = createLangChainMiddleware(agent);
// Pass middleware to the LangChain JS agent setup that owns raw tool dispatch.

const exportAction = "credential.export";
const exportToolName = normalizeOpenAIAgentsToolName(exportAction);
const guardedOpenAITools = wrapOpenAIAgentsTools(agent, [
  openAIAgentsTool({
    name: exportToolName,
    description: "Export a credential bundle after approval.",
    parameters: z.object({ systemId: z.string() }),
    execute: async ({ systemId }) => ({ ok: true, systemId }),
  }),
], {
  strictTools: [exportAction],
  actionAliases: { [exportToolName]: exportAction },
});

const openAIAgent = new Agent({
  name: "Credential operator",
  instructions: "Use tools only for approved workflows.",
  tools: guardedOpenAITools,
});

const openAIGuard = createOpenAIAgentsToolGuard(agent, {
  strictTools: [exportAction],
  actionAliases: { [exportToolName]: exportAction },
});

const guardedGraphNodes = wrapLangGraphNodes(agent, nodes, {
  strictTools: ["secrets.read"],
});

const guardedVercelTools = wrapVercelAITools(agent, {
  sendEmail: aiTool({
    description: "Send a customer email after approval.",
    inputSchema: z.object({ to: z.string().email(), body: z.string() }),
    execute: async ({ to, body }, { toolCallId }) => ({ sent: to, toolCallId }),
  }),
}, {
  strictTools: ["email.send"],
  actionAliases: { sendEmail: "email.send" },
});

const guardedLlamaTools = wrapLlamaIndexTools(agent, [
  LlamaIndexFunctionTool.from(
    ({ customerId }) => ({ exported: customerId }),
    { name: "customerExport", description: "Export approved customer data." },
  ),
], {
  strictTools: ["customer.data.export"],
  actionAliases: { customerExport: "customer.data.export" },
});

const guardedMastraTools = wrapMastraTools(agent, mastraTools, {
  strictTools: ["cloud.deploy.production"],
});

from crewai.tools import tool as crewai_tool
from crewai.tools.base_tool import Tool
from crewai.tools.structured_tool import CrewStructuredTool
from imladri.adapters import wrap_crewai_tools

@crewai_tool("customer_export")
def customer_export(customer_id: str) -> str:
    """Export approved customer data."""
    return f"exported:{customer_id}"

def summarize_ticket(ticket_id: str) -> dict:
    return {"summary": ticket_id}

def lookup_inventory(sku: str) -> dict:
    return {"sku": sku, "available": True}

guarded_crewai_tools = wrap_crewai_tools(
    agent,
    [
        customer_export,
        Tool(name="ticket_summarize", description="Summarize ticket", func=summarize_ticket),
        CrewStructuredTool.from_function(
            func=lookup_inventory,
            name="inventory_lookup",
            description="Look up inventory",
        ),
    ],
    strict_tools=["customer.data.export"],
    action_aliases={
        "customer_export": "customer.data.export",
        "ticket_summarize": "ticket.summarize",
        "inventory_lookup": "inventory.lookup",
    },
)

# Pass guarded_crewai_tools into the CrewAI Agent/Task/Crew path that owns execution.

from haystack import Pipeline, component
from imladri.adapters import wrap_haystack_components

@component
class CustomerExport:
    @component.output_types(result=dict)
    def run(self, customer_id: str):
        return {"result": {"exported": customer_id}}

@component
class TicketSummarizer:
    @component.output_types(result=dict)
    def run(self, ticket_id: str):
        return {"result": {"summary": ticket_id}}

guarded_haystack_components = wrap_haystack_components(
    agent,
    {
        "customer_export": CustomerExport(),
        "ticket_summarize": TicketSummarizer(),
    },
    strict_tools=["customer.data.export"],
    action_aliases={
        "customer_export": "customer.data.export",
        "ticket_summarize": "ticket.summarize",
    },
)

pipeline = Pipeline()
pipeline.add_component("ticket_summarize", guarded_haystack_components["ticket_summarize"])

direct_result = guarded_haystack_components["customer_export"].run(customer_id="cust_123")
pipeline_result = pipeline.run({"ticket_summarize": {"ticket_id": "T-100"}})

from autogen_core import CancellationToken
from autogen_core.tools import FunctionTool
from imladri.adapters import wrap_autogen_tools

def customer_lookup(customer_id: str) -> dict:
    return {"customer_id": customer_id}

def credential_export(system_id: str) -> dict:
    return {"exported": system_id}

guarded_autogen_tools = wrap_autogen_tools(
    agent,
    [
        FunctionTool(customer_lookup, description="Lookup customer", name="customer_lookup"),
        FunctionTool(credential_export, description="Export credential bundle", name="credential_export"),
    ],
    strict_tools=["customer.lookup"],
    action_aliases={
        "customer_lookup": "customer.lookup",
        "credential_export": "credential.export",
    },
)

# Await run_json or run inside the AutoGen async execution path.
result = await guarded_autogen_tools[0].run_json(
    {"customer_id": "cust_123"},
    CancellationToken(),
)

from pydantic_ai import Agent, FunctionToolset, Tool
from pydantic_ai.models.test import TestModel
from imladri.adapters import wrap_pydanticai_tools

def customer_lookup(customer_id: str) -> dict:
    return {"customer_id": customer_id}

def ticket_summarize(ticket_id: str) -> dict:
    return {"ticket_id": ticket_id}

guarded_pydanticai_tools = wrap_pydanticai_tools(
    agent,
    [
        Tool(customer_lookup, name="customer_lookup", description="Lookup customer"),
        FunctionToolset([
            Tool(ticket_summarize, name="ticket_summarize", description="Summarize ticket"),
        ]),
    ],
    strict_tools=["customer.lookup"],
    action_aliases={
        "customer_lookup": "customer.lookup",
        "ticket_summarize": "ticket.summarize",
    },
)

test_agent = Agent(
    TestModel(call_tools=["customer_lookup"]),
    tools=[guarded_pydanticai_tools[0]],
)
result = test_agent.run_sync("Look up the approved customer.")

from semantic_kernel import Kernel
from semantic_kernel.functions import KernelArguments, KernelFunction, KernelPlugin, kernel_function
from imladri.adapters import wrap_semantic_kernel_functions

@kernel_function(name="customer_lookup", description="Lookup customer")
def customer_lookup(customer_id: str) -> dict:
    return {"customer_id": customer_id}

@kernel_function(name="ticket_summarize", description="Summarize ticket")
def ticket_summarize(ticket_id: str) -> dict:
    return {"ticket_id": ticket_id}

guarded_kernel_functions = wrap_semantic_kernel_functions(
    agent,
    [
        KernelFunction.from_method(customer_lookup, plugin_name="support"),
        KernelPlugin(
            name="support",
            functions=[KernelFunction.from_method(ticket_summarize, plugin_name="support")],
        ),
    ],
    strict_tools=["customer.lookup"],
    action_aliases={
        "customer_lookup": "customer.lookup",
        "ticket_summarize": "ticket.summarize",
    },
)

result = await guarded_kernel_functions[0].invoke(
    Kernel(),
    KernelArguments(customer_id="cust_123"),
)

# MCP server uses short-lived authority from an approved customer workspace
IMLADRI_AGENT_ID=<agent-id> \
IMLADRI_AUTHORITY_TOKEN=<workspace-issued-token> \
IMLADRI_WORKER_URL=https://<worker> \
node mcp-server/server.mjs

# Access preview keeps scanner artifacts local
imladri scan init-ci --provider gitlab --output .gitlab-ci-imladri.yml

IMLADRI_SCAN_WORKER_URL=https://<worker> \
IMLADRI_SCAN_AGENT_ID=<agent-id> \
IMLADRI_SCAN_SDK_KEY=<profile-sdk-key> \
imladri scan --path . \
  --config .imladri-scan.json \
  --format json \
  --output imladri-boundary.json \
  --fail-on new

# Customers can export a signed proof packet during onboarding
imladri proof export --format json --output imladri-proof.json