@velum-labs/routekit-gateway 1.4.0 → 1.5.0

package/dist/acp/registry.js

@@ -10,7 +10,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { executeWebRequest, RouteKitFailure, routeKitError, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { Effect } from "effect";
-import { gatewayTry } from "../effect/gateway.js";
+import { gatewayTry } from "@velum-labs/routekit-provider-core";
 export const ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
 function normalizeRegistry(raw) {
     if (typeof raw !== "object" || raw === null) {

package/dist/adapters/anthropic-codec.d.ts

@@ -4,7 +4,7 @@
  * Streaming translation lives in `anthropic-stream.ts`; HTTP handling lives
  * in `anthropic.ts`.
  */
-import type { OpenAiChatResponse } from "../providers/protocol.js";
+import type { OpenAiChatResponse } from "@velum-labs/routekit-provider-core";
 import type { AnthropicRequest } from "./anthropic-wire.js";
 import type { ExecutedSearch, ServerToolLoopEvent } from "./server-tool-loop.js";
 export type { AnthropicRequest } from "./anthropic-wire.js";

package/dist/adapters/anthropic-codec.js

@@ -5,9 +5,9 @@
  * in `anthropic.ts`.
  */
 import { estimateTokens, randomId } from "@velum-labs/routekit-runtime/timing";
-import { decodeToolResult } from "../providers/protocol.js";
-import { droppedField } from "./dropped.js";
-import { anthropicReasoningDetailsOf, anthropicReasoningExtension, attachAnthropicMessageContent, attachAnthropicRequestMetadata, attachReasoningSelection, attachReasoningSelectionError, reasoningIndex } from "./openai-chat-wire.js";
+import { decodeToolResult } from "@velum-labs/routekit-provider-core";
+import { droppedField } from "@velum-labs/routekit-provider-core";
+import { anthropicReasoningDetailsOf, anthropicReasoningExtension, attachAnthropicMessageContent, attachAnthropicRequestMetadata, attachReasoningSelection, attachReasoningSelectionError, reasoningIndex } from "@velum-labs/routekit-provider-core";
 /**
  * Whether an Anthropic tool is *server-executed* (run by Anthropic's backend,
  * e.g. `web_search_20250305` / `code_execution_*`). Nothing behind this gateway
@@ -329,9 +329,20 @@ export function anthropicToChat(body, backendModel, options = {}) {
             });
         }
     }
+    // Claude Code can retain its global effort preference when the process
+    // disables thinking. Disabled thinking wins; forwarding the stale effort
+    // would make the canonical request metadata contradictory.
+    const outputConfig = body.thinking?.type === "disabled" && body.output_config != null
+        ? Object.fromEntries(Object.entries(body.output_config).filter(([key]) => key !== "effort"))
+        : body.output_config;
     const metadata = {
+        ...(body.service_tier !== undefined ? { service_tier: body.service_tier } : {}),
+        ...(body.speed !== undefined ? { speed: body.speed } : {}),
         ...(body.thinking != null ? { thinking: body.thinking } : {}),
-        ...(body.output_config !== undefined ? { output_config: body.output_config } : {})
+        ...(outputConfig !== undefined &&
+            (outputConfig === null || Object.keys(outputConfig).length > 0)
+            ? { output_config: outputConfig }
+            : {})
     };
     if (Object.keys(metadata).length > 0) {
         attachAnthropicRequestMetadata(chat, metadata);

package/dist/adapters/anthropic-stream.js

@@ -4,10 +4,10 @@
  */
 import { randomId } from "@velum-labs/routekit-runtime/timing";
 import { StreamPump } from "@velum-labs/routekit-runtime/sse";
-import { decodeOpenAiChatSseEvent } from "../providers/protocol.js";
-import { SseParseError } from "../sse/parse.js";
+import { decodeOpenAiChatSseEvent } from "@velum-labs/routekit-provider-core";
+import { SseParseError } from "@velum-labs/routekit-provider-core";
 import { mapStopReason } from "./anthropic-codec.js";
-import { anthropicReasoningDetailsOf, anthropicReasoningExtension } from "./openai-chat-wire.js";
+import { anthropicReasoningDetailsOf, anthropicReasoningExtension } from "@velum-labs/routekit-provider-core";
 import { serverToolMarkerOf } from "./server-tool-loop.js";
 import { unwrapUpstreamError } from "./upstream-error.js";
 const ENCODER = new TextEncoder();
@@ -37,7 +37,9 @@ export function openAiSseToAnthropic(upstream, model) {
         nextIndex: 0,
         finished: false,
         inputTokens: undefined,
-        outputTokens: undefined
+        outputTokens: undefined,
+        stopReason: undefined,
+        stopSequence: null
     };
     const ensureStarted = (controller) => {
         if (state.started)
@@ -292,7 +294,7 @@ export function openAiSseToAnthropic(upstream, model) {
             return;
         }
         const choice = chunk.choices?.[0];
-        if (choice === undefined) {
+        if (choice === undefined || state.stopReason !== undefined) {
             if (chunk.usage?.inputTokens !== undefined)
                 state.inputTokens = chunk.usage.inputTokens;
             if (chunk.usage?.outputTokens !== undefined)
@@ -387,18 +389,28 @@ export function openAiSseToAnthropic(upstream, model) {
         if (chunk.usage?.outputTokens !== undefined)
             state.outputTokens = chunk.usage.outputTokens;
         if (choice.finish_reason !== null && choice.finish_reason !== undefined) {
-            finalize(controller, typeof choice.anthropic_stop_reason === "string"
-                ? choice.anthropic_stop_reason
-                : mapStopReason(choice.finish_reason), typeof choice.anthropic_stop_sequence === "string" ? choice.anthropic_stop_sequence : null);
+            // OpenAI sends the usage-only chunk *after* the finish_reason when
+            // stream_options.include_usage is enabled. Defer the terminal Anthropic
+            // event so both the client and call accounting receive those counters.
+            state.stopReason =
+                typeof choice.anthropic_stop_reason === "string"
+                    ? choice.anthropic_stop_reason
+                    : mapStopReason(choice.finish_reason);
+            state.stopSequence =
+                typeof choice.anthropic_stop_sequence === "string" ? choice.anthropic_stop_sequence : null;
         }
     };
     const handleEvent = (controller, data) => {
-        if (data.length === 0)
+        if (data.length === 0 || state.finished)
             return;
         if (data === "[DONE]") {
-            // A `[DONE]` without a prior finish_reason is truncation, not a clean stop.
-            if (!state.finished)
+            if (state.stopReason === undefined) {
+                // A `[DONE]` without a prior finish_reason is truncation, not a clean stop.
                 finalizeTruncated(controller, "upstream sent [DONE] before a finish reason");
+            }
+            else {
+                finalize(controller, state.stopReason, state.stopSequence);
+            }
             return;
         }
         let chunk;
@@ -437,7 +449,12 @@ export function openAiSseToAnthropic(upstream, model) {
         },
         onEnd(controller) {
             if (!state.finished) {
-                finalizeTruncated(controller, "upstream stream ended before a finish reason");
+                if (state.stopReason === undefined) {
+                    finalizeTruncated(controller, "upstream stream ended before a finish reason");
+                }
+                else {
+                    finalize(controller, state.stopReason, state.stopSequence);
+                }
             }
         }
     });

package/dist/adapters/anthropic-wire.d.ts

@@ -3,7 +3,7 @@
  * clients send to `/v1/messages`. Translation lives in `anthropic-codec.ts`;
  * HTTP handling lives in `anthropic.ts`.
  */
-import type { AnthropicThinkingConfig } from "./openai-chat-wire.js";
+import type { AnthropicThinkingConfig } from "@velum-labs/routekit-provider-core";
 export type AnthropicTextBlock = {
     type: "text";
     text: string;
@@ -54,6 +54,10 @@ export type AnthropicRequest = {
     temperature?: number;
     top_p?: number;
     top_k?: number;
+    /** Anthropic capacity routing (`auto` or `standard_only`), not fast mode. */
+    service_tier?: string | null;
+    /** Anthropic fast-mode selector (`fast`); omitted means normal mode. */
+    speed?: string | null;
     thinking?: AnthropicThinking | null;
     output_config?: AnthropicOutputConfig | null;
     metadata?: Record<string, unknown> | null;

package/dist/adapters/anthropic.d.ts

@@ -12,7 +12,7 @@
  * - `anthropic-models.ts` — Claude picker and `/v1/models`
  * - this module — HTTP handlers that wire the codec to a `Backend`
  */
-import type { Backend, BackendRequest, BackendRequestOptions } from "../providers/backend.js";
+import type { Backend, BackendRequest, BackendRequestOptions } from "@velum-labs/routekit-provider-core";
 import type { AnthropicRequest } from "./anthropic-wire.js";
 export type { AnthropicTranslationOptions } from "./anthropic-codec.js";
 export { anthropicToChat, chatToAnthropicMessage, countTokensEstimate, mapStopReason } from "./anthropic-codec.js";

package/dist/adapters/anthropic.js

@@ -12,10 +12,9 @@
  * - `anthropic-models.ts` — Claude picker and `/v1/models`
  * - this module — HTTP handlers that wire the codec to a `Backend`
  */
+import { decodeOpenAiChatResponse, gatewayTry, gatewayTryPromise, jsonResponse } from "@velum-labs/routekit-provider-core";
+import { requireHttpSubmissionSupport } from "@velum-labs/routekit-runtime/effect";
 import { Effect } from "effect";
-import { gatewayTry, gatewayTryPromise } from "../effect/gateway.js";
-import { jsonResponse } from "../http/response.js";
-import { decodeOpenAiChatResponse } from "../providers/protocol.js";
 import { anthropicToChat, chatToAnthropicMessage, countTokensEstimate, isAnthropicServerTool, isAnthropicWebSearchTool, thinkingValidationError, WEB_SEARCH_TOOL_NAME } from "./anthropic-codec.js";
 import { openAiSseToAnthropic } from "./anthropic-stream.js";
 import { composeServerToolStream, runBufferedServerToolLoop } from "./server-tool-loop.js";
@@ -63,6 +62,9 @@ export function handleAnthropicMessages(backend, body, modelCallId, signal, back
         const declaresWebSearch = body.tools?.some(isAnthropicWebSearchTool) === true;
         const clientNameCollision = body.tools?.some((tool) => !isAnthropicServerTool(tool) && tool.name === WEB_SEARCH_TOOL_NAME) === true;
         const executor = declaresWebSearch && !clientNameCollision ? resolveWebSearchExecutor("anthropic") : undefined;
+        // Native provider support does not certify the server-tool loop's
+        // additional provider POSTs or its detached streaming runner.
+        yield* requireHttpSubmissionSupport(executor === undefined);
         const serverTools = executor !== undefined;
         const chat = anthropicToChat(body, upstreamModel, { serverTools });
         const requestOptions = {

package/dist/adapters/cursor.js

@@ -15,8 +15,8 @@
  * boundary stays defensive without 4xx-ing on new shapes.
  */
 import { cursorModelName, EFFORT_QUALIFIED_MODEL_CODEC, enumerateModelEffortVariants, resolveModelEffortVariant, stripCursorNamespace } from "@velum-labs/routekit-contracts";
-import { droppedField } from "./dropped.js";
-import { attachReasoningSelection, attachReasoningSelectionError, hasExplicitReasoningSelection, reasoningSelectionErrorOf, reasoningSelectionOf } from "./openai-chat-wire.js";
+import { droppedField } from "@velum-labs/routekit-provider-core";
+import { attachReasoningSelection, attachReasoningSelectionError, hasExplicitReasoningSelection, reasoningSelectionErrorOf, reasoningSelectionOf } from "@velum-labs/routekit-provider-core";
 /** Fields copied through unchanged when present and non-null. */
 const PASSTHROUGH_FIELDS = [
     "model",

package/dist/adapters/responses-codec.d.ts

@@ -4,7 +4,7 @@
  * translation lives in `responses-stream.ts`; HTTP handling lives in
  * `responses.ts`.
  */
-import type { OpenAiChatResponse } from "../providers/protocol.js";
+import type { OpenAiChatResponse } from "@velum-labs/routekit-provider-core";
 import type { ResponsesRequest, ResponsesTool } from "./responses-wire.js";
 import type { ExecutedSearch } from "./server-tool-loop.js";
 export type { ResponsesInputItem, ResponsesRequest } from "./responses-wire.js";
@@ -62,4 +62,15 @@ export type ResponsesTranslationOptions = {
 export declare function responsesToolRegistry(body: ResponsesRequest, options?: ResponsesTranslationOptions): ResponsesToolRegistry;
 /** Translate a Responses request to an OpenAI Chat Completions body. */
 export declare function responsesToChat(body: ResponsesRequest, backendModel: string | undefined, options?: ResponsesTranslationOptions): Record<string, unknown>;
+/** The native item for a typed tool call (e.g. name "tool_search" ->
+ *  `tool_search_call`). Codex dispatches typed tools by payload shape; a
+ *  `function_call` under the same name fails with "unsupported payload". */
+export declare function typedToolCallItem(input: {
+    name: string;
+    itemId: string;
+    callId: string;
+    args: string;
+}): Record<string, unknown>;
+/** The `query` from a web_search call's JSON arguments (raw args as fallback). */
+export declare function webSearchQueryOf(args: string): string;
 export declare function chatToResponses(openai: OpenAiResponse, model: string, toolRegistry?: ResponsesToolRegistry, searches?: readonly ExecutedSearch[]): Record<string, unknown>;

package/dist/adapters/responses-codec.js

@@ -5,8 +5,8 @@
  * `responses.ts`.
  */
 import { randomId } from "@velum-labs/routekit-runtime/timing";
-import { droppedField } from "./dropped.js";
-import { attachReasoningSelection, attachReasoningSelectionError, attachResponsesReasoningMetadata, hasExplicitReasoningSelection, reasoningSelectionErrorOf, reasoningSelectionOf, responsesReasoningItem, responsesReasoningMetadataOf } from "./openai-chat-wire.js";
+import { droppedField } from "@velum-labs/routekit-provider-core";
+import { attachReasoningSelection, attachReasoningSelectionError, attachResponsesReasoningMetadata, hasExplicitReasoningSelection, reasoningSelectionErrorOf, reasoningSelectionOf, responsesReasoningItem, responsesReasoningMetadataOf } from "@velum-labs/routekit-provider-core";
 import { chatUsageToResponses } from "./responses-usage.js";
 export class ResponsesTranslationError extends Error {
     code = "invalid_encrypted_reasoning_order";
@@ -53,11 +53,33 @@ function contentToText(content) {
         return content;
     return content.map(partText).join("");
 }
-function contentToParts(content) {
+function contentToParts(content, destinationWireShape) {
     if (typeof content === "string")
         return content;
     const parts = [];
     for (const part of content) {
+        if (destinationWireShape === "openai-responses") {
+            // The Codex Chat bridge validates content before transport. Do not
+            // erase unsupported modalities before that codec can reject them.
+            if (part?.type === "input_image") {
+                parts.push({
+                    type: "image_url",
+                    image_url: {
+                        url: part.image_url,
+                        ...(part.detail !== undefined ? { detail: part.detail } : {})
+                    }
+                });
+            }
+            else if (part?.type === "input_text" ||
+                part?.type === "output_text" ||
+                part?.type === "text") {
+                parts.push({ type: "text", text: part.text });
+            }
+            else {
+                parts.push(part);
+            }
+            continue;
+        }
         if (part.type === "input_image" && typeof part.image_url === "string") {
             parts.push({ type: "image_url", image_url: { url: part.image_url } });
         }
@@ -70,8 +92,8 @@ function contentToParts(content) {
                 parts.push({ type: "text", text });
         }
     }
-    if (parts.length === 1 && parts[0]?.type === "text") {
-        return String(parts[0].text);
+    if (parts.length === 1 && parts[0]?.type === "text" && typeof parts[0].text === "string") {
+        return parts[0].text;
     }
     return parts;
 }
@@ -400,7 +422,11 @@ export function responsesToChat(body, backendModel, options = {}) {
                 if (pendingEncryptedReasoning.length > 0)
                     rejectPendingReasoning(item.type);
                 const out = item;
-                const content = typeof out.output === "string" ? out.output : JSON.stringify(out.output);
+                const content = options.destinationWireShape === "openai-responses" && Array.isArray(out.output)
+                    ? contentToParts(out.output, options.destinationWireShape)
+                    : typeof out.output === "string"
+                        ? out.output
+                        : JSON.stringify(out.output);
                 messages.push({ role: "tool", tool_call_id: out.call_id, content });
                 continue;
             }
@@ -430,7 +456,7 @@ export function responsesToChat(body, backendModel, options = {}) {
             }
             const chatMessage = {
                 role,
-                content: contentToParts(message.content)
+                content: contentToParts(message.content, options.destinationWireShape)
             };
             if (role === "assistant")
                 attachPendingReasoning(chatMessage);
@@ -455,6 +481,8 @@ export function responsesToChat(body, backendModel, options = {}) {
         chat.top_p = body.top_p;
     if (typeof body.parallel_tool_calls === "boolean")
         chat.parallel_tool_calls = body.parallel_tool_calls;
+    if (typeof body.service_tier === "string")
+        chat.service_tier = body.service_tier;
     if (body.x_routekit !== undefined)
         chat.x_routekit = body.x_routekit;
     const originalSelectionError = reasoningSelectionErrorOf(body);
@@ -627,7 +655,7 @@ function typedToolArguments(args) {
 /** The native item for a typed tool call (e.g. name "tool_search" ->
  *  `tool_search_call`). Codex dispatches typed tools by payload shape; a
  *  `function_call` under the same name fails with "unsupported payload". */
-function typedToolCallItem(input) {
+export function typedToolCallItem(input) {
     return {
         type: `${input.name}_call`,
         id: input.itemId,
@@ -638,7 +666,7 @@ function typedToolCallItem(input) {
     };
 }
 /** The `query` from a web_search call's JSON arguments (raw args as fallback). */
-function webSearchQueryOf(args) {
+export function webSearchQueryOf(args) {
     try {
         const parsed = JSON.parse(args);
         if (typeof parsed.query === "string")

package/dist/adapters/responses-stream.d.ts

@@ -1,2 +1,2 @@
-import type { ResponsesToolRegistry } from "./responses-codec.js";
+import { type ResponsesToolRegistry } from "./responses-codec.js";
 export declare function openAiSseToResponses(upstream: ReadableStream<Uint8Array>, model: string, toolRegistry?: ResponsesToolRegistry): ReadableStream<Uint8Array>;

package/dist/adapters/responses-stream.js

@@ -1,32 +1,13 @@
 import { extensionValue } from "@velum-labs/routekit-contracts/protocol-ir";
 import { randomId } from "@velum-labs/routekit-runtime/timing";
 import { StreamPump } from "@velum-labs/routekit-runtime/sse";
-import { decodeOpenAiChatSseEvent } from "../providers/protocol.js";
-import { SseParseError } from "../sse/parse.js";
-import { responsesReasoningItem, responsesReasoningMetadataOf } from "./openai-chat-wire.js";
+import { decodeOpenAiChatSseEvent } from "@velum-labs/routekit-provider-core";
+import { SseParseError } from "@velum-labs/routekit-provider-core";
+import { responsesReasoningItem, responsesReasoningMetadataOf } from "@velum-labs/routekit-provider-core";
+import { typedToolCallItem, webSearchQueryOf } from "./responses-codec.js";
 import { chatUsageToResponses } from "./responses-usage.js";
 import { serverToolMarkerOf } from "./server-tool-loop.js";
 const ENCODER = new TextEncoder();
-function typedToolArguments(args) {
-    if (args.trim().length === 0)
-        return {};
-    try {
-        return JSON.parse(args);
-    }
-    catch {
-        return {};
-    }
-}
-function typedToolCallItem(input) {
-    return {
-        type: `${input.name}_call`,
-        id: input.itemId,
-        call_id: input.callId,
-        status: "completed",
-        execution: "client",
-        arguments: typedToolArguments(input.args)
-    };
-}
 function customToolInput(args) {
     if (args.trim().length === 0)
         return "";
@@ -86,18 +67,6 @@ function streamedToolItem(tool) {
         }
     }
 }
-/** The `query` from a web_search call's JSON arguments (raw args as fallback). */
-function webSearchQueryOf(args) {
-    try {
-        const parsed = JSON.parse(args);
-        if (typeof parsed.query === "string")
-            return parsed.query;
-    }
-    catch {
-        // fall through to the raw argument string
-    }
-    return args;
-}
 export function openAiSseToResponses(upstream, model, toolRegistry = new Map()) {
     const responseId = `resp_${randomId()}`;
     const messageItemId = `msg_${randomId()}`;

package/dist/adapters/responses-wire.d.ts

@@ -3,7 +3,7 @@
  * send to `/v1/responses`. Translation lives in `responses-codec.ts`; HTTP
  * handling lives in `responses.ts`.
  */
-import type { RouteKitReasoningEnvelope } from "./openai-chat-wire.js";
+import type { RouteKitReasoningEnvelope } from "@velum-labs/routekit-provider-core";
 export type ResponsesContentPart = {
     type: string;
     text?: string;
@@ -83,6 +83,7 @@ export type ResponsesRequest = {
     temperature?: number;
     top_p?: number;
     parallel_tool_calls?: boolean;
+    service_tier?: string | null;
     /**
      * Codex serializes `reasoning: null` (not an absent key) for models whose
      * catalog metadata carries no reasoning level — every custom provider

package/dist/adapters/responses.d.ts

@@ -12,7 +12,7 @@
  * - `responses-usage.ts` — usage mapping
  * - this module — HTTP handlers that wire the codec to a `Backend`
  */
-import type { Backend, BackendRequest, BackendRequestOptions } from "../providers/backend.js";
+import type { Backend, BackendRequest, BackendRequestOptions } from "@velum-labs/routekit-provider-core";
 import type { ResponsesRequest } from "./responses-wire.js";
 export type { ResponsesToolEntry, ResponsesToolKind, ResponsesToolRegistry, ResponsesTranslationOptions } from "./responses-codec.js";
 export { chatToResponses, responsesToChat, responsesToolRegistry, WEB_SEARCH_TOOL_NAME } from "./responses-codec.js";

package/dist/adapters/responses.js

@@ -12,14 +12,9 @@
  * - `responses-usage.ts` — usage mapping
  * - this module — HTTP handlers that wire the codec to a `Backend`
  */
-import { toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
+import { decodeOpenAiChatResponse, droppedField, finalizeResponsesResponse, gatewayTry, gatewayTryPromise, jsonResponse, prepareResponsesReasoningInput, reasoningSelectionOf, routeKitRequestValidationErrorOf } from "@velum-labs/routekit-provider-core";
+import { requireHttpSubmissionSupport, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { Effect } from "effect";
-import { gatewayTry, gatewayTryPromise } from "../effect/gateway.js";
-import { jsonResponse } from "../http/response.js";
-import { decodeOpenAiChatResponse } from "../providers/protocol.js";
-import { droppedField } from "./dropped.js";
-import { reasoningSelectionOf, routeKitRequestValidationErrorOf } from "./openai-chat-wire.js";
-import { prepareResponsesReasoningInput, wrapResponsesReasoningResponse } from "./openai-responses-wire.js";
 import { chatToResponses, isServerWebSearchTool, ResponsesTranslationError, responsesToChat, responsesToolRegistry, WEB_SEARCH_TOOL_NAME } from "./responses-codec.js";
 import { openAiSseToResponses } from "./responses-stream.js";
 import { composeServerToolStream, runBufferedServerToolLoop } from "./server-tool-loop.js";
@@ -126,7 +121,9 @@ export function handleResponses(backend, body, modelCallId, signal, backendOptio
                 ...backendOptions,
                 modelCallId
             });
-            return yield* wrapResponsesReasoningResponse(response, reasoningOwner);
+            return yield* finalizeResponsesResponse(response, reasoningOwner, {
+                stream: body.stream === true
+            });
         }
         // Server-executed web search is honored when the caller declared the tool,
         // an executor is available (a provider key exists), and no *client* tool
@@ -135,6 +132,10 @@ export function handleResponses(backend, body, modelCallId, signal, backendOptio
         const declaresWebSearch = body.tools?.some(isServerWebSearchTool) === true;
         const clientNameCollision = body.tools?.some((tool) => tool.name === WEB_SEARCH_TOOL_NAME) === true;
         const executor = declaresWebSearch && !clientNameCollision ? resolveWebSearchExecutor("responses") : undefined;
+        // The server-tool owner has additional provider POSTs and an async
+        // streaming runner that do not yet carry strict request authority.
+        // Refuse the compound operation before its first model submission.
+        yield* requireHttpSubmissionSupport(executor === undefined);
         const serverTools = executor !== undefined;
         const toolRegistry = responsesToolRegistry(body, { serverTools });
         const includeCompatibleBody = requestsEncryptedReasoning && !preservesOpaqueReasoning

package/dist/adapters/server-tool-loop.d.ts

@@ -26,8 +26,8 @@
 import { type Reasoning, type ToolResult } from "@velum-labs/routekit-contracts/protocol-ir";
 import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
 import { type Context, Effect } from "effect";
-import type { BackendRequest } from "../providers/backend.js";
-import { type OpenAiChatResponse } from "../providers/protocol.js";
+import type { BackendRequest } from "@velum-labs/routekit-provider-core";
+import { type OpenAiChatResponse } from "@velum-labs/routekit-provider-core";
 import type { WebSearchExecutor } from "./web-search.js";
 /** In-process marker chunk field the loop injects between composed steps. */
 export declare const SERVER_TOOL_MARKER_FIELD = "routekit_server_tool";

package/dist/adapters/server-tool-loop.js

@@ -28,11 +28,11 @@ import { randomId } from "@velum-labs/routekit-runtime/timing";
 import { RouteKitFailure, runRouteKitEffect, runRouteKitEffectWith } from "@velum-labs/routekit-runtime/effect";
 import { StreamPump } from "@velum-labs/routekit-runtime/sse";
 import { Effect } from "effect";
-import { gatewayTry, gatewayTryPromise } from "../effect/gateway.js";
-import { decodeOpenAiChatResponse, decodeOpenAiChatSseEvent, decodeOpenAiToolCalls, isProviderRecord } from "../providers/protocol.js";
-import { ChatStreamAssembler } from "../sse/chat-assembler.js";
-import { SseParseError } from "../sse/parse.js";
-import { googleToolCallIndexesOf, responsesReasoningMetadataOf } from "./openai-chat-wire.js";
+import { gatewayTry, gatewayTryPromise } from "@velum-labs/routekit-provider-core";
+import { decodeOpenAiChatResponse, decodeOpenAiChatSseEvent, decodeOpenAiToolCalls, isProviderRecord } from "@velum-labs/routekit-provider-core";
+import { ChatStreamAssembler } from "@velum-labs/routekit-provider-core";
+import { SseParseError } from "@velum-labs/routekit-provider-core";
+import { googleToolCallIndexesOf, responsesReasoningMetadataOf } from "@velum-labs/routekit-provider-core";
 import { canonicalServerToolReasoning, nativeAnthropicServerToolReasoning, serverToolAssistantMessage } from "./server-tool-transcript.js";
 import { MAX_WEB_SEARCHES_PER_TURN } from "./web-search.js";
 const ENCODER = new TextEncoder();

package/dist/adapters/server-tool-transcript.d.ts

@@ -4,7 +4,7 @@
  * the synthetic tool turn. Loop orchestration lives in `server-tool-loop.ts`.
  */
 import type { Reasoning } from "@velum-labs/routekit-contracts/protocol-ir";
-import { type ResponsesReasoningState } from "./openai-chat-wire.js";
+import { type ResponsesReasoningState } from "@velum-labs/routekit-provider-core";
 export type ServerToolTranscriptCall = {
     providerIndex?: number;
     id?: string;

package/dist/adapters/server-tool-transcript.js

@@ -4,7 +4,7 @@
  * the synthetic tool turn. Loop orchestration lives in `server-tool-loop.ts`.
  */
 import { randomId } from "@velum-labs/routekit-runtime/timing";
-import { ANTHROPIC_MESSAGE_CONTENT, anthropicReasoningDetailsOf, anthropicReasoningExtension, attachGoogleToolCallIndexes, attachResponsesReasoningMetadata, googleThoughtDetailsOf, reasoningIndex } from "./openai-chat-wire.js";
+import { ANTHROPIC_MESSAGE_CONTENT, anthropicReasoningDetailsOf, anthropicReasoningExtension, attachGoogleToolCallIndexes, attachResponsesReasoningMetadata, googleThoughtDetailsOf, reasoningIndex } from "@velum-labs/routekit-provider-core";
 export function canonicalServerToolReasoning(details) {
     return [
         ...anthropicReasoningDetailsOf(details, "message"),

package/dist/adapters/standalone-listener.d.ts

@@ -0,0 +1,6 @@
+import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
+import { Context, Effect, Scope } from "effect";
+/** Own the runtime created for a published, standalone listener. */
+export declare function startStandaloneListener<I, A extends {
+    readonly close: Effect.Effect<void, unknown>;
+}>(service: Context.Key<I, A>, start: Effect.Effect<A, Error, RouteKitPlatform | Scope.Scope>): Promise<A>;

package/dist/adapters/standalone-listener.js

@@ -0,0 +1,26 @@
+import { RouteKitLive, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
+import { Effect, Layer, ManagedRuntime } from "effect";
+/** Own the runtime created for a published, standalone listener. */
+export async function startStandaloneListener(service, start) {
+    const layer = Layer.effect(service, Effect.acquireRelease(start, (listener) => listener.close.pipe(Effect.ignore))).pipe(Layer.provide(RouteKitLive));
+    const runtime = ManagedRuntime.make(layer);
+    try {
+        const listener = await runtime.runPromise(service);
+        let closeRun;
+        const disposeRuntime = Effect.tryPromise({
+            try: () => {
+                closeRun ??= runtime.dispose();
+                return closeRun;
+            },
+            catch: toRouteKitFailure
+        }).pipe(Effect.ignore);
+        return {
+            ...listener,
+            close: listener.close.pipe(Effect.ensuring(disposeRuntime))
+        };
+    }
+    catch (error) {
+        await runtime.dispose().catch(() => undefined);
+        throw error;
+    }
+}

package/dist/adapters/web-search.js

@@ -17,7 +17,7 @@
 import { withDeadline } from "@velum-labs/routekit-runtime/timing";
 import { executeWebRequest, RouteKitFailure, routeKitError, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { Effect } from "effect";
-import { decodeAnthropicWebSearchResult, decodeOpenAiWebSearchResult } from "../providers/protocol.js";
+import { decodeAnthropicWebSearchResult, decodeOpenAiWebSearchResult } from "@velum-labs/routekit-provider-core";
 /** Hard ceiling on gateway-executed searches within one caller turn. */
 export const MAX_WEB_SEARCHES_PER_TURN = 8;
 /** Per-search wall clock before the delegated call is aborted. */

package/dist/annotations/anthropic-stream.d.ts

@@ -0,0 +1,4 @@
+/** Prefix the first non-empty Anthropic public text block or text delta. */
+export declare function decorateAnthropicStream(body: ReadableStream<Uint8Array>, prefix: string): ReadableStream<Uint8Array>;
+/** Decorate a buffered Anthropic Messages response without adding a content block. */
+export declare function decorateAnthropicJson(value: unknown, prefix: string): boolean;

package/dist/annotations/anthropic-stream.js

@@ -0,0 +1,45 @@
+import { prefixOnce, recordOf, transformJsonSse } from "./sse-transform.js";
+/** Prefix the first non-empty Anthropic public text block or text delta. */
+export function decorateAnthropicStream(body, prefix) {
+    let emitted = false;
+    return transformJsonSse(body, (value) => {
+        if (emitted)
+            return undefined;
+        const event = recordOf(value);
+        if (event?.type === "content_block_start") {
+            const block = recordOf(event.content_block);
+            if (block?.type === "text" && typeof block.text === "string" && block.text.length > 0) {
+                block.text = prefixOnce(prefix, block.text);
+                emitted = true;
+                return value;
+            }
+        }
+        if (event?.type === "content_block_delta") {
+            const delta = recordOf(event.delta);
+            if (delta?.type === "text_delta" &&
+                typeof delta.text === "string" &&
+                delta.text.length > 0) {
+                delta.text = prefixOnce(prefix, delta.text);
+                emitted = true;
+                return value;
+            }
+        }
+        return undefined;
+    });
+}
+/** Decorate a buffered Anthropic Messages response without adding a content block. */
+export function decorateAnthropicJson(value, prefix) {
+    const content = recordOf(value)?.content;
+    if (!Array.isArray(content))
+        return false;
+    for (const part of content) {
+        const block = recordOf(part);
+        if (block?.type === "text" &&
+            typeof block.text === "string" &&
+            block.text.length > 0) {
+            block.text = prefixOnce(prefix, block.text);
+            return true;
+        }
+    }
+    return false;
+}

package/dist/annotations/chat-stream.d.ts

@@ -0,0 +1,4 @@
+/** Prefix the first non-empty Chat Completions public content delta. */
+export declare function decorateChatStream(body: ReadableStream<Uint8Array>, prefix: string): ReadableStream<Uint8Array>;
+/** Decorate a buffered Chat Completions response without creating a choice or message. */
+export declare function decorateChatJson(value: unknown, prefix: string): boolean;