Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| 1 | /** |
| 2 | * @composio/mastra + openai + zod 4 |
| 3 | * |
| 4 | * Verifies that @composio/mastra works correctly with zod@4. |
| 5 | * |
| 6 | * See: https://github.com/ComposioHQ/composio/issues/2109. |
| 7 | */ |
| 8 | |
| 9 | import { Composio } from '@composio/core'; |
| 10 | import { MastraProvider } from '@composio/mastra'; |
| 11 | import { getMcpCallToolMeta, MCPClient } from '@mastra/mcp'; |
| 12 | import { Agent } from '@mastra/core/agent'; |
| 13 | import { e2e } from '@e2e-tests/utils'; |
| 14 | import { TIMEOUTS } from '@e2e-tests/utils/const'; |
| 15 | import { describe, it, expect } from 'bun:test'; |
| 16 | import { createOpenAI } from '@ai-sdk/openai'; |
| 17 | import { stepCountIs } from 'ai'; |
| 18 | import { z } from 'zod'; |
| 19 | |
| 20 | const MCP_CONNECT_TIMEOUT_MS = 15_000; |
| 21 | const KARMA_SCHEMA = z.object({ karma: z.number() }); |
| 22 | const SEARCH_TOOL = 'myHttpClient_COMPOSIO_SEARCH_TOOLS'; |
| 23 | const EXECUTE_TOOL = 'myHttpClient_COMPOSIO_MULTI_EXECUTE_TOOL'; |
| 24 | |
| 25 | // Allowlist for failure logs: Zod strips every other field. |
| 26 | const idsSchema = z.object({ log_id: z.string().optional(), request_id: z.string().optional() }); |
| 27 | const searchResponseSchema = idsSchema.extend({ |
| 28 | data: z |
| 29 | .object({ |
| 30 | results: z.array(z.object({ primary_tool_slugs: z.array(z.string()).optional() })).optional(), |
| 31 | tool_schemas: z |
| 32 | .object({ |
| 33 | HACKERNEWS_GET_USER: z |
| 34 | .object({ |
| 35 | input_schema: z.object({ required: z.array(z.string()).optional() }).nullish(), |
| 36 | }) |
| 37 | .optional(), |
| 38 | }) |
| 39 | .optional(), |
| 40 | }) |
| 41 | .optional(), |
| 42 | }); |
| 43 | const executeArgsSchema = z.object({ |
| 44 | tools: z.array(z.object({ tool_slug: z.string(), arguments: z.record(z.string(), z.unknown()) })), |
| 45 | }); |
| 46 | const mcpTextResultSchema = z.object({ |
| 47 | _meta: idsSchema.optional(), |
| 48 | content: z.array(z.object({ type: z.literal('text'), text: z.string() })), |
| 49 | }); |
| 50 | |
| 51 | /** Flat log record for one search result, given as a structured value or an MCP text envelope. */ |
| 52 | function searchRecord(payload: { toolCallId: string; isError?: boolean; result: unknown }) { |
| 53 | const envelope = mcpTextResultSchema.safeParse(payload.result).data; |
| 54 | let value: unknown = payload.result; |
| 55 | if (envelope) { |
| 56 | try { |
| 57 | value = JSON.parse(envelope.content.map(part => part.text).join('')); |
| 58 | } catch { |
| 59 | value = undefined; |
| 60 | } |
| 61 | } |
| 62 | const response = searchResponseSchema.safeParse(value).data; |
| 63 | const meta = idsSchema.safeParse(getMcpCallToolMeta(payload.result) ?? envelope?._meta).data; |
| 64 | return { |
| 65 | toolCallId: payload.toolCallId, |
| 66 | isError: payload.isError, |
| 67 | log_id: meta?.log_id ?? response?.log_id, |
| 68 | request_id: meta?.request_id ?? response?.request_id, |
| 69 | requiredInput: response?.data?.tool_schemas?.HACKERNEWS_GET_USER?.input_schema?.required, |
| 70 | matchedSlugs: response?.data?.results?.flatMap(r => r.primary_tool_slugs ?? []), |
| 71 | }; |
| 72 | } |
| 73 | |
| 74 | /** Text of an MCP tool result, or its JSON when the result is structured. */ |
| 75 | function toolResultText(result: unknown) { |
| 76 | const envelope = mcpTextResultSchema.safeParse(result).data; |
| 77 | return envelope ? envelope.content.map(part => part.text).join('') : JSON.stringify(result); |
| 78 | } |
| 79 | |
| 80 | declare module 'bun' { |
| 81 | interface Env { |
| 82 | COMPOSIO_API_KEY: string; |
| 83 | OPENAI_API_KEY: string; |
| 84 | } |
| 85 | } |
| 86 | |
| 87 | e2e(import.meta.url, { |
| 88 | versions: { node: ['22.23.5', '24.22.3', '26.13.1'] }, |
| 89 | env: { |
| 90 | COMPOSIO_API_KEY: Bun.env.COMPOSIO_API_KEY, |
| 91 | OPENAI_API_KEY: Bun.env.OPENAI_API_KEY, |
| 92 | }, |
| 93 | defineTests: () => { |
| 94 | describe('@composio/mastra + openai + zod 4', () => { |
| 95 | const composio = new Composio({ |
| 96 | apiKey: Bun.env.COMPOSIO_API_KEY, |
| 97 | provider: new MastraProvider(), |
| 98 | }); |
| 99 | |
| 100 | it( |
| 101 | 'should work with Tool Router', |
| 102 | async () => { |
| 103 | const session = await composio.create('default', { |
| 104 | toolkits: ['hackernews'], |
| 105 | mcp: true, |
| 106 | manageConnections: true, |
| 107 | tools: { |
| 108 | hackernews: { |
| 109 | enable: ['HACKERNEWS_GET_USER'], |
| 110 | }, |
| 111 | }, |
| 112 | }); |
| 113 | |
| 114 | const { mcp, sessionId } = session; |
| 115 | expect(sessionId).toBeDefined(); |
| 116 | |
| 117 | // Create a client with an HTTP server (tries Streamable HTTP, falls back to SSE) |
| 118 | const mcpClient = new MCPClient({ |
| 119 | timeout: TIMEOUTS.LLM_LONG, |
| 120 | servers: { |
| 121 | myHttpClient: { |
| 122 | url: new URL(mcp.url), |
| 123 | connectTimeout: MCP_CONNECT_TIMEOUT_MS, |
| 124 | requestInit: { |
| 125 | headers: mcp.headers, |
| 126 | }, |
| 127 | }, |
| 128 | }, |
| 129 | }); |
| 130 | |
| 131 | try { |
| 132 | const tools = await mcpClient.listTools(); |
| 133 | expect(Object.keys(tools).length).toBeGreaterThan(0); |
| 134 | const openai = createOpenAI({ apiKey: Bun.env.OPENAI_API_KEY }); |
| 135 | |
| 136 | const hackernewsAgent = new Agent({ |
| 137 | id: 'test', |
| 138 | name: 'test', |
| 139 | instructions: `You're a helpful Hackernews agent, able to finding information about users.`, |
| 140 | model: openai('gpt-5.5'), |
| 141 | tools, |
| 142 | }); |
| 143 | |
| 144 | const result = await hackernewsAgent.generate( |
| 145 | 'Look up the HackerNews user "pg" with HACKERNEWS_GET_USER, then return the exact karma value from that tool result.', |
| 146 | { structuredOutput: { schema: KARMA_SCHEMA }, stopWhen: stepCountIs(10) } |
| 147 | ); |
| 148 | |
| 149 | // The karma must come from a HACKERNEWS_GET_USER execution, not from the model's memory. |
| 150 | const lookupCallIds = new Set( |
| 151 | result.toolCalls |
| 152 | .filter(({ payload }) => payload.toolName === EXECUTE_TOOL) |
| 153 | .filter(({ payload }) => |
| 154 | executeArgsSchema |
| 155 | .safeParse(payload.args) |
| 156 | .data?.tools.some( |
| 157 | ({ tool_slug, arguments: args }) => |
| 158 | tool_slug === 'HACKERNEWS_GET_USER' && args.username === 'pg' |
| 159 | ) |
| 160 | ) |
| 161 | .map(({ payload }) => payload.toolCallId) |
| 162 | ); |
| 163 | const lookupResults = result.toolResults |
| 164 | .filter(({ payload }) => lookupCallIds.has(payload.toolCallId)) |
| 165 | .map(({ payload }) => toolResultText(payload.result)); |
| 166 | |
| 167 | const parsed = KARMA_SCHEMA.safeParse(result.object); |
| 168 | if (!parsed.success || lookupResults.length === 0) { |
| 169 | const diagnostics = { |
| 170 | finishReason: result.finishReason, |
| 171 | toolCalls: result.toolCalls.map(({ payload }) => payload.toolName), |
| 172 | searches: result.toolResults |
| 173 | .filter(({ payload }) => payload.toolName === SEARCH_TOOL) |
| 174 | .map(({ payload }) => searchRecord(payload)), |
| 175 | executions: result.toolCalls |
| 176 | .filter(({ payload }) => payload.toolName === EXECUTE_TOOL) |
| 177 | .map(({ payload }) => executeArgsSchema.safeParse(payload.args).data?.tools), |
| 178 | lookupResults: lookupResults.map(text => text.slice(0, 500)), |
| 179 | steps: result.steps.map(step => ({ |
| 180 | finishReason: step.finishReason, |
| 181 | usage: step.usage, |
| 182 | providerMetadata: step.providerMetadata, |
| 183 | })), |
| 184 | warnings: result.warnings, |
| 185 | }; |
| 186 | console.error('Agent diagnostics', JSON.stringify(diagnostics, null, 2)); |
| 187 | } |
| 188 | |
| 189 | expect(result.error).toBeUndefined(); |
| 190 | const { karma } = KARMA_SCHEMA.parse(result.object); |
| 191 | expect(karma).toBeGreaterThan(150_000); |
| 192 | expect(lookupResults.join('\n')).toContain(String(karma)); |
| 193 | } finally { |
| 194 | await mcpClient.disconnect(); |
| 195 | } |
| 196 | }, |
| 197 | { |
| 198 | timeout: TIMEOUTS.LLM_LONG, |
| 199 | } |
| 200 | ); |
| 201 | }); |
| 202 | }, |
| 203 | }); |