@ggoldani/agent-passport-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ggoldani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+authors or copyright holders be liable for any claim, damages or other
+liability, whether in an action of contract, tort or otherwise, arising from,
+out of or in connection with the software or the use or other dealings in the
+software.

package/README.md

@@ -0,0 +1,99 @@
+# @ggoldani/agent-passport-mcp
+
+MCP server for the [AgentPassport](https://github.com/ggoldani/agent-passport) trust registry on Stellar. 18 contract tools + 4 REST API bridge tools + health check.
+
+## Install
+
+```bash
+npm install @ggoldani/agent-passport-mcp
+```
+
+## Setup
+
+Configure your MCP client:
+
+**Cursor / Claude Desktop:**
+```json
+{
+  "mcpServers": {
+    "agent-passport": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["@ggoldani/agent-passport-mcp"],
+      "env": {
+        "STELLAR_NETWORK": "testnet",
+        "STELLAR_CONTRACT_ID": "CAYIR5ON6NDKCQ2KLPFHDJTNKEQHSTJP3ZBMRVV4QPEEAI5ZGLN4A7VQ",
+        "AGENTPASSPORT_API_URL": "http://localhost:3002"
+      }
+    }
+  }
+}
+```
+
+**With write access (admin operations):**
+```json
+{
+  "mcpServers": {
+    "agent-passport": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["@ggoldani/agent-passport-mcp"],
+      "env": {
+        "STELLAR_NETWORK": "testnet",
+        "STELLAR_CONTRACT_ID": "CAYIR5ON6NDKCQ2KLPFHDJTNKEQHSTJP3ZBMRVV4QPEEAI5ZGLN4A7VQ",
+        "STELLAR_SECRET_KEY": "S...",
+        "AGENTPASSPORT_API_URL": "http://localhost:3002"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Required | Default | Purpose |
+|----------|----------|---------|---------|
+| `STELLAR_NETWORK` | No | `testnet` | Stellar network |
+| `STELLAR_CONTRACT_ID` | Yes | — | Deployed contract ID |
+| `STELLAR_RPC_URL` | No | Network default | Soroban RPC URL |
+| `STELLAR_SECRET_KEY` | No | — | For write operations |
+| `AGENTPASSPORT_API_URL` | No | `http://localhost:3002` | REST API base URL |
+
+## Tools
+
+### Contract Tools (18)
+Auto-generated from contract WASM via `@ggoldani/stellarmcp`. All prefixed with `ap_`:
+
+| Tool | Description |
+|------|-------------|
+| `ap_get_agent` | Fetch agent profile by address |
+| `ap_list_agents` | Paginated agent list |
+| `ap_get_config` | Contract configuration |
+| `ap_get_relayers` | Authorized relayers |
+| `ap_get_rating` | Rating for an interaction |
+| `ap_list_agent_interactions` | Interaction history |
+| `ap_register_agent` | Register new agent |
+| `ap_update_profile` | Update agent profile |
+| `ap_deregister_agent` | Remove agent |
+| `ap_register_interaction` | Record interaction |
+| `ap_submit_rating` | Rate an interaction (1-100) |
+| `ap_add_relayer` | Authorize relayer |
+| `ap_remove_relayer` | Revoke relayer |
+| `ap_transfer_admin` | Initiate admin transfer |
+| `ap_accept_admin` | Accept admin transfer |
+| `ap_cancel_admin_transfer` | Cancel pending transfer |
+| `ap_init` | Initialize contract |
+
+### API Bridge Tools (4)
+Wrap the REST API for enriched data:
+- `agent_search` — Full-text search with filters
+- `agent_analytics` — Volume, score trajectory, rating breakdown
+- `agent_badge_stats` — Trust badge data
+- `agent_trust_check` — Quick trust verification
+
+### Health (1)
+- `health` — MCP server status check
+
+## License
+
+MIT

package/build/api-bridge/analytics.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const analyticsSchema: z.ZodObject<{
+    address: z.ZodString;
+    period: z.ZodOptional<z.ZodEnum<{
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        all: "all";
+    }>>;
+}, z.core.$strip>;
+export type AnalyticsParams = z.infer<typeof analyticsSchema>;
+interface AnalyticsResponse {
+    address: string;
+    period: string;
+    volume_over_time: Array<{
+        date: string;
+        volume: string;
+    }>;
+    counterparty_growth: Array<{
+        date: string;
+        unique_counterparties: number;
+    }>;
+    score_trajectory: Array<{
+        date: string;
+        score: number;
+    }>;
+    rating_breakdown: {
+        quality: {
+            avg: number;
+            count: number;
+        };
+        speed: {
+            avg: number;
+            count: number;
+        };
+        reliability: {
+            avg: number;
+            count: number;
+        };
+        communication: {
+            avg: number;
+            count: number;
+        };
+    };
+    summary: {
+        total_volume: string;
+        total_interactions: number;
+        unique_counterparties: number;
+        avg_rating: number;
+    };
+}
+export declare function agentAnalytics(params: AnalyticsParams): Promise<AnalyticsResponse>;
+export {};

package/build/api-bridge/analytics.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { apiFetch, validateStellarAddress } from "./client.js";
+export const analyticsSchema = z.object({
+    address: z.string().describe("Stellar address of the agent (G...)"),
+    period: z.enum(["7d", "30d", "90d", "all"]).optional().describe("Time period for analytics"),
+});
+export async function agentAnalytics(params) {
+    validateStellarAddress(params.address);
+    const query = {};
+    if (params.period)
+        query.period = params.period;
+    return apiFetch(`/agents/${params.address}/stats`, query);
+}

package/build/api-bridge/badge.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const badgeSchema: z.ZodObject<{
+    address: z.ZodString;
+}, z.core.$strip>;
+export type BadgeParams = z.infer<typeof badgeSchema>;
+interface BadgeStatsResponse {
+    address: string;
+    name: string;
+    trust_tier: string;
+    score: number;
+    verified_interactions_count: number;
+    total_economic_volume: string;
+    total_counterparties: number;
+}
+export declare function agentBadgeStats(params: BadgeParams): Promise<BadgeStatsResponse>;
+export {};

package/build/api-bridge/badge.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { apiFetch, validateStellarAddress } from "./client.js";
+export const badgeSchema = z.object({
+    address: z.string().describe("Stellar address of the agent (G...)"),
+});
+export async function agentBadgeStats(params) {
+    validateStellarAddress(params.address);
+    return apiFetch(`/badge-stats/${params.address}`);
+}

package/build/api-bridge/client.d.ts

@@ -0,0 +1,3 @@
+export declare function validateStellarAddress(address: string): void;
+export declare function getApiUrl(): string;
+export declare function apiFetch<T>(path: string, params?: Record<string, string>): Promise<T>;

package/build/api-bridge/client.js

@@ -0,0 +1,50 @@
+const STELLAR_ADDRESS_RE = /^G[A-Z2-7]{55}$/;
+export function validateStellarAddress(address) {
+    if (!STELLAR_ADDRESS_RE.test(address)) {
+        if (!address.startsWith("G")) {
+            throw new Error(`"${address}" is not a valid Stellar public key. Stellar addresses start with "G" followed by 56 characters (e.g., GBVDQYSFGXEACZD7LG3NI7UAGLOP72D5SDDNJTHHWHD5EYDZHTPLG2IR). Make sure you're passing the agent's public key, not a secret key or contract ID.`);
+        }
+        throw new Error(`"${address}" looks like a Stellar address but has the wrong length (got ${address.length}, expected 56). Stellar public keys are 56 characters starting with "G" (e.g., GBVDQYSFGXEACZD7LG3NI7UAGLOP72D5SDDNJTHHWHD5EYDZHTPLG2IR). Double-check the address and try again.`);
+    }
+}
+export function getApiUrl() {
+    const url = process.env.AGENTPASSPORT_API_URL || "http://localhost:3002";
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+        throw new Error(`AGENTPASSPORT_API_URL must be a valid URL starting with "http://" or "https://". Got: "${url}".`);
+    }
+    return url.replace(/\/+$/, "");
+}
+export async function apiFetch(path, params) {
+    const baseUrl = getApiUrl();
+    const url = new URL(path, baseUrl);
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== "") {
+                url.searchParams.set(key, value);
+            }
+        }
+    }
+    try {
+        const res = await fetch(url.toString());
+        if (!res.ok) {
+            const body = await res.text().catch(() => "unknown error");
+            if (res.status === 404) {
+                throw new Error(`No agent found at this address. The agent may not be registered on AgentPassport yet, or the address might be incorrect. You can search for registered agents using the agent_search tool.`);
+            }
+            if (res.status === 429) {
+                throw new Error(`Too many requests — the AgentPassport API is rate-limiting this client. Wait a moment and try again.`);
+            }
+            if (res.status >= 500) {
+                throw new Error(`The AgentPassport API server encountered an internal error (HTTP ${res.status}). This is not your fault — try again in a few moments. If it persists, check the AgentPassport status page or server logs.`);
+            }
+            throw new Error(`The AgentPassport API returned an error (HTTP ${res.status}): ${body.slice(0, 200)}`);
+        }
+        return (await res.json());
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            throw new Error(`Could not reach the AgentPassport API at ${baseUrl}. Make sure the API server is running and accessible. If you're running it locally, start it with "npm run start:api" from the project root. You can also set AGENTPASSPORT_API_URL to point to a different server.`);
+        }
+        throw error;
+    }
+}

