@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/tools/http-request/truncate-response.js

@@ -1,4 +1,5 @@
-import { MAX_RESPONSE_CHARS } from './utils.js';
+import { MAX_RESPONSE_CHARS } from './request.js';
+import { isRecord } from '../../guards.js';
 export function truncateResponseBody(body) {
     if (body.length <= MAX_RESPONSE_CHARS)
         return body;
@@ -18,63 +19,73 @@ const MARKER_CHARS = 64;
 function shrinkable(value) {
     if (typeof value === 'string')
         return true;
-    return typeof value === 'object' && value !== null;
+    return isRecord(value);
 }
 export const ELISION = '… [truncated]';
 function fitString(value, budget) {
     const room = budget - ELISION.length - 2;
-    if (room <= 0)
+    if (room <= 0) {
         return ELISION;
+    }
     return `${value.slice(0, room)}${ELISION}`;
 }
-function fit(value, budget) {
-    const room = budget - MARKER_CHARS;
-    if (Array.isArray(value)) {
-        const kept = [];
-        let used = 2;
-        for (const item of value) {
-            const size = JSON.stringify(item).length + 1;
-            if (used + size > room) {
-                const left = room - used;
-                if (left > MARKER_CHARS && shrinkable(item))
-                    kept.push(fit(item, left));
-                break;
+function fitArray(value, room) {
+    const kept = [];
+    let used = 2;
+    for (const item of value) {
+        const size = JSON.stringify(item).length + 1;
+        if (used + size > room) {
+            const left = room - used;
+            if (left > MARKER_CHARS && shrinkable(item)) {
+                kept.push(fit(item, left));
             }
-            kept.push(item);
-            used += size;
+            break;
         }
-        const dropped = value.length - kept.length;
-        if (dropped > 0)
-            kept.push(`… [${dropped} more items truncated]`);
-        return kept;
+        kept.push(item);
+        used += size;
     }
-    if (typeof value === 'object' && value !== null) {
-        const entries = Object.entries(value);
-        const out = {};
-        let used = 2;
-        let kept = 0;
-        let refitted = false;
-        for (const [key, item] of entries) {
-            const keySize = JSON.stringify(key).length + 2;
-            const size = keySize + JSON.stringify(item).length;
-            if (used + size > room) {
-                const left = room - used - keySize;
-                if (!refitted && left > MARKER_CHARS && shrinkable(item)) {
-                    const shrunk = fit(item, left);
-                    out[key] = shrunk;
-                    used += keySize + JSON.stringify(shrunk).length;
-                    refitted = true;
-                    kept++;
-                }
-                continue;
+    const dropped = value.length - kept.length;
+    if (dropped > 0) {
+        kept.push(`… [${dropped} more items truncated]`);
+    }
+    return kept;
+}
+function fitObject(value, room) {
+    const entries = Object.entries(value);
+    const out = {};
+    let used = 2;
+    let kept = 0;
+    let refitted = false;
+    for (const [key, item] of entries) {
+        const keySize = JSON.stringify(key).length + 2;
+        const size = keySize + JSON.stringify(item).length;
+        if (used + size > room) {
+            const left = room - used - keySize;
+            if (!refitted && left > MARKER_CHARS && shrinkable(item)) {
+                const shrunk = fit(item, left);
+                out[key] = shrunk;
+                used += keySize + JSON.stringify(shrunk).length;
+                refitted = true;
+                kept++;
             }
-            out[key] = item;
-            used += size;
-            kept++;
+            continue;
         }
-        if (kept < entries.length)
-            out['…'] = `[${entries.length - kept} more fields truncated]`;
-        return out;
+        out[key] = item;
+        used += size;
+        kept++;
+    }
+    if (kept < entries.length) {
+        out['…'] = `[${entries.length - kept} more fields truncated]`;
+    }
+    return out;
+}
+function fit(value, budget) {
+    const room = budget - MARKER_CHARS;
+    if (Array.isArray(value)) {
+        return fitArray(value, room);
+    }
+    if (isRecord(value)) {
+        return fitObject(value, room);
     }
     if (typeof value === 'string' && JSON.stringify(value).length > budget) {
         return fitString(value, budget);

package/dist-lib/lib/tools/http-request.d.ts

@@ -1,5 +1,5 @@
 import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type FetchInit } from './http-request/utils.ts';
+import { type FetchInit } from './http-request/request.ts';
 import { type CredentialAllowListFn, type CredentialStoreFn } from './skills/auth-resolver.ts';
 import { type HostResolver } from './url-guard.ts';
 export type FetchFn = (url: URL, init: FetchInit) => Promise<{

package/dist-lib/lib/tools/http-request.js

@@ -1,11 +1,11 @@
-import defaultFetch from '#no-redirect-fetch';
+import { noRedirectFetch } from '#no-redirect-fetch';
 import { AbortController } from 'bare-abort-controller';
 import { lookupHost } from '../dns-lookup.js';
 import { READ_METHODS } from './http-methods.js';
 import { encodeDeclaredFields } from './http-request/encode-fields.js';
 import { truncateResponseBody } from './http-request/truncate-response.js';
 import { AbortedError } from '../helpers/race-abort.js';
-import { applyQuery, buildHeaders, contentTypeOf, encodeBody, isRedirectStatus, parseJsonBody, parseObjectArg, TIMEOUT_MS } from './http-request/utils.js';
+import { applyQuery, buildHeaders, contentTypeOf, encodeBody, isRedirectStatus, parseJsonBody, parseObjectArg, TIMEOUT_MS } from './http-request/request.js';
 import { parseAuth, resolveBearerHeader, resolveRedirectBearerHeader } from './skills/auth-resolver.js';
 import { recordCredentialHealth } from './skills/credential-health.js';
 import { resolveOutboundUrl } from './url-guard.js';
@@ -47,8 +47,9 @@ export function createHttpRequestTool({ fetch: fetchImpl, credentialStore, crede
         autoApprove: false,
         effect(args) {
             const method = typeof args.method === 'string' ? args.method.toUpperCase() : undefined;
-            if (method === undefined || !READ_METHODS.has(method))
+            if (method === undefined || !READ_METHODS.has(method)) {
                 return 'write';
+            }
             return args.body === undefined && args.encode === undefined ? 'read' : 'write';
         },
         resource(args) {
@@ -72,39 +73,47 @@ export function createHttpRequestTool({ fetch: fetchImpl, credentialStore, crede
                 return { error: `unsupported protocol: ${url.protocol}` };
             }
             const query = parseObjectArg(args.query, 'query');
-            if (!query.ok)
+            if (!query.ok) {
                 return { error: query.error };
+            }
             const encodeArgs = parseObjectArg(args.encode, 'encode');
-            if (!encodeArgs.ok)
+            if (!encodeArgs.ok) {
                 return { error: encodeArgs.error };
+            }
             const headerArgs = parseObjectArg(args.headers, 'headers');
-            if (!headerArgs.ok)
+            if (!headerArgs.ok) {
                 return { error: headerArgs.error };
+            }
             const headers = headerArgs.value ? buildHeaders(headerArgs.value) : {};
             const parsedBody = parseJsonBody(args.body, contentTypeOf(headers));
-            if (!parsedBody.ok)
+            if (!parsedBody.ok) {
                 return { error: parsedBody.error };
-            if (query.value)
+            }
+            if (query.value) {
                 applyQuery(url, query.value);
+            }
             const auth = parseAuth(args.auth);
-            if (!auth.ok)
+            if (!auth.ok) {
                 return { error: auth.error };
+            }
             const allowList = credentialAllowList?.(ctx);
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(undefined), TIMEOUT_MS);
             try {
                 const initialCheck = await resolveOutboundUrl(url, resolveHost, controller.signal);
-                if (initialCheck.blocked)
+                if (initialCheck.blocked) {
                     return { error: initialCheck.blocked };
+                }
                 const bearer = await resolveBearerHeader(auth.value, url, credentialStore, allowList, ctx, controller.signal);
-                if ('error' in bearer)
+                if ('error' in bearer) {
                     return { error: bearer.error };
+                }
                 const redirectAuth = bearer.credentialKey
                     ? { type: 'bearer', tokenCredentialKey: bearer.credentialKey }
                     : undefined;
                 const encoded = encodeDeclaredFields(parsedBody.value, encodeArgs.value);
                 const requestBody = encodeBody(encoded, headers);
-                const fetch = fetchImpl ?? defaultFetch;
+                const fetch = fetchImpl ?? noRedirectFetch;
                 let currentUrl = url;
                 let method = args.method ?? 'GET';
                 let body = requestBody;
@@ -115,8 +124,9 @@ export function createHttpRequestTool({ fetch: fetchImpl, credentialStore, crede
                 for (let redirects = 0;; redirects++) {
                     const hopHeaders = { ...headers };
                     delete hopHeaders['Authorization'];
-                    if (header)
+                    if (header) {
                         hopHeaders['Authorization'] = header;
+                    }
                     response = await fetch(currentUrl, {
                         method,
                         headers: hopHeaders,
@@ -128,11 +138,13 @@ export function createHttpRequestTool({ fetch: fetchImpl, credentialStore, crede
                     if (credentialKey) {
                         recordCredentialHealth(credentialKey, response.status, ctx?.agentId);
                     }
-                    if (!isRedirectStatus(response.status))
+                    if (!isRedirectStatus(response.status)) {
                         break;
+                    }
                     const location = response.headers?.get('location');
-                    if (!location)
+                    if (!location) {
                         break;
+                    }
                     let nextUrl;
                     try {
                         nextUrl = new URL(location, currentUrl);
@@ -140,13 +152,16 @@ export function createHttpRequestTool({ fetch: fetchImpl, credentialStore, crede
                     catch {
                         break;
                     }
-                    if (nextUrl.protocol !== 'http:' && nextUrl.protocol !== 'https:')
+                    if (nextUrl.protocol !== 'http:' && nextUrl.protocol !== 'https:') {
                         break;
-                    if (redirects >= MAX_REDIRECTS)
+                    }
+                    if (redirects >= MAX_REDIRECTS) {
                         return { error: 'too many redirects' };
+                    }
                     const hopCheck = await resolveOutboundUrl(nextUrl, resolveHost, controller.signal);
-                    if (hopCheck.blocked)
+                    if (hopCheck.blocked) {
                         return { error: hopCheck.blocked };
+                    }
                     if (response.status === 303 ||
                         ((response.status === 301 || response.status === 302) && method === 'POST')) {
                         method = 'GET';

package/dist-lib/lib/tools/mcp/protocol.d.ts

@@ -0,0 +1,53 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { ToolExecuteContext } from '../../capabilities/completion.ts';
+import { type FetchInit } from '../http-request/request.ts';
+export declare const MCP_PROTOCOL_VERSION = "2025-03-26";
+export declare const TIMEOUT_MS = 30000;
+export interface McpHeaders {
+    get(name: string): string | null;
+}
+export interface McpResponseBody {
+    headers: McpHeaders;
+    text(): Promise<string> | string;
+}
+export interface McpResponse extends McpResponseBody {
+    status: number;
+    statusText?: string;
+}
+export type McpFetchFn = (url: URL, init: FetchInit) => Promise<McpResponse>;
+export declare function isNotification(method: string): boolean;
+export declare function isMetadataMethod(method: unknown): boolean;
+export interface McpRequest {
+    method: string;
+    params: Record<string, unknown> | undefined;
+}
+export declare function normalizeMethod(method: string, params: Record<string, unknown> | undefined): McpRequest;
+export interface McpError {
+    error: string;
+}
+export interface McpBody {
+    body: string;
+}
+export declare function flattenMcpResponse(body: string): McpError | McpBody;
+export declare function sessionKey(url: string, ctx: ToolExecuteContext | undefined, credentialKey?: string): string;
+export declare function getSession(key: string): string;
+export declare function deleteSession(key: string): void;
+export declare function cacheSession(key: string, sessionId: string): void;
+export interface McpPostOptions {
+    readonly method: string;
+    readonly params: Record<string, unknown> | undefined;
+    readonly authHeader: string | null;
+    readonly sessionId: string | undefined;
+    readonly signal: BareAbortSignal;
+}
+export declare function post(fetch: McpFetchFn, url: URL, { method, params, authHeader, sessionId, signal }: McpPostOptions): ReturnType<McpFetchFn>;
+export declare function readBody(response: McpResponseBody): Promise<string>;
+export declare function needsSession(status: number, cached: string): boolean;
+export interface McpSessionOptions {
+    readonly authHeader: string | null;
+    readonly signal: BareAbortSignal;
+}
+export interface McpSessionError extends McpError {
+    stateless?: true;
+}
+export declare function establishSession(fetch: McpFetchFn, url: URL, { authHeader, signal }: McpSessionOptions): Promise<string | McpSessionError>;

package/dist-lib/lib/tools/mcp/{utils.js → protocol.js}

@@ -1,4 +1,5 @@
-import { MAX_RESPONSE_CHARS } from '../http-request/utils.js';
+import { isRecord } from '../../guards.js';
+import { MAX_RESPONSE_CHARS } from '../http-request/request.js';
 export const MCP_PROTOCOL_VERSION = '2025-03-26';
 export const TIMEOUT_MS = 30_000;
 const METADATA_METHODS = new Set([
@@ -24,17 +25,20 @@ export function normalizeMethod(method, params) {
         const p = params ?? {};
         return { method, params: p.arguments === undefined ? { ...p, arguments: {} } : p };
     }
-    if (PROTOCOL_METHODS.has(method) || isNotification(method))
+    if (PROTOCOL_METHODS.has(method) || isNotification(method)) {
         return { method, params };
+    }
     return { method: 'tools/call', params: { name: method, arguments: params ?? {} } };
 }
 let nextId = 1;
 function buildEnvelope(method, params) {
     const envelope = { jsonrpc: '2.0', method };
-    if (params !== undefined)
+    if (params !== undefined) {
         envelope.params = params;
-    if (!isNotification(method))
+    }
+    if (!isNotification(method)) {
         envelope.id = String(nextId++);
+    }
     return JSON.stringify(envelope);
 }
 function headers(authHeader, sessionId) {
@@ -42,10 +46,12 @@ function headers(authHeader, sessionId) {
         'content-type': 'application/json',
         accept: 'application/json, text/event-stream'
     };
-    if (authHeader)
+    if (authHeader) {
         h.authorization = authHeader;
-    if (sessionId)
+    }
+    if (sessionId) {
         h['mcp-session-id'] = sessionId;
+    }
     return h;
 }
 function eventData(event) {
@@ -75,14 +81,13 @@ function decodePayload(body, contentType) {
     }
 }
 function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
+    return isRecord(value) && !Array.isArray(value) ? value : null;
 }
 function contentText(result) {
     const content = result?.content;
-    if (!Array.isArray(content))
+    if (!Array.isArray(content)) {
         return null;
+    }
     const texts = content.flatMap((entry) => {
         const item = asRecord(entry);
         return item?.type === 'text' && typeof item.text === 'string' ? [item.text] : [];
@@ -91,8 +96,9 @@ function contentText(result) {
 }
 function rpcErrorText(error) {
     const message = typeof error.message === 'string' ? error.message.trim() : '';
-    if (error.data === undefined)
+    if (error.data === undefined) {
         return message;
+    }
     return `${message} ${JSON.stringify(error.data)}`.trim();
 }
 export function flattenMcpResponse(body) {
@@ -104,15 +110,18 @@ export function flattenMcpResponse(body) {
         return { body: truncate(body) };
     }
     const record = asRecord(parsed);
-    if (!record)
+    if (!record) {
         return { body: truncate(body) };
+    }
     const rpcError = asRecord(record.error);
-    if (rpcError)
+    if (rpcError) {
         return { error: truncate(rpcErrorText(rpcError) || body.trim()) };
+    }
     const result = asRecord(record.result);
     const text = contentText(result)?.trim();
-    if (result?.isError === true)
+    if (result?.isError === true) {
         return { error: truncate(text || body.trim()) };
+    }
     return { body: truncate(text || body) };
 }
 function truncate(text) {
@@ -135,11 +144,12 @@ export function cacheSession(key, sessionId) {
     SESSION_CACHE.set(key, sessionId);
     if (SESSION_CACHE.size > SESSION_CACHE_MAX) {
         const oldest = SESSION_CACHE.keys().next().value;
-        if (oldest !== undefined)
+        if (oldest !== undefined) {
             SESSION_CACHE.delete(oldest);
+        }
     }
 }
-export function post(fetch, url, method, params, authHeader, sessionId, signal) {
+export function post(fetch, url, { method, params, authHeader, sessionId, signal }) {
     return fetch(url, {
         method: 'POST',
         headers: headers(authHeader, sessionId),
@@ -154,12 +164,18 @@ export async function readBody(response) {
 export function needsSession(status, cached) {
     return status === 400 || (status === 404 && cached !== '');
 }
-export async function establishSession(fetch, url, authHeader, signal) {
-    const init = await post(fetch, url, 'initialize', {
-        protocolVersion: MCP_PROTOCOL_VERSION,
-        capabilities: {},
-        clientInfo: { name: 'QV.AC', version: '0.8.x' }
-    }, authHeader, undefined, signal);
+export async function establishSession(fetch, url, { authHeader, signal }) {
+    const init = await post(fetch, url, {
+        method: 'initialize',
+        params: {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'QV.AC', version: '0.8.x' }
+        },
+        authHeader,
+        sessionId: undefined,
+        signal
+    });
     const sessionId = init.headers.get('mcp-session-id');
     if (init.status < 200 || init.status >= 300) {
         return { error: `initialize failed: ${init.status}\n${await readBody(init)}` };
@@ -167,6 +183,12 @@ export async function establishSession(fetch, url, authHeader, signal) {
     if (!sessionId) {
         return { error: 'initialize returned no Mcp-Session-Id header', stateless: true };
     }
-    await post(fetch, url, 'notifications/initialized', undefined, authHeader, sessionId, signal);
+    await post(fetch, url, {
+        method: 'notifications/initialized',
+        params: undefined,
+        authHeader,
+        sessionId,
+        signal
+    });
     return sessionId;
 }

package/dist-lib/lib/tools/mcp-call.d.ts

@@ -1,5 +1,5 @@
 import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type McpFetchFn } from './mcp/utils.ts';
+import { type McpFetchFn } from './mcp/protocol.ts';
 import { type CredentialAllowListFn, type CredentialStoreFn } from './skills/auth-resolver.ts';
 import { type HostResolver } from './url-guard.ts';
 export type { McpFetchFn };

package/dist-lib/lib/tools/mcp-call.js

@@ -1,10 +1,10 @@
-import defaultFetch from '#no-redirect-fetch';
+import { noRedirectFetch } from '#no-redirect-fetch';
 import { AbortController } from 'bare-abort-controller';
 import { MCP_CALL_TOOL_NAME } from '../capabilities/tool-names.js';
 import { lookupHost } from '../dns-lookup.js';
 import { AbortedError } from '../helpers/race-abort.js';
-import { isRedirectStatus, parseObjectArg } from './http-request/utils.js';
-import { cacheSession, deleteSession, establishSession, flattenMcpResponse, getSession, isNotification, needsSession, normalizeMethod, post, readBody, sessionKey, TIMEOUT_MS } from './mcp/utils.js';
+import { isRedirectStatus, parseObjectArg } from './http-request/request.js';
+import { cacheSession, deleteSession, establishSession, flattenMcpResponse, getSession, isNotification, needsSession, normalizeMethod, post, readBody, sessionKey, TIMEOUT_MS } from './mcp/protocol.js';
 import { parseAuth, resolveBearerHeader } from './skills/auth-resolver.js';
 import { recordCredentialHealth } from './skills/credential-health.js';
 import { resolveOutboundUrl } from './url-guard.js';
@@ -13,8 +13,9 @@ function nestedUrl(params) {
 }
 function parseMcpParams(value) {
     const parsed = parseObjectArg(value, 'params');
-    if (parsed.ok || typeof value !== 'string')
+    if (parsed.ok || typeof value !== 'string') {
         return parsed;
+    }
     return parseObjectArg(value.replace(/[“”]/g, '"'), 'params');
 }
 function toolParams(params, liftedNestedUrl) {
@@ -74,11 +75,11 @@ export function createMcpCallTool({ fetch: fetchImpl, credentialStore, credentia
                 return null;
             }
         },
-        async execute(rawArgs, ctx) {
-            const args = rawArgs;
+        async execute(args, ctx) {
             const rawParams = parseMcpParams(args.params);
-            if (!rawParams.ok)
+            if (!rawParams.ok) {
                 return { error: rawParams.error };
+            }
             const topLevelUrl = typeof args.url === 'string' && args.url.length > 0 ? args.url : undefined;
             const urlValue = topLevelUrl ?? nestedUrl(rawParams.value);
             let url;
@@ -95,30 +96,48 @@ export function createMcpCallTool({ fetch: fetchImpl, credentialStore, credentia
                 return { error: 'method must be a non-empty string' };
             }
             const parsedAuth = parseAuth(args.auth);
-            if (!parsedAuth.ok)
+            if (!parsedAuth.ok) {
                 return { error: parsedAuth.error };
+            }
             const { method, params } = normalizeMethod(args.method, toolParams(rawParams.value, topLevelUrl === undefined && urlValue !== undefined));
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(undefined), TIMEOUT_MS);
             try {
                 const urlCheck = await resolveOutboundUrl(url, resolveHost, controller.signal);
-                if (urlCheck.blocked)
+                if (urlCheck.blocked) {
                     return { error: urlCheck.blocked };
+                }
                 const bearer = await resolveBearerHeader(parsedAuth.value, url, credentialStore, credentialAllowList?.(ctx), ctx, controller.signal);
-                if ('error' in bearer)
+                if ('error' in bearer) {
                     return { error: bearer.error };
+                }
                 const authHeader = bearer.header;
-                const fetch = fetchImpl ?? defaultFetch;
+                const fetch = fetchImpl ?? noRedirectFetch;
                 const guardedFetch = (target, init) => fetch(target, { ...init, validatedAddresses: urlCheck.addresses });
                 const key = sessionKey(url.href, ctx, bearer.credentialKey);
                 const cached = getSession(key);
-                let response = await post(guardedFetch, url, method, params, authHeader, cached || undefined, controller.signal);
+                let response = await post(guardedFetch, url, {
+                    method,
+                    params,
+                    authHeader,
+                    sessionId: cached || undefined,
+                    signal: controller.signal
+                });
                 if (needsSession(response.status, cached)) {
                     deleteSession(key);
-                    const session = await establishSession(guardedFetch, url, authHeader, controller.signal);
+                    const session = await establishSession(guardedFetch, url, {
+                        authHeader,
+                        signal: controller.signal
+                    });
                     if (typeof session === 'string') {
                         cacheSession(key, session);
-                        response = await post(guardedFetch, url, method, params, authHeader, session, controller.signal);
+                        response = await post(guardedFetch, url, {
+                            method,
+                            params,
+                            authHeader,
+                            sessionId: session,
+                            signal: controller.signal
+                        });
                     }
                     else if (!session.stateless) {
                         return { error: session.error };
@@ -126,8 +145,9 @@ export function createMcpCallTool({ fetch: fetchImpl, credentialStore, credentia
                 }
                 else {
                     const issued = response.headers.get('mcp-session-id');
-                    if (issued)
+                    if (issued) {
                         cacheSession(key, issued);
+                    }
                 }
                 if (isRedirectStatus(response.status)) {
                     return { error: `MCP server responded with an unexpected redirect (${response.status})` };
@@ -135,8 +155,9 @@ export function createMcpCallTool({ fetch: fetchImpl, credentialStore, credentia
                 if (bearer.credentialKey) {
                     recordCredentialHealth(bearer.credentialKey, response.status, ctx?.agentId);
                 }
-                if (isNotification(method))
+                if (isNotification(method)) {
                     return { status: response.status, body: '' };
+                }
                 return { status: response.status, ...flattenMcpResponse(await readBody(response)) };
             }
             catch (err) {

package/dist-lib/lib/tools/operations/builders.js

@@ -22,15 +22,16 @@ function builder(schema, build) {
     return {
         build(args) {
             const parsed = schema.safeParse(args);
-            if (!parsed.success)
+            if (!parsed.success) {
                 return { error: parsed.error.issues[0]?.message ?? 'invalid arguments' };
+            }
             return { request: build(parsed.data) };
         }
     };
 }
 const GmailMessageSchema = z
     .object({ ...GmailEnvelopeSchema.shape, threadId: z.string().optional() })
-    .refine((value) => Boolean(value.text?.length) || Boolean(value.html?.length), {
+    .refine((value) => !!value.text?.length || !!value.html?.length, {
     message: 'either text or html is required'
 });
 const gmailSend = builder(GmailMessageSchema, (args) => ({
@@ -51,7 +52,7 @@ const gmailGet = builder(GmailGetSchema, (args) => ({
 function createRequest() {
     return {
         createRequest: {
-            requestId: b4a.toString(randomBytes(16), 'hex'),
+            requestId: b4a.toHex(randomBytes(16)),
             conferenceSolutionKey: { type: 'hangoutsMeet' }
         }
     };
@@ -98,8 +99,9 @@ const docsAppendText = builder(DocsAppendSchema, (args) => {
     const requests = [
         { insertText: { endOfSegmentLocation: {}, text: args.text } }
     ];
-    if (args.pageBreak)
+    if (args.pageBreak) {
         requests.push({ insertPageBreak: { endOfSegmentLocation: {} } });
+    }
     return { body: { requests } };
 });
 const sheetsCreate = builder(z.object({ name: z.string().min(1) }), (args) => ({
@@ -145,10 +147,12 @@ const NotionCreatePageSchema = z
     message: 'pass parentPageId or parentDatabaseId, not both'
 });
 function notionParent(args) {
-    if (args.parentPageId)
+    if (args.parentPageId) {
         return { page_id: args.parentPageId };
-    if (args.parentDatabaseId)
+    }
+    if (args.parentDatabaseId) {
         return { database_id: args.parentDatabaseId };
+    }
     return undefined;
 }
 const notionCreatePage = builder(NotionCreatePageSchema, (args) => ({