@mcpmake/core 0.2.3 → 0.2.5

package/dist/emitter/templates/auth-provider.ts.hbs

@@ -3,51 +3,88 @@ import type { AppConfig } from './config.js';
 import { getAccessToken } from './oauth.js';
 {{/if}}
 
+/**
+ * Per-operation outbound-auth requirement (D-H2), forwarded from the tool
+ * handler. Mirrors the generator's ToolAuthRequirement:
+ *   - undefined            → apply every configured scheme (global default).
+ *   - { mode: 'public' }   → apply NO auth (operation declared `security: []`).
+ *   - { mode: 'schemes' }  → apply ONLY the listed OpenAPI scheme names.
+ */
+export type AuthRequirement =
+  | { mode: 'public' }
+  | { mode: 'schemes'; schemeNames: string[] };
+
+/** Whether the scheme named `name` should be applied for this requirement. */
+function schemeApplies(req: AuthRequirement | undefined, name: string): boolean {
+  if (!req) return true; // no per-op requirement → legacy global behavior
+  if (req.mode === 'public') return false; // explicit `security: []`
+  return req.schemeNames.includes(name);
+}
+
 {{#if hasOAuth}}
-export async function getAuthHeaders(config: AppConfig): Promise<Record<string, string>> {
+export async function getAuthHeaders(
+  config: AppConfig,
+  requirement?: AuthRequirement,
+): Promise<Record<string, string>> {
 {{else}}
-export function getAuthHeaders(config: AppConfig): Record<string, string> {
+export function getAuthHeaders(
+  config: AppConfig,
+  requirement?: AuthRequirement,
+): Record<string, string> {
 {{/if}}
   const headers: Record<string, string> = {};
 
 {{#each authSchemes}}
 {{#if (eq type "apiKey")}}
 {{#if (eq in "header")}}
-  if (config.apiKey) {
+  if (config.apiKey && schemeApplies(requirement, {{{json schemeName}}})) {
     headers['{{headerName}}'] = config.apiKey;
   }
 {{/if}}
+{{#if (eq in "cookie")}}
+  // API key sent as a cookie — appended to the Cookie header so it survives
+  // alongside any per-operation cookie parameters set by the handler.
+  if (config.apiKey && schemeApplies(requirement, {{{json schemeName}}})) {
+    const existing = headers['Cookie'];
+    const pair = '{{headerName}}=' + encodeURIComponent(config.apiKey);
+    headers['Cookie'] = existing ? existing + '; ' + pair : pair;
+  }
+{{/if}}
 {{#if (eq in "query")}}
-  // API key sent as query parameter — handled in request URL construction
+  // API key is sent as a query parameter (`{{headerName}}`). Query-string auth is
+  // applied during URL construction (apiKeyQueryName/apiKeyQueryValue in config),
+  // not as a header, so there is nothing to add here.
 {{/if}}
 {{/if}}
 {{#if (eq type "http-bearer")}}
-  if (config.bearerToken) {
+  if (config.bearerToken && schemeApplies(requirement, {{{json schemeName}}})) {
     headers['Authorization'] = `Bearer ${config.bearerToken}`;
   }
 {{/if}}
 {{#if (eq type "http-basic")}}
-  if (config.basicUsername && config.basicPassword) {
+  if (config.basicUsername && config.basicPassword && schemeApplies(requirement, {{{json schemeName}}})) {
     const encoded = Buffer.from(`${config.basicUsername}:${config.basicPassword}`).toString('base64');
     headers['Authorization'] = `Basic ${encoded}`;
   }
 {{/if}}
 {{#if (eq type "oauth2")}}
   // OAuth2 — use token management with refresh
-  try {
-    const token = await getAccessToken({
-      clientId: config.oauth2ClientId ?? '',
-      clientSecret: config.oauth2ClientSecret,
-      authorizationUrl: config.oauth2AuthorizationUrl ?? '',
-      tokenUrl: config.oauth2TokenUrl ?? '',
-      scopes: [],
-      redirectUri: config.oauth2RedirectUri ?? 'http://localhost:3000/callback',
-    });
-    headers['Authorization'] = `Bearer ${token}`;
-  } catch {
-    // Fallback to pre-obtained token
-    if (config.oauth2Token) {
-      headers['Authorization'] = `Bearer ${config.oauth2Token}`;
+  if (schemeApplies(requirement, {{{json schemeName}}})) {
+    try {
+      const token = await getAccessToken({
+        clientId: config.oauth2ClientId ?? '',
+        clientSecret: config.oauth2ClientSecret,
+        authorizationUrl: config.oauth2AuthorizationUrl ?? '',
+        tokenUrl: config.oauth2TokenUrl ?? '',
+        scopes: [],
+        redirectUri: config.oauth2RedirectUri ?? 'http://localhost:3000/callback',
+      });
+      headers['Authorization'] = `Bearer ${token}`;
+    } catch {
+      // Fallback to pre-obtained token
+      if (config.oauth2Token) {
+        headers['Authorization'] = `Bearer ${config.oauth2Token}`;
+      }
     }
   }
 {{/if}}
@@ -55,3 +92,27 @@ export function getAuthHeaders(config: AppConfig): Record<string, string> {
 
   return headers;
 }
+
+/**
+ * Query-string auth parameters (apiKey-in-query schemes), keyed by query-param
+ * name. Applied by the tool handler during URL construction — a query parameter
+ * cannot be sent as a request header (D-H2). Respects the same per-operation
+ * requirement as the headers: a public operation gets none, a scheme-scoped one
+ * gets only its scheme(s).
+ */
+export function getAuthQueryParams(
+  config: AppConfig,
+  requirement?: AuthRequirement,
+): Record<string, string> {
+  const params: Record<string, string> = {};
+{{#each authSchemes}}
+{{#if (eq type "apiKey")}}
+{{#if (eq in "query")}}
+  if (config.apiKey && config.apiKeyQueryName && schemeApplies(requirement, {{{json schemeName}}})) {
+    params[config.apiKeyQueryName] = config.apiKey;
+  }
+{{/if}}
+{{/if}}
+{{/each}}
+  return params;
+}

package/dist/emitter/templates/config.ts.hbs

@@ -3,6 +3,10 @@ export interface AppConfig {
 {{#each authSchemes}}
 {{#if (eq type "apiKey")}}
   apiKey?: string;
+{{#if (eq in "query")}}
+  /** Query-parameter name the API key is appended under (apiKey-in-query auth). */
+  apiKeyQueryName?: string;
+{{/if}}
 {{/if}}
 {{#if (eq type "http-bearer")}}
   bearerToken?: string;
@@ -78,6 +82,9 @@ export function loadConfig(): AppConfig {
 {{#each authSchemes}}
 {{#if (eq type "apiKey")}}
     apiKey: process.env.{{envVarName}},
+{{#if (eq in "query")}}
+    apiKeyQueryName: {{{json headerName}}},
+{{/if}}
 {{/if}}
 {{#if (eq type "http-bearer")}}
     bearerToken: process.env.{{envVarName}},

package/dist/emitter/templates/env.example.hbs

@@ -49,4 +49,10 @@ MCP_AUTH_TOKEN=
 # — any request can hit any instance). Set to "true" for stateful per-session
 # (Mcp-Session-Id) mode if a client needs resumable streams.
 MCP_STATEFUL=
+# Stateful-session bounds (only used when MCP_STATEFUL=true). The server caps the
+# number of live sessions, evicts ones idle past MCP_SESSION_IDLE_MS, and sweeps
+# on a MCP_SESSION_REAP_MS timer so abandoned sessions can't exhaust memory.
+# MCP_MAX_SESSIONS=1000
+# MCP_SESSION_IDLE_MS=300000
+# MCP_SESSION_REAP_MS=60000
 {{/if}}

package/dist/emitter/templates/http-executor.ts.hbs

@@ -1,4 +1,4 @@
-import { getAuthHeaders } from './auth.js';
+import { getAuthHeaders, type AuthRequirement } from './auth.js';
 import { traceHeaders } from './trace.js';
 import type { AppConfig } from './config.js';
 
@@ -7,6 +7,14 @@ export interface RequestOptions {
   url: string;
   body?: unknown;
   contentType?: string;
+  /**
+   * How to serialize `body` for the upstream request:
+   *   - `json` (default): JSON.stringify, Content-Type stays as given.
+   *   - `form`: URLSearchParams (application/x-www-form-urlencoded).
+   *   - `multipart`: FormData (the runtime sets multipart Content-Type + boundary;
+   *     a per-field { __file__, content, filename } object is sent as a file part).
+   */
+  bodyEncoding?: 'json' | 'form' | 'multipart';
   headers: Record<string, string>;
   config: AppConfig;
   /**
@@ -14,6 +22,71 @@ export interface RequestOptions {
    * absent and `MCP_IDEMPOTENCY_AUTO=true`, a UUID is generated automatically.
    */
   idempotencyKey?: string;
+  /**
+   * Per-operation outbound-auth requirement (D-H2). Forwarded to getAuthHeaders
+   * so a public operation (`security: []`) sends no auth and a scheme-scoped
+   * operation sends only its scheme(s). Omitted → every configured scheme.
+   */
+  authRequirement?: AuthRequirement;
+}
+
+/**
+ * Hard per-request deadline (ms). Without it a stalled upstream keeps a tool
+ * call (and, in async-task mode, the background promise) alive indefinitely.
+ * Override with MCP_REQUEST_TIMEOUT_MS; defaults to 30s.
+ */
+const REQUEST_TIMEOUT_MS = (() => {
+  const raw = typeof process !== 'undefined' ? process.env?.MCP_REQUEST_TIMEOUT_MS : undefined;
+  const n = raw ? Number(raw) : NaN;
+  return Number.isFinite(n) && n > 0 ? n : 30_000;
+})();
+
+/**
+ * Maximum upstream response body size (bytes). A malicious or runaway upstream
+ * can otherwise exhaust memory in a single response. Override with
+ * MCP_MAX_RESPONSE_BYTES; defaults to 10 MiB.
+ */
+const MAX_RESPONSE_BYTES = (() => {
+  const raw = typeof process !== 'undefined' ? process.env?.MCP_MAX_RESPONSE_BYTES : undefined;
+  const n = raw ? Number(raw) : NaN;
+  return Number.isFinite(n) && n > 0 ? n : 10 * 1024 * 1024;
+})();
+
+/** Serialize a request body according to its declared encoding. */
+function serializeBody(
+  body: unknown,
+  encoding: 'json' | 'form' | 'multipart' | undefined,
+): { body: string | URLSearchParams | FormData; setContentType: boolean } {
+  if (encoding === 'form') {
+    const params = new URLSearchParams();
+    if (body && typeof body === 'object') {
+      for (const [k, v] of Object.entries(body as Record<string, unknown>)) {
+        if (v !== undefined && v !== null) params.append(k, String(v));
+      }
+    }
+    return { body: params, setContentType: true };
+  }
+  if (encoding === 'multipart') {
+    const form = new FormData();
+    if (body && typeof body === 'object') {
+      for (const [k, v] of Object.entries(body as Record<string, unknown>)) {
+        if (v === undefined || v === null) continue;
+        if (
+          typeof v === 'object' &&
+          '__file__' in (v as Record<string, unknown>) &&
+          'content' in (v as Record<string, unknown>)
+        ) {
+          const f = v as { content: string; filename?: string };
+          form.append(k, new Blob([f.content]), f.filename ?? k);
+        } else {
+          form.append(k, String(v));
+        }
+      }
+    }
+    // Let the runtime set multipart/form-data with the correct boundary.
+    return { body: form, setContentType: false };
+  }
+  return { body: JSON.stringify(body), setContentType: true };
 }
 
 export interface ApiResponse {
@@ -75,7 +148,7 @@ export async function executeRequest(options: RequestOptions): Promise<ApiRespon
   }
   lastRequestTime = Date.now();
 
-  const authHeaders = await getAuthHeaders(config);
+  const authHeaders = await getAuthHeaders(config, options.authRequirement);
   // Header precedence (lowest → highest): auth, runtime default headers
   // (MCP_DEFAULT_HEADERS), W3C Trace Context, then per-call headers.
   // Propagate W3C Trace Context to the upstream API (no-op outside an HTTP
@@ -88,8 +161,15 @@ export async function executeRequest(options: RequestOptions): Promise<ApiRespon
     ...options.headers,
   };
 
-  if (options.body && options.contentType) {
-    headers['Content-Type'] = options.contentType;
+  // Serialize the body for its declared encoding. FormData must NOT carry a
+  // manual Content-Type — the runtime appends the multipart boundary itself.
+  let serializedBody: string | URLSearchParams | FormData | undefined;
+  if (options.body !== undefined && options.body !== null) {
+    const { body, setContentType } = serializeBody(options.body, options.bodyEncoding);
+    serializedBody = body;
+    if (setContentType && options.contentType) {
+      headers['Content-Type'] = options.contentType;
+    }
   }
 
   // Idempotency-Key for mutating requests (explicit per-call, or auto when enabled).
@@ -101,11 +181,16 @@ export async function executeRequest(options: RequestOptions): Promise<ApiRespon
   let lastError: Error | undefined;
 
   for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    // Per-attempt hard deadline. AbortError is not retryable — a timed-out
+    // upstream should fail fast rather than multiply the wait by the retry count.
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
     try {
       const response = await fetch(options.url, {
         method,
         headers,
-        body: options.body ? JSON.stringify(options.body) : undefined,
+        body: serializedBody,
+        signal: controller.signal,
       });
 
       if (RETRYABLE_STATUS_CODES.includes(response.status) && attempt < config.maxRetries) {
@@ -134,24 +219,82 @@ export async function executeRequest(options: RequestOptions): Promise<ApiRespon
       };
     } catch (error) {
       lastError = error as Error;
+      // A request that hit the hard deadline is cancelled, not retried.
+      const isAbort =
+        error instanceof Error && (error.name === 'AbortError' || error.name === 'TimeoutError');
+      if (isAbort) {
+        throw new Error(`Request timed out after ${REQUEST_TIMEOUT_MS}ms`);
+      }
       if (error instanceof ApiError && !RETRYABLE_STATUS_CODES.includes(error.status)) {
         throw error;
       }
       if (attempt < config.maxRetries) {
         await sleep(1000 * Math.pow(2, attempt));
       }
+    } finally {
+      clearTimeout(timer);
     }
   }
 
   throw lastError ?? new Error('Request failed after retries');
 }
 
+/**
+ * Read a response body with a hard byte cap. Streaming the body lets us abort as
+ * soon as the cap is exceeded instead of buffering an unbounded (or dishonest
+ * Content-Length) payload into memory.
+ */
+async function readBounded(response: Response): Promise<string> {
+  const declared = Number(response.headers.get('content-length'));
+  if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES) {
+    throw new Error(`Response too large (${declared} bytes > ${MAX_RESPONSE_BYTES} cap)`);
+  }
+  if (!response.body) {
+    return response.text();
+  }
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) {
+        total += value.byteLength;
+        if (total > MAX_RESPONSE_BYTES) {
+          await reader.cancel();
+          throw new Error(`Response exceeded ${MAX_RESPONSE_BYTES}-byte cap (truncated)`);
+        }
+        chunks.push(value);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder().decode(concatChunks(chunks, total));
+}
+
+function concatChunks(chunks: Uint8Array[], total: number): Uint8Array {
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+
 async function parseResponseBody(response: Response): Promise<unknown> {
   const contentType = response.headers.get('content-type') ?? '';
+  const text = await readBounded(response);
   if (contentType.includes('application/json')) {
-    return response.json();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
   }
-  return response.text();
+  return text;
 }
 
 function sleep(ms: number): Promise<void> {

package/dist/emitter/templates/server-main-http.ts.hbs

@@ -174,8 +174,50 @@ if (transportMode === 'http') {
   /* Stateful mode keeps one McpServer + transport PER SESSION, keyed by the
    * Mcp-Session-Id the SDK assigns on `initialize`, so concurrent clients get
    * independent, isolated sessions (a single shared transport cannot multiplex
-   * them). Stateless mode builds a fresh server + transport per request. */
-  const sessions = new Map<string, { server: McpServer; transport: StreamableHTTPServerTransport }>();
+   * them). Stateless mode builds a fresh server + transport per request.
+   *
+   * Sessions are bounded: a client that abandons a session without sending the
+   * SDK's close (so `transport.onclose` never fires) would otherwise retain its
+   * server/transport graph forever. We cap the live count, stamp a last-access
+   * time on every request, evict idle sessions on access and via a periodic
+   * reaper, and reject new sessions once at capacity. The limits are overridable
+   * via env so an operator can tune them without editing the generated source. */
+  interface Session {
+    server: McpServer;
+    transport: StreamableHTTPServerTransport;
+    lastAccess: number;
+  }
+  const sessions = new Map<string, Session>();
+
+  function envInt(name: string, fallback: number): number {
+    const n = parseInt(process.env[name] ?? '', 10);
+    return Number.isInteger(n) && n > 0 ? n : fallback;
+  }
+  const MAX_SESSIONS = envInt('MCP_MAX_SESSIONS', 1000);
+  const SESSION_IDLE_MS = envInt('MCP_SESSION_IDLE_MS', 5 * 60 * 1000);
+  const SESSION_REAP_MS = envInt('MCP_SESSION_REAP_MS', 60 * 1000);
+
+  /* Close + drop a single session (best-effort; never throws). */
+  function destroySession(sid: string, session: Session): void {
+    sessions.delete(sid);
+    void session.transport.close().catch(() => {});
+    void session.server.close().catch(() => {});
+  }
+
+  /* Evict every session whose last access is older than the idle window. */
+  function evictIdleSessions(now: number): void {
+    for (const [sid, session] of sessions) {
+      if (now - session.lastAccess > SESSION_IDLE_MS) {
+        log('info', 'Evicting idle session', { sid });
+        destroySession(sid, session);
+      }
+    }
+  }
+
+  /* Periodic reaper — sweeps idle sessions even when no traffic arrives.
+   * `unref()` so it never keeps the process alive on its own. */
+  const reaper = setInterval(() => evictIdleSessions(Date.now()), SESSION_REAP_MS);
+  reaper.unref();
 
   function isInitializeRequest(body: unknown): boolean {
     return (
@@ -200,26 +242,39 @@ if (transportMode === 'http') {
     );
     await runWithTrace(trace, async () => {
       if (stateful) {
+        const now = Date.now();
+        // Sweep idle sessions on every access so an idle map is reclaimed even
+        // between reaper ticks (and before a capacity check can spuriously fail).
+        evictIdleSessions(now);
         const sessionId = headerValue(req.headers['mcp-session-id']);
         const existing = sessionId ? sessions.get(sessionId) : undefined;
         if (existing) {
+          existing.lastAccess = now;
           await existing.transport.handleRequest(req, res, parsedBody);
           return;
         }
         if (!sessionId && isInitializeRequest(parsedBody)) {
+          // Reject new sessions once at capacity rather than growing unbounded.
+          if (sessions.size >= MAX_SESSIONS) {
+            log('error', 'Session capacity reached, rejecting initialize', {
+              maxSessions: MAX_SESSIONS,
+            });
+            rpcError(res, null, -32000, 'Server at session capacity — retry later');
+            return;
+          }
           // New session: create a dedicated server + transport and register it
           // under the session id the SDK generates during initialize.
           const server = createMcpServer(config);
           const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => crypto.randomUUID(),
             onsessioninitialized: (sid: string) => {
-              sessions.set(sid, { server, transport });
+              sessions.set(sid, { server, transport, lastAccess: Date.now() });
             },
           });
           transport.onclose = () => {
             const sid = transport.sessionId;
             if (sid) sessions.delete(sid);
-            void server.close();
+            void server.close().catch(() => {});
           };
           await server.connect(transport);
           await transport.handleRequest(req, res, parsedBody);
@@ -412,6 +467,7 @@ if (transportMode === 'http') {
   process.on('SIGTERM', () => {
     log('info', 'SIGTERM received, shutting down');
     isReady = false;
+    clearInterval(reaper);
 
     httpServer.close(async () => {
       try {

package/dist/emitter/templates/tool-handler.ts.hbs

@@ -3,6 +3,9 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { executeRequest } from '../http.js';
 import { applyJqFilter } from '../response-filter.js';
 import type { AppConfig } from '../config.js';
+{{#if hasQueryApiKey}}
+import { getAuthQueryParams } from '../auth.js';
+{{/if}}
 {{#if isAsync}}
 import { createTask, updateTask } from '../task-manager.js';
 {{/if}}
@@ -36,18 +39,30 @@ const outputSchema = {{{outputSchemaCode}}};
 async function runRequest(rawInput: Record<string, unknown>, config: AppConfig): Promise<unknown> {
   // Pull off the per-call control args so they are never forwarded upstream.
   const { jq_filter: jqFilter, idempotency_key: idempotencyKey, ...input } = rawInput;
+{{#if hasQueryApiKey}}
+  let url = buildUrl(input, config.baseUrl);
+  // apiKey-in-query auth: append the key as a query parameter (it cannot be sent
+  // as a header). Respects the per-operation security requirement (D-H2).
+  url = appendQueryParams(url, getAuthQueryParams(config, {{#if authRequirement}}{{{json authRequirement}}}{{else}}undefined{{/if}}));
+{{else}}
   const url = buildUrl(input, config.baseUrl);
+{{/if}}
 
   const response = await executeRequest({
     method: '{{method}}',
     url,
 {{#if hasRequestBody}}
-    body: input.body,
+    body: input.{{bodyInputKey}},
     contentType: '{{requestBodyContentType}}',
+    bodyEncoding: '{{bodyEncoding}}',
 {{/if}}
-    headers: {},
+    headers: buildHeaders(input),
     config,
     idempotencyKey: typeof idempotencyKey === 'string' ? idempotencyKey : undefined,
+{{#if authRequirement}}
+    // Per-operation outbound-auth requirement derived from OpenAPI `security` (D-H2).
+    authRequirement: {{{json authRequirement}}},
+{{/if}}
   });
 
   let result: unknown = response.data;
@@ -140,3 +155,23 @@ function buildUrl(
 ): string {
 {{{buildUrlBody}}}
 }
+
+// Build the upstream header/cookie set from the tool input. Header and cookie
+// parameters are sent under their original API names (see paramMappings).
+function buildHeaders(params: Record<string, unknown>): Record<string, string> {
+{{{buildHeadersBody}}}
+}
+{{#if hasQueryApiKey}}
+
+// Append extra query parameters (apiKey-in-query auth) onto an already-built URL,
+// preserving any existing query string and URL-encoding name and value.
+function appendQueryParams(url: string, extra: Record<string, string>): string {
+  const keys = Object.keys(extra);
+  if (keys.length === 0) return url;
+  const sep = url.includes('?') ? '&' : '?';
+  const qs = keys
+    .map((k) => encodeURIComponent(k) + '=' + encodeURIComponent(extra[k]))
+    .join('&');
+  return url + sep + qs;
+}
+{{/if}}

package/dist/emitter/templates/tool-test.ts.hbs

@@ -25,7 +25,15 @@ function capture(): { name: string; def: Record<string, unknown>; handler: unkno
 }
 
 describe('{{name}}', () => {
-  // Tool: {{name}} — {{method}} {{pathTemplate}}
+  // Source operation metadata. Serialized via JSON.stringify on the builder side
+  // so an untrusted OpenAPI path (which can contain newlines/quotes) can never
+  // escape a comment or string literal into module-level code.
+  const operation = {{{operationMeta}}};
+
+  it('targets the source operation', () => {
+    expect(operation.method).toBe('{{method}}');
+    expect(typeof operation.path).toBe('string');
+  });
 
   it('registers exactly one tool under its name', () => {
     const calls = capture();

package/dist/emitter/worker-templates/config.ts.hbs

@@ -8,6 +8,10 @@ export interface AppConfig {
 {{#each authSchemes}}
 {{#if (eq type "apiKey")}}
   apiKey?: string;
+{{#if (eq in "query")}}
+  /** Query-parameter name the API key is appended under (apiKey-in-query auth). */
+  apiKeyQueryName?: string;
+{{/if}}
 {{/if}}
 {{#if (eq type "http-bearer")}}
   bearerToken?: string;
@@ -69,6 +73,9 @@ export function loadConfig(env: EnvLike): AppConfig {
 {{#each authSchemes}}
 {{#if (eq type "apiKey")}}
     apiKey: env.{{envVarName}},
+{{#if (eq in "query")}}
+    apiKeyQueryName: {{{json headerName}}},
+{{/if}}
 {{/if}}
 {{#if (eq type "http-bearer")}}
     bearerToken: env.{{envVarName}},

package/dist/emitter/worker-templates/tool-handler.ts.hbs

@@ -2,6 +2,9 @@ import { z } from 'zod';
 import { executeRequest } from '../http.js';
 import { applyJqFilter } from '../response-filter.js';
 import type { AppConfig } from '../config.js';
+{{#if hasQueryApiKey}}
+import { getAuthQueryParams } from '../auth.js';
+{{/if}}
 
 // Per-call control arguments shared by every generated tool. Optional and
 // stripped before the upstream request, so omitting them is a no-op.
@@ -70,18 +73,30 @@ export async function handler(
 async function runRequest(rawInput: Record<string, unknown>, config: AppConfig): Promise<unknown> {
   // Pull off the per-call control args so they are never forwarded upstream.
   const { jq_filter: jqFilter, idempotency_key: idempotencyKey, ...input } = rawInput;
+{{#if hasQueryApiKey}}
+  let url = buildUrl(input, config.baseUrl);
+  // apiKey-in-query auth: append the key as a query parameter (it cannot be sent
+  // as a header). Respects the per-operation security requirement (D-H2).
+  url = appendQueryParams(url, getAuthQueryParams(config, {{#if authRequirement}}{{{json authRequirement}}}{{else}}undefined{{/if}}));
+{{else}}
   const url = buildUrl(input, config.baseUrl);
+{{/if}}
 
   const response = await executeRequest({
     method: '{{method}}',
     url,
 {{#if hasRequestBody}}
-    body: input.body,
+    body: input.{{bodyInputKey}},
     contentType: '{{requestBodyContentType}}',
+    bodyEncoding: '{{bodyEncoding}}',
 {{/if}}
-    headers: {},
+    headers: buildHeaders(input),
     config,
     idempotencyKey: typeof idempotencyKey === 'string' ? idempotencyKey : undefined,
+{{#if authRequirement}}
+    // Per-operation outbound-auth requirement derived from OpenAPI `security` (D-H2).
+    authRequirement: {{{json authRequirement}}},
+{{/if}}
   });
 
   let result: unknown = response.data;
@@ -101,3 +116,23 @@ async function runRequest(rawInput: Record<string, unknown>, config: AppConfig):
 function buildUrl(params: Record<string, unknown>, baseUrl: string): string {
 {{{buildUrlBody}}}
 }
+
+// Build the upstream header/cookie set from the tool input. Header and cookie
+// parameters are sent under their original API names (see paramMappings).
+function buildHeaders(params: Record<string, unknown>): Record<string, string> {
+{{{buildHeadersBody}}}
+}
+{{#if hasQueryApiKey}}
+
+// Append extra query parameters (apiKey-in-query auth) onto an already-built URL,
+// preserving any existing query string and URL-encoding name and value.
+function appendQueryParams(url: string, extra: Record<string, string>): string {
+  const keys = Object.keys(extra);
+  if (keys.length === 0) return url;
+  const sep = url.includes('?') ? '&' : '?';
+  const qs = keys
+    .map((k) => encodeURIComponent(k) + '=' + encodeURIComponent(extra[k]))
+    .join('&');
+  return url + sep + qs;
+}
+{{/if}}