caddie-mcp 0.1.0

package/dist/tools/runs.js

@@ -0,0 +1,248 @@
+import { z } from "zod";
+import { request, parseJsonParam, truncateResponse } from "../client.js";
+import { ACTION_TYPE_RE, definitionSchema, payloadSchema, validateWorkflowId, validateRunId, auditLog, } from "./shared.js";
+const MAX_RESULT_BYTES = 50_000;
+const TRUNCATION_SUFFIX = `Re-run with a smaller inputs.limit or add inputs.chainIds/inputs.filters to reduce results. ` +
+    `Use inputs.offset with nextOffset from the result to paginate.`;
+function truncateResult(text) {
+    const buf = Buffer.from(text, "utf8");
+    if (buf.length <= MAX_RESULT_BYTES)
+        return text;
+    return (buf.subarray(0, MAX_RESULT_BYTES).toString("utf8") +
+        `\n...(truncated — ${buf.length} bytes total. ${TRUNCATION_SUFFIX})`);
+}
+export function registerRunTools(s) {
+    s.registerTool("b3os_run_workflow", {
+        description: `Trigger execution of a saved workflow. Returns a runId that you can track with
+b3os_get_run. The workflow must be published (status: "active") to run.
+
+Pass an optional payload for manual triggers that expect input data (e.g., a wallet
+address, token symbol, or other parameters).`,
+        inputSchema: {
+            workflowId: z.string().describe("Workflow ID to run"),
+            payload: payloadSchema
+                .optional()
+                .describe("Optional trigger payload data (for manual triggers that expect input)"),
+        },
+    }, async ({ workflowId, payload }) => {
+        validateWorkflowId(workflowId);
+        auditLog("RUN", `workflow ${workflowId}`);
+        const body = {};
+        if (payload !== undefined)
+            body.payload = parseJsonParam(payload, "payload");
+        const result = await request(`/v1/workflows/${workflowId}/run`, {
+            method: "POST",
+            body: Object.keys(body).length > 0 ? body : undefined,
+        });
+        if (!result?.runId)
+            throw new Error(`Failed to trigger workflow ${workflowId}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Workflow triggered. Run ID: ${result.runId}\n\nUse b3os_get_run to check the result.`,
+                },
+            ],
+        };
+    });
+    s.registerTool("b3os_run_action", {
+        description: `Execute a single action immediately and return its result.
+
+Simpler than b3os_run_ephemeral — no workflow definition needed.
+Provide the action type and its inputs directly.
+
+Use for one-shot lookups: "get ETH price", "fetch wallet balances",
+"look up a token address". For multi-step workflows or if-node branching,
+use b3os_run_ephemeral instead.
+
+PAGINATION: Actions that return lists (e.g. wallet balances, market results) support
+inputs.limit and inputs.offset. For wallet balance actions, always pass a limit (e.g.
+limit: 20) and filter with chainIds or filters to avoid oversized responses. Use the
+nextOffset field from the result to fetch the next page.
+
+Action types use hyphens only (e.g. "coingecko-get-token-price", "sim-dune-get-wallet-balances").
+Use b3os_search_actions to discover available action types.`,
+        inputSchema: {
+            actionType: z
+                .string()
+                .describe('Action type ID — hyphens only, no slashes (e.g. "coingecko-get-token-price", "sim-dune-get-wallet-balances")'),
+            inputs: z.any().optional().describe("Action input payload"),
+            connectorId: z.string().optional().describe("Connector ID for authenticated actions"),
+        },
+    }, async ({ actionType, inputs, connectorId }) => {
+        if (!ACTION_TYPE_RE.test(actionType)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Invalid actionType format: "${actionType}". Use b3os_search_actions to find valid action types.`,
+                    },
+                ],
+            };
+        }
+        const body = {
+            inputs: inputs ? parseJsonParam(inputs, "inputs") : {},
+        };
+        if (connectorId)
+            body.connectorId = connectorId;
+        const result = await request(`/v1/actions/${actionType}/run`, { method: "POST", body, timeout: 35_000 });
+        if (!result)
+            throw new Error("Action returned empty response");
+        const text = truncateResult(JSON.stringify(result.result, null, 2));
+        return {
+            content: [{ type: "text", text: `${actionType} (${result.durationMs}ms):\n${text}` }],
+        };
+    });
+    s.registerTool("b3os_run_ephemeral", {
+        description: `Execute a workflow definition immediately without saving it. Runs synchronously —
+blocks until all nodes complete and returns the full execution results.
+
+Perfect for one-shot operations: "check ETH price", "get Polymarket leaderboard",
+"fetch wallet balances". No polling needed — results come back in the response.
+
+Constraints: max 20 nodes, manual trigger only, no wait/for-each nodes, 60s timeout.
+
+The typical one-shot flow:
+1. Construct a simple workflow definition (manual trigger → action)
+2. b3os_run_ephemeral → executes and returns all node results
+That's it — one call, nothing persisted.`,
+        inputSchema: {
+            definition: definitionSchema,
+            payload: payloadSchema.optional().describe("Optional trigger payload data"),
+        },
+    }, async ({ definition, payload }) => {
+        auditLog("RUN_EPHEMERAL");
+        const parsedDefinition = parseJsonParam(definition, "definition");
+        const body = { definition: parsedDefinition };
+        if (payload !== undefined)
+            body.payload = parseJsonParam(payload, "payload");
+        const result = await request("/v1/runs/sync", {
+            method: "POST",
+            body,
+            timeout: 65_000,
+        });
+        if (!result)
+            throw new Error("Sync run returned empty response");
+        const parts = [];
+        parts.push(`Run ${result.runId}: ${result.status} (${result.durationMs}ms)`);
+        if (result.executionState) {
+            for (const [nodeId, node] of Object.entries(result.executionState)) {
+                if (nodeId === "root")
+                    continue;
+                if (node.status === "failure") {
+                    parts.push(`\n--- FAILED: ${nodeId} (${node.type}) ---`);
+                    if (node.result)
+                        parts.push(truncateResult(JSON.stringify(node.result, null, 2)));
+                }
+                else if (node.status === "success" && node.result) {
+                    parts.push(`\n--- ${nodeId} (${node.type}) ---`);
+                    parts.push(truncateResult(JSON.stringify(node.result, null, 2)));
+                }
+            }
+        }
+        return { content: [{ type: "text", text: truncateResponse(parts.join("\n")) }] };
+    });
+    s.registerTool("b3os_list_runs", {
+        description: `List workflow runs. Filter by workflowId and/or status.
+Use status="failure" to find failed runs for debugging.`,
+        inputSchema: {
+            workflowId: z.string().optional().describe("Filter by workflow ID"),
+            status: z
+                .enum(["running", "success", "failure", "waiting", "cancelled"])
+                .optional()
+                .describe("Filter by run status (e.g. 'failure' to find failed runs)"),
+            limit: z.number().optional().describe("Max results (default: 20)"),
+            offset: z.number().optional().describe("Offset for pagination"),
+        },
+    }, async ({ workflowId, status, limit, offset, }) => {
+        const params = {};
+        if (workflowId)
+            params.workflowId = workflowId;
+        // The /v1/runs API doesn't support server-side status filtering,
+        // so we over-fetch and filter client-side when a status filter is requested.
+        const safeLimit = Math.min(limit || 20, 100);
+        if (status) {
+            params.limit = String(Math.max(safeLimit * 3, 60));
+        }
+        else {
+            params.limit = String(safeLimit);
+        }
+        if (offset && !status)
+            params.offset = String(offset);
+        const data = await request("/v1/runs", { params });
+        let runs = data?.items || [];
+        let hasMore = data?.hasMore ?? false;
+        if (status) {
+            runs = runs.filter(r => r.status === status);
+            if (runs.length > safeLimit) {
+                runs = runs.slice(0, safeLimit);
+                hasMore = true;
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        runs: runs.map(r => ({
+                            id: r.id,
+                            workflowId: r.workflowId,
+                            status: r.status,
+                            triggerSource: r.triggerSource,
+                            startedAt: r.startedAt,
+                            finishedAt: r.finishedAt,
+                        })),
+                        hasMore,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    s.registerTool("b3os_get_run", {
+        description: `Get details of a workflow run. By default returns full execution state for every node.
+
+Use summary=true to get only run metadata (status, timing, IDs) without the heavy
+execution state and workflow definition — much smaller payload, ideal for checking
+run status or listing recent runs.
+
+Use nodeIds to fetch execution state for specific nodes only — useful for debugging
+a single failed node without downloading the entire state.
+
+Check the failed node's input and result fields to understand what went wrong.`,
+        inputSchema: {
+            runId: z.string().describe("Run ID (e.g. 'run_abc123')"),
+            summary: z
+                .boolean()
+                .optional()
+                .describe("When true, omit ExecutionState and WorkflowDefinition to reduce payload size"),
+            nodeIds: z
+                .array(z.string())
+                .optional()
+                .describe("Only include these node IDs in ExecutionState (comma-separated in the API)"),
+        },
+    }, async ({ runId, summary, nodeIds }) => {
+        validateRunId(runId);
+        const params = {};
+        if (summary)
+            params.summary = "true";
+        if (nodeIds?.length)
+            params.nodeIds = nodeIds.join(",");
+        const run = await request(`/v1/runs/${runId}`, { params });
+        if (!run)
+            throw new Error(`Run ${runId} not found`);
+        return { content: [{ type: "text", text: truncateResponse(JSON.stringify(run, null, 2)) }] };
+    });
+    s.registerTool("b3os_cancel_run", {
+        description: `Cancel a running workflow execution. Use this to stop a workflow that is stuck,
+misconfigured, or performing unwanted actions. Only works on runs with status "running"
+or "waiting".`,
+        inputSchema: {
+            runId: z.string().describe("Run ID to cancel (e.g. 'run_abc123')"),
+        },
+    }, async ({ runId }) => {
+        validateRunId(runId);
+        auditLog("CANCEL", `run ${runId}`);
+        await request(`/v1/runs/${runId}/cancel`, { method: "POST" });
+        return { content: [{ type: "text", text: `Run ${runId} cancelled.` }] };
+    });
+}

package/dist/tools/shared.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+/** Regex for action/trigger type identifiers (lowercase slug format). */
+export declare const ACTION_TYPE_RE: RegExp;
+/** Workflow definition schema — must be an object with a `nodes` map. */
+export declare const definitionSchema: z.ZodObject<{
+    nodes: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+/** Payload schema — must be a key-value object, not a primitive or array. */
+export declare const payloadSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export declare function validateWorkflowId(workflowId: string): void;
+export declare function validateRunId(runId: string): void;
+export declare function validateOrgId(orgId: string): void;
+export declare function auditLog(action: string, detail?: string): void;

package/dist/tools/shared.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/** Regex for action/trigger type identifiers (lowercase slug format). */
+export const ACTION_TYPE_RE = /^[a-z0-9][a-z0-9-]*$/;
+/** Workflow definition schema — must be an object with a `nodes` map. */
+export const definitionSchema = z
+    .object({ nodes: z.record(z.string(), z.any()) })
+    .describe("Workflow definition (JSON object with nodes map)");
+/** Payload schema — must be a key-value object, not a primitive or array. */
+export const payloadSchema = z.record(z.string(), z.any()).describe("Payload key-value object");
+export function validateWorkflowId(workflowId) {
+    if (!/^wf_\w+$/.test(workflowId)) {
+        throw new Error("Invalid workflowId format — expected 'wf_' prefix");
+    }
+}
+export function validateRunId(runId) {
+    if (!/^run_\w+$/.test(runId)) {
+        throw new Error("Invalid runId format — expected 'run_' prefix");
+    }
+}
+export function validateOrgId(orgId) {
+    if (!/^org_\w+$/.test(orgId)) {
+        throw new Error("Invalid orgId format — expected 'org_' prefix (e.g. 'org_abc123')");
+    }
+}
+export function auditLog(action, detail) {
+    console.error(`[b3os-mcp] ${action}${detail ? ` ${detail}` : ""} at ${new Date().toISOString()}`);
+}

package/dist/tools/workflows.d.ts

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

package/dist/tools/workflows.js

@@ -0,0 +1,226 @@
+import { z } from "zod";
+import { request, parseJsonParam, truncateResponse } from "../client.js";
+import { definitionSchema, validateWorkflowId, auditLog } from "./shared.js";
+const WEB_APP_URL = "https://b3os.org";
+function workflowEditUrl(workflowId) {
+    return `${WEB_APP_URL}/workflows/edit?id=${workflowId}`;
+}
+export function registerWorkflowTools(s) {
+    s.registerTool("b3os_list_workflows", {
+        description: `List workflows in the organization. Returns workflow metadata (id, name, status,
+last triggered). Use this to find a workflow by name before getting its details.
+Filter by status to find active, paused, or draft workflows.`,
+        inputSchema: {
+            status: z.enum(["draft", "active", "paused", "archived"]).optional().describe("Filter by workflow status"),
+            limit: z.number().optional().describe("Max results (default: 20)"),
+            offset: z.number().optional().describe("Offset for pagination"),
+        },
+    }, async ({ status, limit, offset }) => {
+        const params = {
+            _fields_filter: "id,name,status,description,lastTriggeredAt,createdAt",
+        };
+        // The /v1/workflows API doesn't support server-side status filtering,
+        // so we over-fetch and filter client-side when a status filter is requested.
+        const safeLimit = Math.min(limit || 20, 100);
+        if (status) {
+            params.limit = String(Math.max(safeLimit * 3, 60));
+        }
+        else {
+            params.limit = String(safeLimit);
+        }
+        if (offset && !status)
+            params.offset = String(offset);
+        const data = await request("/v1/workflows", { params });
+        let workflows = data?.items || [];
+        let hasMore = data?.hasMore ?? false;
+        if (status) {
+            workflows = workflows.filter(w => w.status === status);
+            if (workflows.length > safeLimit) {
+                workflows = workflows.slice(0, safeLimit);
+                hasMore = true;
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        workflows: workflows.map(w => ({
+                            id: w.id,
+                            name: w.name,
+                            status: w.status,
+                            description: w.description,
+                            lastTriggeredAt: w.lastTriggeredAt,
+                            createdAt: w.createdAt,
+                        })),
+                        hasMore,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    s.registerTool("b3os_get_workflow", {
+        description: `Get a workflow's full details including its definition (nodes, triggers, connections).
+Use this to inspect an existing workflow before modifying it.`,
+        inputSchema: { workflowId: z.string().describe("Workflow ID (e.g. 'wf_abc123')") },
+    }, async ({ workflowId }) => {
+        validateWorkflowId(workflowId);
+        const workflow = await request(`/v1/workflows/${workflowId}`);
+        if (!workflow)
+            throw new Error(`Workflow ${workflowId} not found`);
+        return { content: [{ type: "text", text: truncateResponse(JSON.stringify(workflow, null, 2)) }] };
+    });
+    s.registerTool("b3os_create_workflow", {
+        description: `Save a new workflow to B3OS.
+
+IMPORTANT: Always call b3os_validate_workflow first to catch errors before saving.
+After saving, use b3os_publish_workflow to make it live.`,
+        inputSchema: {
+            name: z.string().describe("Workflow name"),
+            description: z.string().describe("What this workflow does"),
+            definition: definitionSchema,
+        },
+    }, async ({ name, description, definition }) => {
+        // Some MCP clients pass definition as a JSON string instead of an object — parse it to avoid double-serialization
+        const parsedDefinition = parseJsonParam(definition, "definition");
+        const workflow = await request("/v1/workflows", {
+            method: "POST",
+            body: { name, description, definition: parsedDefinition },
+        });
+        if (!workflow)
+            throw new Error("Failed to create workflow — empty response");
+        const url = workflowEditUrl(workflow.id);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Workflow created successfully.\n\n${JSON.stringify({ id: workflow.id, name: workflow.name, status: workflow.status, version: workflow.version }, null, 2)}\n\nLink: ${url}\nNext: use b3os_publish_workflow to make it live.`,
+                },
+            ],
+        };
+    });
+    s.registerTool("b3os_update_workflow", {
+        description: `Update an existing workflow's metadata or definition. Only include the fields you want to change.`,
+        inputSchema: {
+            workflowId: z.string().describe("Workflow ID to update"),
+            name: z.string().optional().describe("New name"),
+            description: z.string().optional().describe("New description"),
+            definition: definitionSchema.optional(),
+            expectedCurrentVersion: z.number().optional().describe("Expected current version (optimistic locking)"),
+        },
+    }, async ({ workflowId, name, description, definition, expectedCurrentVersion, }) => {
+        validateWorkflowId(workflowId);
+        const body = {};
+        if (name !== undefined)
+            body.name = name;
+        if (description !== undefined)
+            body.description = description;
+        if (definition !== undefined)
+            body.definition = parseJsonParam(definition, "definition");
+        if (expectedCurrentVersion !== undefined)
+            body.expectedCurrentVersion = expectedCurrentVersion;
+        const workflow = await request(`/v1/workflows/${workflowId}`, {
+            method: "PUT",
+            body,
+        });
+        if (!workflow)
+            throw new Error(`Workflow ${workflowId} not found`);
+        const url = workflowEditUrl(workflow.id);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Workflow updated.\n\n${JSON.stringify({ id: workflow.id, name: workflow.name, status: workflow.status, version: workflow.version }, null, 2)}\n\nLink: ${url}`,
+                },
+            ],
+        };
+    });
+    s.registerTool("b3os_delete_workflow", {
+        description: `Delete (archive) a workflow. This is irreversible. The workflow will be archived
+and no longer execute. Always confirm with the user before calling this tool.`,
+        inputSchema: {
+            workflowId: z.string().describe("Workflow ID to delete"),
+            confirm: z.literal(true).describe("Must be exactly true to confirm deletion — this is irreversible"),
+        },
+    }, async ({ workflowId }) => {
+        validateWorkflowId(workflowId);
+        auditLog("DELETE", `workflow ${workflowId}`);
+        await request(`/v1/workflows/${workflowId}`, { method: "DELETE" });
+        return { content: [{ type: "text", text: `Workflow ${workflowId} deleted.` }] };
+    });
+    s.registerTool("b3os_publish_workflow", {
+        description: `Publish a draft workflow to make it live. After creating or updating a workflow,
+it starts in "draft" status. Publishing activates its triggers (schedules, webhooks, etc.)
+so it begins executing automatically.`,
+        inputSchema: {
+            workflowId: z.string().describe("Workflow ID to publish"),
+            expectedVersion: z.number().optional().describe("Expected version (optimistic locking)"),
+        },
+    }, async ({ workflowId, expectedVersion }) => {
+        validateWorkflowId(workflowId);
+        auditLog("PUBLISH", `workflow ${workflowId}`);
+        const body = {};
+        if (expectedVersion !== undefined)
+            body.expectedVersion = expectedVersion;
+        const workflow = await request(`/v1/workflows/${workflowId}/publish`, {
+            method: "POST",
+            body: Object.keys(body).length > 0 ? body : undefined,
+        });
+        if (!workflow)
+            throw new Error(`Failed to publish workflow ${workflowId}`);
+        const url = workflowEditUrl(workflowId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: workflow.name
+                        ? `Workflow "${workflow.name}" is now live (status: ${workflow.status}).\n\nLink: ${url}`
+                        : `Workflow ${workflowId} published successfully (status: ${workflow.status || "active"}).\n\nLink: ${url}`,
+                },
+            ],
+        };
+    });
+    s.registerTool("b3os_pause_workflow", {
+        description: `Pause an active workflow. Its triggers will stop firing and no new runs will start.
+Use b3os_resume_workflow to reactivate it.`,
+        inputSchema: { workflowId: z.string().describe("Workflow ID to pause") },
+    }, async ({ workflowId }) => {
+        validateWorkflowId(workflowId);
+        await request(`/v1/workflows/${workflowId}/pause`, { method: "POST" });
+        return { content: [{ type: "text", text: `Workflow ${workflowId} paused.` }] };
+    });
+    s.registerTool("b3os_resume_workflow", {
+        description: `Resume a paused workflow. Its triggers will start firing again.`,
+        inputSchema: { workflowId: z.string().describe("Workflow ID to resume") },
+    }, async ({ workflowId }) => {
+        validateWorkflowId(workflowId);
+        await request(`/v1/workflows/${workflowId}/resume`, { method: "POST" });
+        return { content: [{ type: "text", text: `Workflow ${workflowId} resumed.` }] };
+    });
+    s.registerTool("b3os_validate_workflow", {
+        description: `Validate a workflow definition without saving it. ALWAYS call this before
+b3os_create_workflow or b3os_update_workflow. No side effects. Returns validation results
+including any missing fields, invalid payloads, or misconfigured nodes.`,
+        inputSchema: {
+            name: z
+                .string()
+                .optional()
+                .describe("Workflow name (defaults to 'Untitled' — the API requires a name for validation)"),
+            definition: definitionSchema,
+        },
+    }, async ({ name, definition }) => {
+        const parsedDefinition = parseJsonParam(definition, "definition");
+        const result = await request("/v1/workflows/validate", {
+            method: "POST",
+            body: { name: name || "Untitled", definition: parsedDefinition },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result ? `Validation result:\n${JSON.stringify(result, null, 2)}` : "Workflow definition is valid.",
+                },
+            ],
+        };
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,157 @@
+export interface ApiResponse<T> {
+    code: number;
+    message: string;
+    data: T;
+}
+export interface PaginatedData<T> {
+    items: T[];
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+export interface Organization {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    photo?: string;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Wallet {
+    id: string;
+    organizationId: string;
+    address: string;
+    name: string;
+    isDefault: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface Connector {
+    id: string;
+    name: string;
+    type: string;
+    provider?: string;
+}
+export interface Workflow {
+    id: string;
+    version: number;
+    organizationId: string;
+    name: string;
+    description: string;
+    status: "draft" | "active" | "paused" | "archived";
+    type: string;
+    definition: WorkflowDefinition;
+    maxRuns: number;
+    remainRuns: number;
+    cooldownMs: number;
+    lastTriggeredAt?: string;
+    createdBy?: string;
+    createdAt: string;
+    updatedBy?: string;
+    updatedAt: string;
+    hasDraft?: boolean;
+    hasLiveVersion?: boolean;
+}
+export interface WorkflowDefinition {
+    nodes: Record<string, WorkflowNode>;
+}
+export interface WorkflowNode {
+    type: string;
+    description?: string;
+    connector?: {
+        type: string;
+        id?: string;
+    };
+    payload: Record<string, unknown>;
+    children: string[];
+    branch?: string;
+}
+export interface ExecutionNode {
+    type: string;
+    status: "pending" | "running" | "success" | "failure" | "skipped" | "waiting";
+    input?: Record<string, unknown>;
+    result?: Record<string, unknown>;
+    startedAt?: string;
+    finishedAt?: string;
+}
+export interface Run {
+    id: string;
+    organizationId: string;
+    workflowId: string;
+    workflowVersion: number;
+    status: "running" | "success" | "failure" | "waiting" | "cancelled";
+    executionState: Record<string, ExecutionNode>;
+    triggerSource?: string;
+    triggeredBy?: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+export interface TelegramChat {
+    id: string;
+    chatId: number;
+    chatType: string;
+    chatTitle?: string;
+    chatUsername?: string;
+    connectorId?: string;
+    connectorName?: string;
+    verifiedAt: string;
+}
+export interface SlackChannel {
+    id: string;
+    name: string;
+    is_private?: boolean;
+    is_archived?: boolean;
+    num_members?: number;
+}
+export interface ActionTestResult {
+    result?: {
+        data?: {
+            ret?: Record<string, unknown>;
+        };
+    };
+}
+export interface ActionDefinition {
+    type: string;
+    name: string;
+    description: string;
+    payloadSchema: Record<string, unknown>;
+    resultSchema: Record<string, unknown>;
+    logoUrl: string;
+    createdBy: string;
+    documentationUrl: string;
+    connector?: {
+        type: string;
+    };
+    category: string;
+    tags: string[];
+    requiresGas: boolean;
+}
+export interface TriggerDefinition {
+    type: string;
+    name: string;
+    description: string;
+    payloadSchema: Record<string, unknown>;
+    resultSchema: Record<string, unknown>;
+    logoUrl: string;
+    createdBy: string;
+    documentationUrl: string;
+    connector?: {
+        type: string;
+    };
+    tags: string[];
+}
+export interface SearchHit {
+    id: string;
+    type: string;
+    name: string;
+    description: string;
+    category?: string;
+    tags?: string[];
+    score: number;
+}
+export interface SearchResults {
+    results: SearchHit[];
+    totalHits: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// ── API Response Wrappers ──
+export {};