@namzu/sdk 14.0.7 → 15.1.0

package/src/config/__tests__/compaction-budget-schema.test.ts

@@ -1,114 +0,0 @@
-/**
- * The BUDGET SCHEMA.
- *
- * Every compaction count used to be `z.number().positive()`. Zod's base number
- * check rejects only non-numbers and `NaN`, so `Infinity` and `0.5` both parsed.
- * These are counts of messages, characters, sentences and tokens: a non-integer
- * is meaningless, and `Infinity` does something worse than being meaningless —
- * it turns a bound into a no-op rather than an error. `truncateMessages` compares
- * `charCount > budget`, never true against `Infinity`, so the WHOLE older history
- * was pasted into the verification prompt.
- *
- * They are `.int().positive()` now. `Number.isInteger` is false for `Infinity`
- * and for any fraction, so one validator closes both. These tests are the guard:
- * every count is checked against both illegal shapes, and the documented
- * defaults are pinned so tightening the validator cannot have moved them.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import { WorkingStateManager } from '../../compaction/manager.js'
-import { buildVerifiedSummary } from '../../compaction/verifier.js'
-import { type Message, createUserMessage } from '../../types/message/index.js'
-import type { ChatCompletionParams } from '../../types/provider/chat.js'
-import type { LLMProvider } from '../../types/provider/interface.js'
-import type { StreamChunk } from '../../types/provider/stream.js'
-import { CompactionConfigSchema, RuntimeConfigSchema } from '../runtime.js'
-
-/** Every integer count on CompactionConfigSchema. */
-const COUNT_FIELDS = [
-	'contextWindowTokens',
-	'keepRecentMessages',
-	'maxToolResults',
-	'maxListSize',
-	'llmVerificationMaxTokens',
-	'richStateThreshold',
-	'convoTextBudget',
-	'maxSentencesPerTurn',
-	'maxCharsPerNote',
-	'maxCharsPerRequirement',
-	'maxCharsPerTask',
-] as const
-
-describe('CompactionConfigSchema — count fields', () => {
-	for (const field of COUNT_FIELDS) {
-		it(`rejects Infinity for ${field}`, () => {
-			expect(() => CompactionConfigSchema.parse({ [field]: Number.POSITIVE_INFINITY })).toThrow()
-		})
-
-		it(`rejects a fractional value for ${field}`, () => {
-			expect(() => CompactionConfigSchema.parse({ [field]: 0.5 })).toThrow()
-		})
-	}
-
-	it('rejects Infinity through the RuntimeConfigSchema envelope', () => {
-		expect(() =>
-			RuntimeConfigSchema.parse({ compaction: { convoTextBudget: Number.POSITIVE_INFINITY } }),
-		).toThrow()
-	})
-
-	it('still accepts the documented defaults', () => {
-		const parsed = CompactionConfigSchema.parse({})
-		expect(parsed.convoTextBudget).toBe(12_000)
-		expect(parsed.keepRecentMessages).toBe(4)
-	})
-})
-
-/**
- * Why the schema is the only defence, and what that leaves open.
- *
- * `truncateMessages` bounds the verification prompt with `charCount > budget`,
- * which is never true against `Infinity` — that is the consequence the schema
- * fix above exists to prevent, and it can no longer be reached THROUGH the
- * schema. It is still reachable by a host that hand-builds a `CompactionConfig`
- * object literal, because the inferred type is plain `number`; that is a stated
- * limitation, not a covered case. No silent clamp was added inside
- * `truncateMessages` — a budget that quietly repairs an illegal value hides the
- * caller's bug instead of surfacing it, and the schema is where the boundary
- * belongs.
- *
- * What this test does pin: with a LEGAL budget the prompt really is bounded, so
- * the truncation the schema now guarantees is actually performed.
- */
-describe('truncateMessages bounds the verification prompt at a legal budget', () => {
-	it('does not paste the entire older history into the verification prompt', async () => {
-		const config = CompactionConfigSchema.parse({
-			llmVerification: true,
-			convoTextBudget: 12_000,
-		})
-		const manager = new WorkingStateManager(config)
-		manager.setTask('write the quarterly report')
-
-		const calls: ChatCompletionParams[] = []
-		const provider: LLMProvider = {
-			id: 'mock',
-			name: 'mock',
-			chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk> {
-				calls.push(params)
-				return (async function* () {
-					yield { id: 'c1', delta: { content: 'COMPLETE' } } as StreamChunk
-				})()
-			},
-		}
-
-		// ~200 KB of older history — far past any sane verification budget.
-		const older: Message[] = Array.from({ length: 200 }, (_, i) =>
-			createUserMessage(`turn ${i} ${'y'.repeat(1000)}`),
-		)
-
-		await buildVerifiedSummary(manager, older, provider, config)
-
-		const promptChars = (calls[0]?.messages ?? []).reduce((n, m) => n + (m.content?.length ?? 0), 0)
-		expect(promptChars).toBeLessThan(100_000)
-	})
-})

