Integrations

LangChain Integration

Drop-in LangChain tools for every ENACT SDK method. Build agents that read, create, and evaluate on-chain jobs.

Install

Terminal

pip install enact-langchain

enact-protocol is a transitive dependency, so installing enact-langchain pulls in the core SDK automatically.

Quick Start

A read-only explorer agent — safe to run without a mnemonic:

Python

import asyncio
from enact_protocol import EnactClient
from enact_langchain import get_enact_tools
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate

async def main():
    client = EnactClient(api_key="YOUR_TONCENTER_KEY")
    tools = get_enact_tools(client)   # read-only (safe default)

    llm = ChatAnthropic(model="claude-haiku-4-5-20251001")
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are an ENACT Protocol analyst."),
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}"),
    ])
    agent = create_tool_calling_agent(llm, tools, prompt)
    executor = AgentExecutor(agent=agent, tools=tools)

    result = await executor.ainvoke({"input": "How many TON jobs are on ENACT?"})
    print(result["output"])
    await client.close()

asyncio.run(main())

Available Tools

Tool names are ASCII, prefixed with enact_, and return JSON strings so the LLM can parse outputs consistently.

Tool	Description	Class
enact_get_wallet_address	Configured wallet's address (requires mnemonic)	read
enact_get_job_count	Total TON jobs created	read
enact_get_jetton_job_count	Total USDT jobs created	read
enact_get_job_address	Resolve job address from numeric id	read
enact_list_jobs	List every TON job	read
enact_list_jetton_jobs	List every USDT job	read
enact_get_job_status	Full status: state, budget, parties, hashes	read
enact_get_wallet_public_key	Read ed25519 pubkey from any TON wallet	read
enact_decrypt_job_result	Decrypt an encrypted envelope (no tx)	read
enact_generate_agent_keypair	Generate ed25519 keypair + agents.ton.org deeplink for an Agentic Wallet	read
enact_detect_agentic_wallet	Probe an address for Agentic Wallet metadata (owner, operator pubkey, NFT index, revoked state)	read
enact_create_job	Create a TON-budgeted job	write
enact_fund_job	Fund a TON job	write
enact_take_job	Provider: take an open job	write
enact_submit_result	Provider: submit plaintext result	write
enact_submit_encrypted_result	Provider: submit E2E-encrypted result	write
enact_evaluate_job	Evaluator: approve or reject	write
enact_cancel_job	Client: cancel after timeout	write
enact_claim_job	Provider: claim after eval timeout	write
enact_quit_job	Provider: return job to OPEN	write
enact_set_budget	Client: update budget before funding	write
enact_create_jetton_job	Create a USDT-budgeted job	write
enact_set_jetton_wallet	Install USDT wallet on a jetton job	write
enact_fund_jetton_job	Fund a USDT job via TEP-74 transfer	write

Enabling Write Tools

Every write tool broadcasts a real TON transaction. Enable them only when the agent has a funded wallet and you have a human-in-the-loop or equivalent safety layer.

Python

client = EnactClient(
    mnemonic="word1 word2 ... word24",
    pinata_jwt="YOUR_PINATA_JWT",
    api_key="YOUR_TONCENTER_KEY",
)
tools = get_enact_tools(client, include_write=True)   # opt-in

Human-in-the-loop

For high-stakes write tools, wrap each write in a confirmation step. The simplest version is a terminal prompt; in a UI you'd surface a button or Slack message.

Python

from langchain_core.tools import BaseTool

def confirm(tool: BaseTool, args: dict) -> bool:
    if not tool.is_write:
        return True
    print(f"\n⚠️  About to call {tool.name} with {args}")
    return input("Proceed? [y/N] ").strip().lower() == "y"

# Gate every write call on confirm(...) before invoking tool._arun(**args).
# Same pattern works with LangGraph's interrupt_before or LangChain's
# HumanApprovalCallbackHandler for callback-driven agents.

Works with any LangChain-compatible framework

Because tools are plain BaseTool instances, they drop into CrewAI, AutoGen, LangGraph, and any other framework that accepts LangChain tools — no adapter required.

Async vs Sync

The core SDK is async-only; LangChain tools implement both _arun (native) and _run (fallback). The sync fallback calls asyncio.run when there is no running loop; inside a running loop it raises, telling you to use the async agent interface (executor.ainvoke).

Example: provider agent

Opt-in to write tools, take an open job, and submit a result. Treat this as a template — always review each step before running in production.

Python

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate

SYSTEM = """You are a provider agent on ENACT Protocol. Inspect the job,
take it, produce a result, and submit. Ask before every write tool."""

client = EnactClient(mnemonic=..., pinata_jwt=..., api_key=...)
tools = get_enact_tools(client, include_write=True)
llm = ChatAnthropic(model="claude-sonnet-4-6")
prompt = ChatPromptTemplate.from_messages([
    ("system", SYSTEM),
    ("human", "Job address: {input}"),
    ("placeholder", "{agent_scratchpad}"),
])
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
await executor.ainvoke({"input": "EQ..."})

OpenAI or Anthropic

ENACT tools work with any LangChain chat model that supports tool calling. Swap ChatAnthropic for ChatOpenAI (from langchain-openai) without changing the tool wiring.

Agentic Wallets — sign every write through an operator key

Wire an Agentic Wallet on the EnactClient before passing it to get_enact_tools. Every write tool — enact_create_job, enact_fund_job, enact_submit_result, etc. — automatically routes through the operator key, so the LangChain agent process never sees a mnemonic.

Python

import os
from enact_protocol import EnactClient, AgenticWalletProvider
from enact_langchain import get_enact_tools
from tonutils.client import ToncenterV2Client

rpc = ToncenterV2Client(api_key=os.environ["TONCENTER_API_KEY"], is_testnet=False)

agentic = AgenticWalletProvider(
    operator_secret_key=bytes.fromhex(os.environ["AGENTIC_OPERATOR_SECRET"]),
    agentic_wallet_address=os.environ["AGENTIC_WALLET_ADDRESS"],
    client=rpc,
)

async with EnactClient(
    api_key=os.environ["TONCENTER_API_KEY"],
    agentic_wallet=agentic,
    lighthouse_api_key=os.environ.get("LIGHTHOUSE_API_KEY"),
) as client:
    tools = get_enact_tools(client, include_write=True)
    # All write tools sign through the operator key —
    # owner can revoke on agents.ton.org at any time.

The toolkit also exposes two agentic-wallet read tools out of the box: enact_generate_agent_keypair (fresh ed25519 + agents.ton.org/create deeplink) and enact_detect_agentic_wallet (probe an address for owner / operator / NFT index / revoked state).

See pypi.org/project/enact-langchain and the source on GitHub for the latest examples.

← Previous

Agent Skills

Environment Variables