package/build/api-bridge/index.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerApiBridgeTools(server: McpServer): void;

package/build/api-bridge/index.js

@@ -0,0 +1,66 @@
+import { searchSchema, agentSearch } from "./search.js";
+import { analyticsSchema, agentAnalytics } from "./analytics.js";
+import { badgeSchema, agentBadgeStats } from "./badge.js";
+import { trustCheckSchema, agentTrustCheck } from "./trust-check.js";
+export function registerApiBridgeTools(server) {
+    server.tool("agent_search", "Search agents with full-text search and filters (score, tags, interactions, volume). Returns paginated results with trust tiers.", searchSchema.shape, async (params) => {
+        try {
+            const result = await agentSearch(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `agent_search failed: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("agent_analytics", "Get analytics for an agent — volume over time, score trajectory, rating breakdown, and summary stats.", analyticsSchema.shape, async (params) => {
+        try {
+            const result = await agentAnalytics(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `agent_analytics failed: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("agent_badge_stats", "Get trust badge data for an agent — trust tier, score, interactions, counterparties, volume. Use for embedding trust badges.", badgeSchema.shape, async (params) => {
+        try {
+            const result = await agentBadgeStats(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `agent_badge_stats failed: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("agent_trust_check", "Quick trust verification — check if an agent meets minimum score and interaction thresholds. Returns pass/fail with reasons.", trustCheckSchema.shape, async (params) => {
+        try {
+            const result = await agentTrustCheck(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `agent_trust_check failed: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/build/api-bridge/search.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const searchSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodString>;
+    minScore: z.ZodOptional<z.ZodNumber>;
+    maxScore: z.ZodOptional<z.ZodNumber>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        score: "score";
+        interactions: "interactions";
+        volume: "volume";
+        newest: "newest";
+        relevance: "relevance";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SearchParams = z.infer<typeof searchSchema>;
+interface AgentResponse {
+    owner_address: string;
+    name: string;
+    description: string;
+    tags: string;
+    score: number;
+    verified_interactions_count: number;
+    trust_tier: string;
+}
+interface PaginatedResponse {
+    data: AgentResponse[];
+    total: number;
+    has_more: boolean;
+}
+export declare function agentSearch(params: SearchParams): Promise<PaginatedResponse>;
+export {};

package/build/api-bridge/search.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { apiFetch } from "./client.js";
+export const searchSchema = z.object({
+    q: z.string().optional().describe("Full-text search query"),
+    tags: z.string().optional().describe("Comma-separated tags to filter"),
+    minScore: z.number().int().min(0).max(100).optional().describe("Minimum score filter"),
+    maxScore: z.number().int().min(0).max(100).optional().describe("Maximum score filter"),
+    sortBy: z.enum(["score", "interactions", "volume", "newest", "relevance"]).optional().describe("Sort field"),
+    limit: z.number().int().min(1).max(50).optional().describe("Results per page (1-50)"),
+});
+export async function agentSearch(params) {
+    const query = {};
+    if (params.q)
+        query.q = params.q;
+    if (params.tags)
+        query.tags = params.tags;
+    if (params.minScore !== undefined)
+        query.minScore = String(params.minScore);
+    if (params.maxScore !== undefined)
+        query.maxScore = String(params.maxScore);
+    if (params.sortBy)
+        query.sortBy = params.sortBy;
+    if (params.limit !== undefined)
+        query.limit = String(params.limit);
+    return apiFetch("/agents", query);
+}

package/build/api-bridge/trust-check.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const trustCheckSchema: z.ZodObject<{
+    address: z.ZodString;
+    minScore: z.ZodOptional<z.ZodNumber>;
+    minInteractions: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TrustCheckParams = z.infer<typeof trustCheckSchema>;
+interface TrustCheckResponse {
+    passed: boolean;
+    reasons: string[];
+    trust_tier: string;
+    score: number;
+    verified_interactions_count: number;
+}
+export declare function agentTrustCheck(params: TrustCheckParams): Promise<TrustCheckResponse>;
+export {};

package/build/api-bridge/trust-check.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { apiFetch, validateStellarAddress } from "./client.js";
+export const trustCheckSchema = z.object({
+    address: z.string().describe("Stellar address of the agent (G...)"),
+    minScore: z.number().int().min(0).max(100).optional().describe("Minimum trust score required"),
+    minInteractions: z.number().int().min(0).optional().describe("Minimum verified interactions required"),
+});
+export async function agentTrustCheck(params) {
+    validateStellarAddress(params.address);
+    const query = {};
+    if (params.minScore !== undefined)
+        query.minScore = String(params.minScore);
+    if (params.minInteractions !== undefined)
+        query.minInteractions = String(params.minInteractions);
+    return apiFetch(`/trust-check/${params.address}`, query);
+}

package/build/generated/src/config.d.ts

@@ -0,0 +1,14 @@
+export type AutoSignPolicy = "safe" | "guarded" | "expert";
+export interface AppConfig {
+    network: "mainnet" | "testnet";
+    rpcUrl?: string;
+    horizonUrl?: string;
+    requestTimeoutMs: number;
+    contractId: string;
+    secretKey?: string;
+    autoSignPolicy?: AutoSignPolicy;
+    autoSign: boolean;
+    autoSignLimit: number;
+    networkPassphrase: string;
+}
+export declare function loadConfig(): AppConfig;

package/build/generated/src/config.js

@@ -0,0 +1,39 @@
+import { Networks, StrKey } from "@stellar/stellar-sdk";
+import { z } from "zod";
+const EnvSchema = z.object({
+    STELLAR_NETWORK: z.enum(["mainnet", "testnet"]).default("testnet"),
+    STELLAR_RPC_URL: z.string().url().optional(),
+    STELLAR_HORIZON_URL: z.string().url().optional(),
+    STELLAR_REQUEST_TIMEOUT_MS: z.coerce.number().int().positive().max(30_000).default(30_000),
+    STELLAR_CONTRACT_ID: z
+        .string()
+        .trim()
+        .min(1)
+        .refine((value) => StrKey.isValidContract(value), {
+        message: "Invalid Soroban contract id (expected C... contract strkey)."
+    }),
+    STELLAR_SECRET_KEY: z.string().optional(),
+    STELLAR_AUTO_SIGN_POLICY: z.enum(["safe", "guarded", "expert"]).optional(),
+    STELLAR_AUTO_SIGN: z.coerce.boolean().default(false),
+    STELLAR_AUTO_SIGN_LIMIT: z.coerce.number().min(0).default(0)
+});
+export function loadConfig() {
+    const parsed = EnvSchema.safeParse(process.env);
+    if (!parsed.success) {
+        throw new Error(`Invalid environment: ${parsed.error.message}`);
+    }
+    const env = parsed.data;
+    const passphrase = env.STELLAR_NETWORK === "mainnet" ? Networks.PUBLIC : Networks.TESTNET;
+    return {
+        network: env.STELLAR_NETWORK,
+        rpcUrl: env.STELLAR_RPC_URL,
+        horizonUrl: env.STELLAR_HORIZON_URL,
+        requestTimeoutMs: env.STELLAR_REQUEST_TIMEOUT_MS,
+        contractId: env.STELLAR_CONTRACT_ID,
+        secretKey: env.STELLAR_SECRET_KEY,
+        autoSignPolicy: env.STELLAR_AUTO_SIGN_POLICY,
+        autoSign: env.STELLAR_AUTO_SIGN,
+        autoSignLimit: env.STELLAR_AUTO_SIGN_LIMIT,
+        networkPassphrase: passphrase
+    };
+}

package/build/generated/src/generated/meta.d.ts

@@ -0,0 +1,10 @@
+/** Generator metadata and compatibility expectations. */
+export declare const GENERATOR_ARTIFACT_VERSION = "1";
+export declare const STELLARMCP_GENERATOR_SEMVER = "0.1.7";
+export declare const SPEC_FINGERPRINT = "8eb756002ea822fe";
+/**
+ * Compatibility: this layout (artifact v1) targets MCP SDK and Stellar SDK versions
+ * pinned by the generating StellarMCP release (`0.1.7`). Re-run code generation after upgrading
+ * the parent generator or changing the contract interface.
+ */
+export declare const COMPATIBILITY_NOTE = "Generated package must use the same major MCP protocol expectations as @modelcontextprotocol/sdk v1.x and @stellar/stellar-sdk v14.x family unless you regenerate with a newer stellarmcp-generate.";

package/build/generated/src/generated/meta.js

@@ -0,0 +1,10 @@
+/** Generator metadata and compatibility expectations. */
+export const GENERATOR_ARTIFACT_VERSION = "1";
+export const STELLARMCP_GENERATOR_SEMVER = "0.1.7";
+export const SPEC_FINGERPRINT = "8eb756002ea822fe";
+/**
+ * Compatibility: this layout (artifact v1) targets MCP SDK and Stellar SDK versions
+ * pinned by the generating StellarMCP release (`0.1.7`). Re-run code generation after upgrading
+ * the parent generator or changing the contract interface.
+ */
+export const COMPATIBILITY_NOTE = "Generated package must use the same major MCP protocol expectations as @modelcontextprotocol/sdk v1.x and @stellar/stellar-sdk v14.x family unless you regenerate with a newer stellarmcp-generate.";

package/build/generated/src/generated/schemas.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+export declare const initInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    admin: z.ZodString;
+    authorized_relayer: z.ZodString;
+};
+export declare const get_agentInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    owner_address: z.ZodString;
+};
+export declare const get_configInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+};
+export declare const get_ratingInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    interaction_tx_hash: z.ZodString;
+};
+export declare const add_relayerInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    admin: z.ZodString;
+    relayer: z.ZodString;
+};
+export declare const list_agentsInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    from: z.ZodNumber;
+    limit: z.ZodNumber;
+};
+export declare const accept_adminInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    new_admin: z.ZodString;
+};
+export declare const get_relayersInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+};
+export declare const submit_ratingInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    rating: z.ZodUnknown;
+};
+export declare const register_agentInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    owner_address: z.ZodString;
+    input: z.ZodUnknown;
+};
+export declare const remove_relayerInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    admin: z.ZodString;
+    relayer: z.ZodString;
+};
+export declare const transfer_adminInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    admin: z.ZodString;
+    new_admin: z.ZodString;
+};
+export declare const update_profileInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    owner_address: z.ZodString;
+    input: z.ZodUnknown;
+};
+export declare const deregister_agentInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    owner_address: z.ZodString;
+};
+export declare const register_interactionInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    relayer: z.ZodString;
+    interaction: z.ZodUnknown;
+};
+export declare const cancel_admin_transferInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    admin: z.ZodString;
+};
+export declare const list_agent_interactionsInputSchema: {
+    contractId: z.ZodOptional<z.ZodString>;
+    sourceAccount: z.ZodString;
+    provider_address: z.ZodString;
+    from_seq: z.ZodNumber;
+    limit: z.ZodNumber;
+};