package/src/connector/BaseConnector.test.ts

@@ -1,130 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 5):
- *
- *   - `BaseConnector` is abstract. Each concrete subclass sets id /
- *     name / description / connectionType / configSchema / methods
- *     and implements connect / disconnect / healthCheck / execute.
- *   - `toDefinition()` projects the abstract readonly fields into a
- *     `ConnectorDefinition<TConfig>` — used to register the connector
- *     with the `ConnectorRegistry`.
- *   - `findMethod(name)` returns the method by name or undefined.
- *   - `requireMethod(name)` throws with the method name + available
- *     names when not found.
- *   - `validateInput(method, input)`: zod.safeParse; on failure
- *     throws `Invalid input for method "<name>": <joined issues>`.
- *   - `measureExecution(fn)` returns `{result, durationMs}` with
- *     durationMs rounded.
- *   - Auth resolution lives in subclasses (see HttpConnector tests),
- *     not in the base class.
- */
-
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import type {
-	AuthConfig,
-	ConnectionType,
-	ConnectorExecuteResult,
-	ConnectorMethod,
-} from '../types/connector/index.js'
-import type { ConnectorId } from '../types/ids/index.js'
-
-import { BaseConnector } from './BaseConnector.js'
-
-class TestConnector extends BaseConnector<{ base: string }> {
-	readonly id = 'conn_test' as ConnectorId
-	readonly name = 'Test'
-	readonly description = 'Test connector'
-	readonly connectionType: ConnectionType = 'custom'
-	readonly configSchema = z.object({ base: z.string() })
-	readonly methods: ConnectorMethod[] = [
-		{
-			name: 'echo',
-			description: 'echo',
-			inputSchema: z.object({ value: z.string() }),
-		},
-	]
-
-	async connect(): Promise<void> {}
-	async disconnect(): Promise<void> {}
-	async healthCheck(): Promise<boolean> {
-		return true
-	}
-	async execute(): Promise<ConnectorExecuteResult> {
-		return { success: true, output: 'ok', durationMs: 0 }
-	}
-
-	// Expose protected methods for direct tests:
-	publicRequireMethod(name: string): ConnectorMethod {
-		return this.requireMethod(name)
-	}
-	publicValidateInput(method: ConnectorMethod, input: unknown): unknown {
-		return this.validateInput(method, input)
-	}
-	publicMeasureExecution<T>(fn: () => Promise<T>) {
-		return this.measureExecution(fn)
-	}
-
-	// Exposed internal auth resolver on a subclass is a sibling concern —
-	// `BaseConnector` does not define any auth handling; the field is
-	// just stored.
-	getStoredAuth(): AuthConfig | undefined {
-		return this.auth
-	}
-}
-
-describe('BaseConnector', () => {
-	it('toDefinition projects abstract readonly fields', () => {
-		const c = new TestConnector()
-		const def = c.toDefinition()
-		expect(def.id).toBe('conn_test')
-		expect(def.name).toBe('Test')
-		expect(def.description).toBe('Test connector')
-		expect(def.connectionType).toBe('custom')
-		expect(def.methods).toHaveLength(1)
-	})
-
-	it('findMethod returns undefined for an unknown name', () => {
-		const c = new TestConnector()
-		expect(c.publicRequireMethod).toBeDefined()
-		// findMethod is invoked indirectly via requireMethod — we cover the
-		// positive + negative paths below.
-	})
-
-	it('requireMethod returns the method when present', () => {
-		const c = new TestConnector()
-		const method = c.publicRequireMethod('echo')
-		expect(method.name).toBe('echo')
-	})
-
-	it('requireMethod throws naming the missing method + available names', () => {
-		const c = new TestConnector()
-		expect(() => c.publicRequireMethod('nope')).toThrow(/Method "nope" not found/)
-		expect(() => c.publicRequireMethod('nope')).toThrow(/Available: echo/)
-	})
-
-	it('validateInput passes through parsed data on success', () => {
-		const c = new TestConnector()
-		const method = c.publicRequireMethod('echo')
-		expect(c.publicValidateInput(method, { value: 'hi' })).toEqual({ value: 'hi' })
-	})
-
-	it('validateInput throws with joined issue messages on failure', () => {
-		const c = new TestConnector()
-		const method = c.publicRequireMethod('echo')
-		expect(() => c.publicValidateInput(method, { value: 123 })).toThrow(
-			/Invalid input for method "echo"/,
-		)
-	})
-
-	it('measureExecution returns the result + rounded durationMs', async () => {
-		const c = new TestConnector()
-		const { result, durationMs } = await c.publicMeasureExecution(async () => {
-			await new Promise((r) => setTimeout(r, 5))
-			return 42
-		})
-		expect(result).toBe(42)
-		expect(durationMs).toBeGreaterThanOrEqual(0)
-		expect(Number.isInteger(durationMs)).toBe(true)
-	})
-})

