@devries-cameron20 / composio-1 / commits / 461c6c313
Fork 0

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

feat(sdk): experimental premium usage policy for Sessions (#4599)

## What this does Adds minimal, experimental SDK support for the existing Session `premium_usage` API policy. Developers can pass `premiumUsage` in TypeScript or `premium_usage` in Python when creating a Tool Router Session, and update that policy on an existing Session. This is the Session-level premium usage policy for Instant Tools backed by hosted accounts. It is **not** a new toolkit-availability switch or a change to account selection. The project must separately allow premium usage; that setting is not self-service yet. ## Contract and defaults - Omit the field: send no new SDK field. The backend applies its existing Session default, subject to the project setting. - `false`: disable premium usage for that Session. - Object: restrict eligible toolkits or tools using `enable`/`disable`; `returnPremiumCharge` (`return_premium_charge` in Python) opts into actual charge visibility. It does not grant spend permission on its own. - Existing connected-account pins, toolkit filters, `enable_multi_execute`, and other Session settings remain unchanged. No direct-execution API changes. Both SDKs pass `premium_usage` through the pinned generated clients' typed create/patch fields (`@composio/client` 2.0.0-rc.8, `composio-client` 2.0.0rc8). No generated client files are changed. ## Scope - TypeScript: create/update schemas, wire-name conversion, and preservation of the optional `premium_charge` execution response as `premiumCharge`, with focused tests and a changeset. - Python: create/update keyword arguments and focused tests. - No pricing/catalog response modeling or new public SDK API for project settings in this PR. ## Verification - TypeScript: 188 focused tests passed; `@composio/core` typecheck passed. - Python: 129 Tool Router tests passed. - The full TypeScript suite was attempted but includes unrelated local-network tests that cannot bind to `127.0.0.1` in this environment. Focused changed-area tests pass. Companion developer documentation: #4604 (merged), with a follow-up in #4606. This PR contains only SDK code and tests. --------- Co-authored-by: jkomyno <alberto@composio.dev>

palash-c committed Sep 24, 2026 at 12:13 UTC 461c6c3139b5eaaacfad67c2b34dfe2438a52f7e
15 files changed +257 -5
.changeset/instant-tools-session-policy.md new
+5
@@ -0,0 +1,5 @@
1 +---
2 +'@composio/core': minor
3 +---
4 +
5 +Add experimental `premiumUsage` support when creating and updating Tool Router Sessions.
python/composio/core/models/tool_router.py
+15
@@ -49,6 +49,7 @@ from composio.core.models.tool_router_constants import (
49 SESSION_PRESET_DIRECT_TOOLS,
50 )
51 from composio.core.models.tool_router_session import (
52 + ToolRouterPremiumUsageConfig,
53 ToolRouterSession,
54 ToolRouterSessionPreloadConfig,
55 ToolRouterSessionWithMcp,
@@ -726,6 +727,9 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
727 preload: t.Optional[ToolRouterPreloadConfig] = None,
728 session_preset: t.Optional[SessionPreset] = None,
729 experimental: t.Optional[ToolRouterExperimentalConfig] = None,
730 + premium_usage: t.Optional[
731 + t.Union[t.Literal[False], ToolRouterPremiumUsageConfig]
732 + ] = None,
733 mcp: t.Literal[True],
734 ) -> ToolRouterSessionWithMcp[TTool, TToolCollection]: ...
735
@@ -754,6 +758,9 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
758 preload: t.Optional[ToolRouterPreloadConfig] = None,
759 session_preset: t.Optional[SessionPreset] = None,
760 experimental: t.Optional[ToolRouterExperimentalConfig] = None,
761 + premium_usage: t.Optional[
762 + t.Union[t.Literal[False], ToolRouterPremiumUsageConfig]
763 + ] = None,
764 mcp: t.Literal[False] = False,
765 ) -> ToolRouterSession[TTool, TToolCollection]: ...
766
@@ -781,6 +788,9 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
788 preload: t.Optional[ToolRouterPreloadConfig] = None,
789 session_preset: t.Optional[SessionPreset] = None,
790 experimental: t.Optional[ToolRouterExperimentalConfig] = None,
791 + premium_usage: t.Optional[
792 + t.Union[t.Literal[False], ToolRouterPremiumUsageConfig]
793 + ] = None,
794 mcp: bool = False,
795 ) -> ToolRouterSession[TTool, TToolCollection]:
796 """
@@ -888,6 +898,9 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
898 it directly from session.tools(); otherwise custom tools
899 remain search-only.
900 Example: {'assistive_prompt': {'user_timezone': 'America/New_York'}}
901 + :param premium_usage: Experimental premium usage policy. The project
902 + must allow premium usage. ``False`` disables it for this
903 + Session; a policy can restrict eligible toolkits and tools.
904 :param mcp: When True, the returned session surfaces its hosted MCP
905 endpoint (``session.mcp.url`` / ``session.mcp.headers``) in
906 the type (returns ToolRouterSessionWithMcp). The endpoint
@@ -1081,6 +1094,8 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
1094 create_params: t.Dict[str, t.Any] = {
1095 "user_id": user_id,
1096 }
1097 + if premium_usage is not None:
1098 + create_params["premium_usage"] = premium_usage
1099
1100 # Build connections config
1101 connections_config: t.Dict[str, t.Any] = {
python/composio/core/models/tool_router_session.py
+38
@@ -111,6 +111,24 @@ ToolRouterSessionConfig = t.Union[
111 ]
112
113
114 +class ToolRouterPremiumUsageEnable(te.TypedDict):
115 + enable: t.List[str]
116 +
117 +
118 +class ToolRouterPremiumUsageDisable(te.TypedDict):
119 + disable: t.List[str]
120 +
121 +
122 +class ToolRouterPremiumUsageConfig(te.TypedDict, total=False):
123 + """Experimental premium usage policy for a Session."""
124 +
125 + toolkits: t.Union[ToolRouterPremiumUsageEnable, ToolRouterPremiumUsageDisable]
126 + tools: t.Dict[
127 + str, t.Union[ToolRouterPremiumUsageEnable, ToolRouterPremiumUsageDisable]
128 + ]
129 + return_premium_charge: bool
130 +
131 +
132 class ToolRouterUpdateManageConnectionsConfig(te.TypedDict, total=False):
133 """``manage_connections`` shape accepted by :meth:`ToolRouterSession.update`.
134
@@ -982,6 +1000,9 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
1000 self,
1001 *,
1002 toolkits: t.Union[t.Optional[session_patch_params.Toolkits], "Omit"] = omit,
1003 + premium_usage: t.Union[
1004 + t.Literal[False], ToolRouterPremiumUsageConfig, "Omit"
1005 + ] = omit,
1006 tools: t.Union[
1007 t.Optional[t.Dict[str, session_patch_params.Tools]], "Omit"
1008 ] = omit,
@@ -1021,6 +1042,10 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
1042 as-is). Supplied ``tools``, ``auth_configs`` and ``connected_accounts``
1043 maps replace the stored map entirely. Inside ``manage_connections``,
1044 ``callback_url=None`` removes only the stored callback URL.
1045 + Experimental ``premium_usage`` accepts ``False`` to disable billed
1046 + access or an object to set its filters; it does not accept ``None``.
1047 + Any object, even one that only sets ``return_premium_charge``,
1048 + re-enables premium usage on a Session set to ``False``.
1049
1050 By default the request carries no precondition: the last writer wins.
1051 Pass ``expected_config_version`` (for example this object's
@@ -1052,6 +1077,11 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
1077 "Pass either `sandbox` or `workbench`, not both. "
1078 "`workbench` is a backwards-compatible alias for `sandbox`."
1079 )
1080 + if premium_usage is None:
1081 + raise exceptions.InvalidParams(
1082 + "`premium_usage` does not accept None; pass False to disable "
1083 + "premium usage, or omit it to keep the stored policy"
1084 + )
1085
1086 precondition: t.Union[int, "Omit"]
1087 if expected_config_version is None or expected_config_version is False:
@@ -1106,6 +1136,14 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
1136 t.Union[t.Optional[session_patch_params.Experimental], "Omit"],
1137 experimental,
1138 ),
1139 + premium_usage=t.cast(
1140 + t.Union[
1141 + t.Literal[False],
1142 + session_patch_params.CurrentPremiumUsageVariant1,
1143 + "Omit",
1144 + ],
1145 + premium_usage,
1146 + ),
1147 extra_body=extra_body,
1148 # A stale precondition is a deterministic 409: never retry it.
1149 request_options={"max_retries": 0},
python/tests/test_tool_router.py
+46
@@ -172,6 +172,26 @@ class TestToolRouter:
172 # Verify API was called
173 mock_client.tool_router.session.create.assert_called_once()
174
175 + def test_create_with_premium_usage_policy(self, tool_router, mock_client):
176 + policy = {"toolkits": {"enable": ["exa"]}, "return_premium_charge": True}
177 + tool_router.create(user_id="user_123", premium_usage=policy)
178 + kwargs = mock_client.tool_router.session.create.call_args.kwargs
179 + assert kwargs["premium_usage"] == policy
180 + assert "extra_body" not in kwargs
181 +
182 + mock_client.tool_router.session.create.reset_mock()
183 + tool_router.create(user_id="user_123")
184 + assert (
185 + "premium_usage"
186 + not in mock_client.tool_router.session.create.call_args.kwargs
187 + )
188 +
189 + tool_router.create(user_id="user_123", premium_usage=False)
190 + assert (
191 + mock_client.tool_router.session.create.call_args.kwargs["premium_usage"]
192 + is False
193 + )
194 +
195 def test_create_session_default_returns_base_session(self, tool_router):
196 """Default create() (mcp omitted) returns the base ToolRouterSession.
197
@@ -2520,6 +2540,32 @@ class TestSessionUpdateContract:
2540 def test_session_tracks_config_version(self, session):
2541 assert session.config_version == 7
2542
2543 + def test_premium_usage_policy_is_sent(self, session, mock_client):
2544 + session.update(
2545 + premium_usage={
2546 + "toolkits": {"enable": ["exa"]},
2547 + "return_premium_charge": True,
2548 + }
2549 + )
2550 + kwargs = mock_client.tool_router.session.patch.call_args.kwargs
2551 + assert kwargs["premium_usage"] == {
2552 + "toolkits": {"enable": ["exa"]},
2553 + "return_premium_charge": True,
2554 + }
2555 + assert kwargs["extra_body"] is None
2556 +
2557 + def test_premium_usage_can_be_disabled(self, session, mock_client):
2558 + session.update(premium_usage=False)
2559 + assert (
2560 + mock_client.tool_router.session.patch.call_args.kwargs["premium_usage"]
2561 + is False
2562 + )
2563 +
2564 + def test_premium_usage_rejects_none(self, session, mock_client):
2565 + with pytest.raises(InvalidParams, match="premium_usage"):
2566 + session.update(premium_usage=None) # type: ignore[arg-type]
2567 + mock_client.tool_router.session.patch.assert_not_called()
2568 +
2569 def test_update_sends_no_precondition_by_default_without_retries(
2570 self, session, mock_client
2571 ):
ts/packages/core/src/lib/toolRouterParams.ts
+19
@@ -17,6 +17,7 @@ import {
17 ToolRouterUpdateManageConnectionsSchema,
18 ToolRouterUpdateExperimentalConfig,
19 ToolRouterSandboxConfig,
20 + ToolRouterPremiumUsage,
21 } from '../types/toolRouter.types';
22 import { ValidationError } from '../errors';
23 import { z } from 'zod';
@@ -196,6 +197,21 @@ export type SessionPatchBody = Omit<
197 expected_config_version?: number;
198 };
199
200 +export type SessionPremiumUsageBody = NonNullable<SessionPatchParams['premium_usage']>;
201 +
202 +export const transformToolRouterPremiumUsageParams = (
203 + config: ToolRouterPremiumUsage
204 +): SessionPremiumUsageBody => {
205 + if (config === false) return false;
206 + return {
207 + ...(config.toolkits !== undefined && { toolkits: config.toolkits }),
208 + ...(config.tools !== undefined && { tools: config.tools }),
209 + ...(config.returnPremiumCharge !== undefined && {
210 + return_premium_charge: config.returnPremiumCharge,
211 + }),
212 + };
213 +};
214 +
215 export const transformToolRouterUpdateManageConnectionsParams = (
216 params: boolean | ToolRouterUpdateManageConnectionsConfig
217 ): SessionPatchManageConnectionsBody => {
@@ -332,6 +348,9 @@ export const transformToolRouterUpdateParams = (
348 params.toolkits =
349 config.toolkits === null ? null : transformToolRouterToolkitsParams(config.toolkits);
350 }
351 + if (config.premiumUsage !== undefined) {
352 + params.premium_usage = transformToolRouterPremiumUsageParams(config.premiumUsage);
353 + }
354 if (config.tools !== undefined) {
355 params.tools = config.tools === null ? null : transformToolRouterToolsParams(config.tools);
356 }
ts/packages/core/src/models/ToolRouter.ts
+4
@@ -50,6 +50,7 @@ import {
50 transformToolRouterSandboxParams,
51 transformToolRouterToolkitsParams,
52 transformToolRouterMultiAccountParams,
53 + transformToolRouterPremiumUsageParams,
54 resolveToolRouterSandboxConfig,
55 } from '../lib/toolRouterParams';
56 import { PRELOAD_TOOLS_ALL } from '../lib/toolRouterConstants';
@@ -259,6 +260,9 @@ export class ToolRouter<
260 auth_configs: routerConfig.authConfigs,
261 connected_accounts: connectedAccountsPayload,
262 toolkits: transformToolRouterToolkitsParams(routerConfig.toolkits),
263 + ...(routerConfig.premiumUsage !== undefined && {
264 + premium_usage: transformToolRouterPremiumUsageParams(routerConfig.premiumUsage),
265 + }),
266 tools: transformToolRouterToolsParams(routerConfig.tools),
267 tags: transformToolRouterTagsParams(routerConfig.tags),
268 manage_connections: transformToolRouterManageConnectionsParams(
ts/packages/core/src/models/ToolRouterSession.ts
+3
@@ -1097,6 +1097,9 @@ export class ToolRouterSession<
1097 : `${failedCount} out of ${allResults.length} tools failed`
1098 : null,
1099 successful: !hasAnyError,
1100 + ...(remoteResult?.premiumCharge !== undefined && {
1101 + premiumCharge: remoteResult.premiumCharge,
1102 + }),
1103 };
1104 }
1105 }
ts/packages/core/src/models/Tools.ts
+7 -5
@@ -62,6 +62,7 @@ import {
62 import { dereferenceJsonSchema } from '../utils/jsonSchema';
63 import { ComposioRequestOptions } from '../types/requestOptions.types';
64 import { withCancellation } from '../utils/cancellation';
65 +import { transformExecuteResponse } from '../utils/transformers/toolRouterResponseTransform';
66 import { ComposioRequestCancelledError } from '../errors/SDKErrors';
67
68 const TOOL_ROUTER_SESSION_TOOLS_PAGE_LIMIT = 500;
@@ -1257,12 +1258,13 @@ export class Tools<
1258 requestOptions?.signal
1259 );
1260
1260 - // Prepare the result
1261 + const { data, error, logId, premiumCharge } = transformExecuteResponse(response);
1262 let result: ToolExecuteResponse = {
1262 - data: response.data,
1263 - error: response.error,
1264 - successful: !response.error,
1265 - logId: response.log_id,
1263 + data,
1264 + error,
1265 + successful: !error,
1266 + logId,
1267 + ...(premiumCharge !== undefined && { premiumCharge }),
1268 };
1269
1270 // Apply afterExecute modifier if provided
ts/packages/core/src/types/tool.types.ts
+2
@@ -407,6 +407,8 @@ export const ToolExecuteResponseSchema = z.object({
407 successful: z.boolean(),
408 logId: z.string().optional(),
409 sessionInfo: z.unknown().optional(),
410 + /** Actual premium usage charge when the Session opts into returning it. */
411 + premiumCharge: z.unknown().optional(),
412 });
413 export type ToolExecuteResponse = z.infer<typeof ToolExecuteResponseSchema>;
414
ts/packages/core/src/types/toolRouter.types.ts
+38
@@ -107,6 +107,34 @@ export const ToolRouterToolkitsEnabledConfigSchema = z
107 })
108 .strict();
109
110 +/** Experimental premium usage policy for a Session. */
111 +export const ToolRouterPremiumUsageSchema = z.union([
112 + z.literal(false),
113 + z
114 + .object({
115 + toolkits: z
116 + .union([ToolRouterToolkitsEnabledConfigSchema, ToolRouterToolkitsDisabledConfigSchema])
117 + .optional(),
118 + tools: z
119 + .record(
120 + z.string(),
121 + z.union([
122 + z.object({ enable: z.array(z.string()) }).strict(),
123 + z.object({ disable: z.array(z.string()) }).strict(),
124 + ])
125 + )
126 + .optional(),
127 + /**
128 + * Return the actual premium charge in Session tool responses. Controls
129 + * visibility only; on update, any policy object still re-enables premium
130 + * usage on a Session set to `false`.
131 + */
132 + returnPremiumCharge: z.boolean().optional(),
133 + })
134 + .strict(),
135 +]);
136 +export type ToolRouterPremiumUsage = z.infer<typeof ToolRouterPremiumUsageSchema>;
137 +
138 export const ToolRouterManageConnectionsConfigSchema = z.object({
139 enable: z
140 .boolean()
@@ -236,6 +264,10 @@ const ToolRouterCreateSessionConfigBaseSchema = z
264 .optional()
265 .describe('The toolkits to use in the tool router session'),
266
267 + premiumUsage: ToolRouterPremiumUsageSchema.optional().describe(
268 + 'Experimental premium usage policy. Omission permits eligible tools when the project allows premium usage; false disables it for this Session.'
269 + ),
270 +
271 authConfigs: z
272 .record(z.string(), z.string())
273 .describe(
@@ -373,6 +405,7 @@ export const ToolRouterCreateSessionConfigSchema = z
405 * @param {Array<'readOnlyHint' | 'destructiveHint' | 'idempotentHint' | 'openWorldHint'>} tags - Global tags to filter tools by behavior
406 * @param {Record<string, string>} authConfigs - The auth configs to use in the tool router session
407 * @param {Record<string, string | string[]>} connectedAccounts - The connected accounts to use in the tool router session. A single string is coerced to a single-element array before being sent to the backend.
408 + * @param {ToolRouterPremiumUsage} [premiumUsage] - Experimental premium usage policy. The project must allow premium usage.
409 * @param {ToolRouterConfigManageConnectionsSchema | boolean} manageConnections - The config for the manage connections in the tool router session. Defaults to true, if set to false, you need to manage connections manually. If set to an object, you can configure the manage connections settings.
410 * @param {boolean} [manageConnections.enable] - Whether to use tools to manage connections in the tool router session @default true
411 * @param {string} [manageConnections.callbackUrl] - The callback url to use in the tool router session
@@ -543,6 +576,8 @@ export const ToolRouterSessionExecuteResponseSchema = z.object({
576 data: z.record(z.string(), z.unknown()),
577 error: z.string().nullable(),
578 logId: z.string(),
579 + /** Actual premium usage charge when the Session opts into returning it. */
580 + premiumCharge: z.unknown().optional(),
581 });
582 export type ToolRouterSessionExecuteResponse = z.infer<
583 typeof ToolRouterSessionExecuteResponseSchema
@@ -758,6 +793,9 @@ export type ToolRouterUpdateExperimentalConfig = z.infer<typeof ToolRouterUpdate
793 */
794 export const ToolRouterUpdateSessionConfigSchema = z
795 .object({
796 + premiumUsage: ToolRouterPremiumUsageSchema.optional().describe(
797 + 'Experimental premium usage policy. False disables it. Any supplied object, even one that only sets returnPremiumCharge, re-enables it. Omitted subfields keep their stored values.'
798 + ),
799 toolkits: z
800 .union([
801 ToolRouterToolkitsParamSchema,
ts/packages/core/src/utils/transformers/toolRouterResponseTransform.ts
+2
@@ -68,6 +68,7 @@ interface RawExecuteResponse {
68 data: Record<string, unknown>;
69 error: string | null;
70 log_id: string;
71 + premium_charge?: unknown;
72 }
73
74 function transformSearchResult(raw: RawSearchResult) {
@@ -156,5 +157,6 @@ export function transformExecuteResponse(raw: RawExecuteResponse) {
157 data: raw.data,
158 error: raw.error,
159 logId: raw.log_id,
160 + ...(raw.premium_charge !== undefined && { premiumCharge: raw.premium_charge }),
161 };
162 }
ts/packages/core/test/lib/toolRouterParams.test.ts
+11
@@ -183,6 +183,17 @@ describe('transformToolRouterTagsParams', () => {
183 });
184
185 describe('transformToolRouterUpdateParams', () => {
186 + it('maps the experimental premium usage policy without changing other session settings', () => {
187 + expect(
188 + transformToolRouterUpdateParams({
189 + premiumUsage: { toolkits: { disable: ['exa'] }, returnPremiumCharge: true },
190 + })
191 + ).toEqual({ premium_usage: { toolkits: { disable: ['exa'] }, return_premium_charge: true } });
192 + expect(transformToolRouterUpdateParams({ premiumUsage: false })).toEqual({
193 + premium_usage: false,
194 + });
195 + });
196 +
197 it('keeps an empty toolkit allowlist in the request', () => {
198 expect(transformToolRouterUpdateParams({ toolkits: [] })).toEqual({
199 toolkits: { enable: [] },
ts/packages/core/test/models/toolRouter.test.ts
+37
@@ -200,6 +200,28 @@ describe('ToolRouter', () => {
200 describe('create method', () => {
201 const userId = 'user_123';
202
203 + it('passes premium usage only when requested', async () => {
204 + mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
205 + await toolRouter.create(userId, {
206 + premiumUsage: { toolkits: { enable: ['exa'] }, returnPremiumCharge: true },
207 + });
208 + expect(mockClient.toolRouter.session.create.mock.calls[0]?.[0]).toMatchObject({
209 + premium_usage: { toolkits: { enable: ['exa'] }, return_premium_charge: true },
210 + });
211 +
212 + mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
213 + await toolRouter.create(userId, { premiumUsage: false });
214 + expect(mockClient.toolRouter.session.create.mock.calls[1]?.[0]).toMatchObject({
215 + premium_usage: false,
216 + });
217 +
218 + mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
219 + await toolRouter.create(userId);
220 + expect(mockClient.toolRouter.session.create.mock.calls[2]?.[0]).not.toHaveProperty(
221 + 'premium_usage'
222 + );
223 + });
224 +
225 describe('basic session creation', () => {
226 it('should create a session with minimal configuration', async () => {
227 mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
@@ -2692,6 +2714,21 @@ describe('ToolRouter', () => {
2714 expect(result.logId).toBe('log_abc');
2715 });
2716
2717 + it('returns the premium charge when the API includes one', async () => {
2718 + mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
2719 + mockClient.toolRouter.session.execute.mockResolvedValueOnce({
2720 + ...mockExecuteResponse,
2721 + premium_charge: { amount: '0.01', currency: 'USD' },
2722 + });
2723 +
2724 + const session = await toolRouter.create(userId, {
2725 + premiumUsage: { returnPremiumCharge: true },
2726 + });
2727 + const result = await session.execute('GMAIL_SEND_EMAIL');
2728 +
2729 + expect(result.premiumCharge).toEqual({ amount: '0.01', currency: 'USD' });
2730 + });
2731 +
2732 it('should propagate execute API errors', async () => {
2733 mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
2734 mockClient.toolRouter.session.execute.mockRejectedValueOnce(new Error('Execute failed'));
ts/packages/core/test/tools/tools.test.ts
+16
@@ -1365,6 +1365,22 @@ describe('Tools', () => {
1365 });
1366 });
1367
1368 + it('returns the premium charge for provider-wrapped session tools', async () => {
1369 + mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1370 + data: {},
1371 + error: null,
1372 + log_id: '123',
1373 + premium_charge: { amount: '0.01', currency: 'USD' },
1374 + });
1375 +
1376 + const result = await context.tools.executeSessionTool('EXA_SEARCH', {
1377 + sessionId,
1378 + arguments: {},
1379 + });
1380 +
1381 + expect(result.premiumCharge).toEqual({ amount: '0.01', currency: 'USD' });
1382 + });
1383 +
1384 it('should pass inline custom tools to tool router session execute', async () => {
1385 const toolSlug = 'COMPOSIO_TOOL';
1386 const body = {
ts/packages/core/test/utils/toolRouterResponseTransform.test.ts
+14
@@ -160,5 +160,19 @@ describe('toolRouterResponseTransform', () => {
160 expect(result.error).toBe('Connection not found');
161 expect(result.logId).toBe('log_err');
162 });
163 +
164 + it('preserves the optional premium charge without inventing one', () => {
165 + expect(
166 + transformExecuteResponse({
167 + data: {},
168 + error: null,
169 + log_id: 'log_paid',
170 + premium_charge: { amount: '0.01', currency: 'USD' },
171 + }).premiumCharge
172 + ).toEqual({ amount: '0.01', currency: 'USD' });
173 + expect(
174 + transformExecuteResponse({ data: {}, error: null, log_id: 'log_free' })
175 + ).not.toHaveProperty('premiumCharge');
176 + });
177 });
178 });