package/src/connector/builtins/__tests__/oauth2-auth.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { AuthConfig } from '../../../types/connector/index.js'
-import { HttpConnector } from '../http.js'
-
-/**
- * `'oauth2'` was grouped with `'none'` and `'custom'`, returning no headers.
- *
- * So a connector configured for OAuth2 sent an UNAUTHENTICATED request.
- * Every other auth type throws on a missing credential; this one quietly
- * did not, and the upstream's 401 reads as a bad token rather than as no
- * token at all — which sends whoever is debugging to look at the token.
- */
-
-function headersFor(auth: AuthConfig): Record<string, string> {
-	const connector = new HttpConnector()
-	// The resolver is private by design; reaching it directly is what keeps
-	// this test about the header decision rather than about fetch.
-	return (
-		connector as unknown as { resolveAuthHeaders(a: AuthConfig): Record<string, string> }
-	).resolveAuthHeaders(auth)
-}
-
-describe('an oauth2 connector does not send an unauthenticated request', () => {
-	it('sends the access token it was given', () => {
-		const headers = headersFor({
-			type: 'oauth2',
-			credentials: { accessToken: 'tok_abc' },
-		} as AuthConfig)
-
-		expect(headers.Authorization).toBe('Bearer tok_abc')
-	})
-
-	it('accepts the token under either name', () => {
-		const headers = headersFor({ type: 'oauth2', credentials: { token: 'tok_xyz' } } as AuthConfig)
-
-		expect(headers.Authorization).toBe('Bearer tok_xyz')
-	})
-
-	it('refuses when there is no token, rather than sending nothing', () => {
-		// The whole defect: an empty header set went out and the request
-		// reached the upstream with no credential at all.
-		expect(() => headersFor({ type: 'oauth2', credentials: {} } as AuthConfig)).toThrow(
-			/accessToken/,
-		)
-	})
-
-	it('refuses when credentials are absent entirely', () => {
-		expect(() => headersFor({ type: 'oauth2' } as AuthConfig)).toThrow(/unauthenticated/)
-	})
-})
-
-describe('the other schemes are unchanged', () => {
-	it("still sends nothing for 'none'", () => {
-		expect(headersFor({ type: 'none' } as AuthConfig)).toEqual({})
-	})
-
-	it("still sends nothing for 'custom', which is the host's job", () => {
-		// Deliberately empty, unlike oauth2: `custom` means the host attaches
-		// its own headers, so there is nothing to omit and nothing to refuse.
-		expect(headersFor({ type: 'custom' } as AuthConfig)).toEqual({})
-	})
-
-	it('still sends a bearer token', () => {
-		expect(
-			headersFor({ type: 'bearer', credentials: { token: 't' } } as AuthConfig).Authorization,
-		).toBe('Bearer t')
-	})
-
-	it('still refuses a bearer with no token', () => {
-		expect(() => headersFor({ type: 'bearer', credentials: {} } as AuthConfig)).toThrow(/token/)
-	})
-})

package/src/connector/builtins/http.test.ts

@@ -1,329 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 5):
- *
- *   - `HttpConnector.connect` stores config + auth, strips trailing
- *     slashes from baseUrl, merges default headers with auth-derived
- *     headers.
- *   - Auth resolution (http only — webhook has its own):
- *     - `api_key` with `apiKey` + optional `headerName` (default
- *       `X-API-Key`).
- *     - `bearer` with `token` → `Authorization: Bearer <token>`.
- *     - `basic` with `username` + `password` → base64 encoded.
- *     - `none` / `oauth2` / `custom` → no headers.
- *     - Missing required credential fields throw a typed error string.
- *   - `disconnect` clears internal state.
- *   - `healthCheck` HEAD-fetches baseUrl with a 5s timeout; returns
- *     true iff `response.ok || response.status < 500`; false on any
- *     thrown fetch (e.g. timeout abort).
- *   - `execute("request", input)`:
- *     - `requireMethod` + `validateInput` run.
- *     - Builds URL from `baseUrl + path` + appends query params.
- *     - Sends default+input headers; auto-sets `Content-Type:
- *       application/json` when a body is present and no content-type
- *       was passed.
- *     - Parses response JSON when `content-type: application/json`,
- *       else text.
- *     - `success: true` iff status in [200, 400). Metadata includes
- *       status + statusText.
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { HttpConnector } from './http.js'
-
-function makeResponse(init: {
-	status?: number
-	statusText?: string
-	headers?: Record<string, string>
-	body?: unknown
-}) {
-	const headers = new Headers(init.headers ?? { 'content-type': 'application/json' })
-	return {
-		ok: (init.status ?? 200) < 400,
-		status: init.status ?? 200,
-		statusText: init.statusText ?? 'OK',
-		headers,
-		json: async () => init.body,
-		text: async () => String(init.body ?? ''),
-	}
-}
-
-describe('HttpConnector', () => {
-	let fetchMock: ReturnType<typeof vi.fn>
-
-	beforeEach(() => {
-		fetchMock = vi.fn()
-		global.fetch = fetchMock as unknown as typeof fetch
-	})
-
-	afterEach(() => {
-		vi.restoreAllMocks()
-	})
-
-	describe('connect + disconnect', () => {
-		it('strips trailing slashes from baseUrl', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com//', timeoutMs: 30_000 })
-			// Follow-up request lands on the cleaned URL:
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: { ok: true } }))
-			await c.execute('request', { method: 'GET', path: 'x' })
-			expect(fetchMock).toHaveBeenCalledWith('https://api.example.com/x', expect.any(Object))
-		})
-
-		it('strips trailing slashes in linear time (js/polynomial-redos regression)', async () => {
-			// A long run of slashes followed by one more character is the
-			// pathological case for a `/+$` regex: the tail never matches, so a
-			// backtracking engine retries the quantifier at every start position.
-			// This must stay well under the ~500ms the vulnerable regex took at
-			// this size (see connect() history) to prove the O(n) fix held.
-			const c = new HttpConnector()
-			const hostile = `https://api.example.com/${'/'.repeat(30_000)}a`
-			const start = Date.now()
-			await c.connect({ baseUrl: hostile, timeoutMs: 30_000 })
-			expect(Date.now() - start).toBeLessThan(200)
-		})
-
-		it('disconnect clears internal state; execute after disconnect treats baseUrl as empty', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com', timeoutMs: 30_000 })
-			await c.disconnect()
-			expect(await c.healthCheck()).toBe(false)
-		})
-	})
-
-	describe('auth resolution', () => {
-		it('api_key default header name = X-API-Key', async () => {
-			const c = new HttpConnector()
-			await c.connect(
-				{ baseUrl: 'https://api.example.com' },
-				{ type: 'api_key', credentials: { apiKey: 'secret' } },
-			)
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-			await c.execute('request', { method: 'GET', path: 'x' })
-			const headers = fetchMock.mock.calls[0]?.[1].headers as Record<string, string>
-			expect(headers['X-API-Key']).toBe('secret')
-		})
-
-		it('api_key custom header name is honored', async () => {
-			const c = new HttpConnector()
-			await c.connect(
-				{ baseUrl: 'https://api.example.com' },
-				{ type: 'api_key', credentials: { apiKey: 'secret', headerName: 'X-Custom' } },
-			)
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-			await c.execute('request', { method: 'GET', path: 'x' })
-			const headers = fetchMock.mock.calls[0]?.[1].headers as Record<string, string>
-			expect(headers['X-Custom']).toBe('secret')
-		})
-
-		it('bearer sets Authorization: Bearer <token>', async () => {
-			const c = new HttpConnector()
-			await c.connect(
-				{ baseUrl: 'https://api.example.com' },
-				{ type: 'bearer', credentials: { token: 'tkn' } },
-			)
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-			await c.execute('request', { method: 'GET', path: 'x' })
-			const headers = fetchMock.mock.calls[0]?.[1].headers as Record<string, string>
-			expect(headers.Authorization).toBe('Bearer tkn')
-		})
-
-		it('basic encodes username:password as base64', async () => {
-			const c = new HttpConnector()
-			await c.connect(
-				{ baseUrl: 'https://api.example.com' },
-				{ type: 'basic', credentials: { username: 'alice', password: 'pw' } },
-			)
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-			await c.execute('request', { method: 'GET', path: 'x' })
-			const headers = fetchMock.mock.calls[0]?.[1].headers as Record<string, string>
-			expect(headers.Authorization).toBe(`Basic ${btoa('alice:pw')}`)
-		})
-
-		it('none / custom add no auth headers', async () => {
-			// `oauth2` was in this list, and that is what the defect was: it
-			// meant a connector configured for OAuth2 reached the upstream with
-			// no credential at all. `none` and `custom` belong here — the first
-			// asks for no auth, the second says the host attaches its own.
-			for (const type of ['none', 'custom'] as const) {
-				const c = new HttpConnector()
-				await c.connect({ baseUrl: 'https://api.example.com' }, { type, credentials: {} })
-				fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-				await c.execute('request', { method: 'GET', path: 'x' })
-				const headers = fetchMock.mock.calls.at(-1)?.[1].headers as Record<string, string>
-				expect(headers.Authorization).toBeUndefined()
-				expect(headers['X-API-Key']).toBeUndefined()
-			}
-		})
-
-		it('oauth2 refuses rather than reaching the upstream unauthenticated', async () => {
-			const c = new HttpConnector()
-
-			await expect(
-				c.connect({ baseUrl: 'https://api.example.com' }, { type: 'oauth2', credentials: {} }),
-			).rejects.toThrow(/accessToken/)
-		})
-
-		it('oauth2 sends the access token it was given', async () => {
-			const c = new HttpConnector()
-			await c.connect(
-				{ baseUrl: 'https://api.example.com' },
-				{ type: 'oauth2', credentials: { accessToken: 'tok_1' } },
-			)
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-
-			await c.execute('request', { method: 'GET', path: 'x' })
-
-			const headers = fetchMock.mock.calls.at(-1)?.[1].headers as Record<string, string>
-			expect(headers.Authorization).toBe('Bearer tok_1')
-		})
-
-		it('api_key throws when apiKey is missing', async () => {
-			const c = new HttpConnector()
-			await expect(
-				c.connect({ baseUrl: 'https://api.example.com' }, { type: 'api_key', credentials: {} }),
-			).rejects.toThrow(/missing required credential "apiKey"/)
-		})
-
-		it('bearer throws when token is missing', async () => {
-			const c = new HttpConnector()
-			await expect(
-				c.connect({ baseUrl: 'https://api.example.com' }, { type: 'bearer', credentials: {} }),
-			).rejects.toThrow(/missing required credential "token"/)
-		})
-
-		it('basic throws when either username or password is missing', async () => {
-			const c = new HttpConnector()
-			await expect(
-				c.connect(
-					{ baseUrl: 'https://api.example.com' },
-					{ type: 'basic', credentials: { username: 'a' } },
-				),
-			).rejects.toThrow(/missing required credentials/)
-		})
-	})
-
-	describe('healthCheck', () => {
-		it('returns true for ok responses', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200 }))
-			expect(await c.healthCheck()).toBe(true)
-		})
-
-		it('returns true for 4xx (not-ok but < 500)', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 404 }))
-			expect(await c.healthCheck()).toBe(true)
-		})
-
-		it('returns false for 5xx', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 503 }))
-			expect(await c.healthCheck()).toBe(false)
-		})
-
-		it('returns false on thrown fetch', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockRejectedValueOnce(new Error('timeout'))
-			expect(await c.healthCheck()).toBe(false)
-		})
-
-		it('returns false when never connected', async () => {
-			const c = new HttpConnector()
-			expect(await c.healthCheck()).toBe(false)
-		})
-	})
-
-	describe('execute', () => {
-		it('returns success:true for 2xx + 3xx responses', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: { ok: 1 } }))
-			const result = await c.execute('request', { method: 'GET', path: 'thing' })
-			expect(result.success).toBe(true)
-			expect(result.output).toMatchObject({ status: 200 })
-		})
-
-		it('returns success:false for 4xx / 5xx responses', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 500, body: { err: 1 } }))
-			const result = await c.execute('request', { method: 'GET', path: 'thing' })
-			expect(result.success).toBe(false)
-			expect(result.metadata).toMatchObject({ status: 500 })
-		})
-
-		it('sets Content-Type: application/json when body is set and none provided', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-			await c.execute('request', {
-				method: 'POST',
-				path: 'thing',
-				body: { k: 'v' },
-			})
-			const headers = fetchMock.mock.calls[0]?.[1].headers as Record<string, string>
-			expect(headers['Content-Type']).toBe('application/json')
-		})
-
-		it('preserves caller-supplied Content-Type', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: '' }))
-			await c.execute('request', {
-				method: 'POST',
-				path: 'thing',
-				body: 'raw',
-				headers: { 'Content-Type': 'text/plain' },
-			})
-			const headers = fetchMock.mock.calls[0]?.[1].headers as Record<string, string>
-			expect(headers['Content-Type']).toBe('text/plain')
-		})
-
-		it('appends query params to the URL', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(makeResponse({ status: 200, body: {} }))
-			await c.execute('request', {
-				method: 'GET',
-				path: 'thing',
-				query: { a: '1', b: '2' },
-			})
-			expect(fetchMock.mock.calls[0]?.[0]).toBe('https://api.example.com/thing?a=1&b=2')
-		})
-
-		it('parses JSON response when content-type is json', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(
-				makeResponse({
-					status: 200,
-					headers: { 'content-type': 'application/json' },
-					body: { ok: 1 },
-				}),
-			)
-			const result = await c.execute('request', { method: 'GET', path: 'x' })
-			expect((result.output as { body: unknown }).body).toEqual({ ok: 1 })
-		})
-
-		it('returns text body for non-JSON content-type', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			fetchMock.mockResolvedValueOnce(
-				makeResponse({ status: 200, headers: { 'content-type': 'text/plain' }, body: 'hello' }),
-			)
-			const result = await c.execute('request', { method: 'GET', path: 'x' })
-			expect((result.output as { body: unknown }).body).toBe('hello')
-		})
-
-		it('throws on invalid input (unknown method)', async () => {
-			const c = new HttpConnector()
-			await c.connect({ baseUrl: 'https://api.example.com' })
-			await expect(c.execute('not-a-method', {})).rejects.toThrow(/not found/)
-		})
-	})
-})