@zhivex-ai/gateway 1.2.2 → 1.3.0

package/dist/index.js

@@ -1,4 +1,8 @@
-import { ConflictError, GuardrailTriggeredError, ProviderHTTPError, ValidationError, createAgent, createStructuredOutputPrompt, createTextMessage, generateObject, generateText, runAgent, streamAgent, streamObject, streamText } from "@zhivex-ai/core";
+import { ConflictError, GuardrailTriggeredError, ProviderHTTPError, ValidationError, createAgent, calculateModelCost, createStructuredOutputPrompt, createTextMessage, generateObject, generateText, runAgent, streamAgent, streamObject, streamText } from "@zhivex-ai/core";
+import { GatewayCircuitOpenError } from "./circuit-breaker.js";
+import { scoreAdaptiveTarget, validateAdaptivePolicy } from "./adaptive-routing.js";
+export { createGatewayCircuitBreaker, GatewayCircuitOpenError } from "./circuit-breaker.js";
+export { createGatewayMetrics } from "./metrics.js";
 import { createRouteDecision, gatewayMessagesToModelMessages } from "./compat.js";
 import { hasToolHistory, validateGatewayMessages } from "./history.js";
 import { GatewayError } from "./types.js";
@@ -424,6 +428,7 @@ const normalizeUsage = (usage, inputText, outputText) => {
     const outputTokens = usage?.outputTokens ?? estimateTokens(outputText);
     const totalTokens = usage?.totalTokens ?? inputTokens + outputTokens;
     return {
+        ...usage,
         inputTokens,
         outputTokens,
         totalTokens,
@@ -494,11 +499,41 @@ const historyAbortSignal = (signal) => {
     historySignals.set(signal, controller.signal);
     return controller.signal;
 };
-const assertLegacyAgentMessages = (request) => {
-    if (request.messages?.some((message) => "parts" in message)) {
-        throw new GatewayError("Canonical gateway history is not supported by agent operations.", false);
+const prepareAgentHistoryRequest = (request) => {
+    if (request.prompt !== undefined && request.messages !== undefined)
+        throw new GatewayError("Pass prompt or messages, not both.", false);
+    if (!request.messages?.some(message => "parts" in message))
+        return request;
+    validateGatewayMessages(request.messages);
+    if (request.state || request.runId || request.handoff || request.approvals || request.idempotencyKey) {
+        throw new GatewayError("Import canonical agent history as a fresh run; resume durable state using state or runId without messages or an import idempotency key.", false);
     }
+    return { ...request, metadata: { ...request.metadata, gatewayPortableHistory: true }, abortSignal: historyAbortSignal(request.abortSignal) };
 };
+const agentHistoryStore = (store, context, binding) => store ? new Proxy(store, {
+    get(target, key) {
+        const value = Reflect.get(target, key);
+        if (key === "load")
+            return async (...args) => {
+                const state = await target.load(...args);
+                if (state && binding !== undefined && state.metadata?.gatewayAgentRouteBinding !== binding)
+                    throw new ConflictError("Agent state belongs to a different gateway route binding.");
+                if (state?.metadata?.gatewayPortableHistory === true)
+                    context.toolHistory = true;
+                return state;
+            };
+        if (key === "claimIdempotencyKey" && target.claimIdempotencyKey)
+            return async (...args) => {
+                const claim = await target.claimIdempotencyKey(...args);
+                if (binding !== undefined && claim.state.metadata?.gatewayAgentRouteBinding !== binding)
+                    throw new ConflictError("Agent idempotency key belongs to a different gateway route binding.");
+                if (claim.state.metadata?.gatewayPortableHistory === true)
+                    context.toolHistory = true;
+                return claim;
+            };
+        return typeof value === "function" ? value.bind(target) : value;
+    }
+}) : undefined;
 const buildRequiredCapabilities = (request, extra = {}) => ({
     ...(request.requiredCapabilities ?? {}),
     ...(request.tools || requestHasToolHistory(request) ? { tools: true } : {}),
@@ -595,6 +630,9 @@ const createAgentRunInput = (request) => {
         providerOptions: request.providerOptions,
         policy: request.policy,
         metadata: request.metadata,
+        context: request.context,
+        compaction: request.compaction,
+        executionEnvironment: request.executionEnvironment,
         abortSignal: request.abortSignal
     };
 };
@@ -611,12 +649,82 @@ const enrichAgentResult = (target, attempts, routeDecision, startedAt, result) =
     }
 });
 export const createGateway = (config) => {
+    if (config.adaptiveRouting) {
+        validateAdaptivePolicy(config.adaptiveRouting);
+        if (config.scoreTarget)
+            throw new GatewayError("Choose adaptiveRouting or scoreTarget, not both.", false);
+    }
+    const configuredAgentRequest = (request) => {
+        const definition = request.agent;
+        if (!definition)
+            return request;
+        const defaults = {
+            agentId: definition.id, instructions: definition.instructions, tools: Array.isArray(definition.tools) ? Object.fromEntries(definition.tools.map(tool => [tool.name, tool])) : definition.tools,
+            maxSteps: definition.maxSteps, temperature: definition.temperature, maxTokens: definition.maxTokens,
+            reasoning: definition.reasoning, toolExecution: definition.toolExecution, toolApprovalPolicy: definition.toolApprovalPolicy,
+            providerOptions: definition.providerOptions, store: definition.store, memory: definition.memory,
+            onTelemetryEvent: definition.onTelemetryEvent, hookFailurePolicy: definition.hookFailurePolicy,
+            compaction: definition.compaction, executionEnvironment: definition.executionEnvironment
+        };
+        const merged = { ...defaults, ...Object.fromEntries(Object.entries(request).filter(([, value]) => value !== undefined)),
+            policy: { ...definition.policy, ...request.policy }, metadata: { ...definition.metadata, ...request.metadata }
+        };
+        const binding = JSON.stringify([1, merged.agentId ?? null, request.primary, request.fallbacks ?? [], config.adaptiveRouting?.version ?? "legacy", definition.harness?.fingerprint ?? null]);
+        merged.metadata = { ...merged.metadata, gatewayAgentRouteBinding: binding };
+        if (request.state && request.state.metadata?.gatewayAgentRouteBinding !== binding)
+            throw new ConflictError("Agent state belongs to a different gateway route binding.");
+        return merged;
+    };
+    const beginMetrics = (target, signal) => {
+        let handle;
+        try {
+            handle = config.metrics?.begin(target);
+        }
+        catch { /* Metrics cannot affect execution. */ }
+        let ended = false;
+        const end = (outcome) => {
+            if (ended)
+                return;
+            ended = true;
+            signal?.removeEventListener("abort", onAbort);
+            try {
+                handle?.end(outcome);
+            }
+            catch { /* Best effort. */ }
+        };
+        const onAbort = () => end("cancelled");
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+        return { end, firstText: () => { try {
+                handle?.firstText();
+            }
+            catch { /* Best effort. */ } } };
+    };
+    if (config.costAccounting && !config.modelCatalog)
+        throw new GatewayError("costAccounting requires a modelCatalog snapshot.", false);
+    if (config.costAccounting?.unknownCostPolicy !== undefined && !["allow", "reject"].includes(config.costAccounting.unknownCostPolicy))
+        throw new GatewayError("Invalid detailed unknownCostPolicy.", false);
+    if (config.costAccounting?.cacheAssumption !== undefined && !["reported", "none"].includes(config.costAccounting.cacheAssumption))
+        throw new GatewayError("Invalid cacheAssumption.", false);
     const createRouteContext = (request, options = {}) => {
         validateRouteRequest(config, request);
         const mode = request.routingMode ?? "balanced";
         const intent = request.taskIntent ?? options.defaultIntent ?? "chat";
-        const orderedTargets = orderTargets(mode, intent, request.primary, request.fallbacks ?? [], config);
+        const orderedTargets = config.adaptiveRouting
+            ? [request.primary, ...(request.fallbacks ?? [])].filter((target, index, all) => all.findIndex(x => x.provider === target.provider && x.modelId === target.modelId) === index)
+            : orderTargets(mode, intent, request.primary, request.fallbacks ?? [], config);
         const routeDecision = createRouteDecision(mode, intent, orderedTargets);
+        if (config.costAccounting) {
+            routeDecision.estimatedCosts = orderedTargets.map(target => calculateModelCost({
+                catalog: config.modelCatalog, ...target,
+                usage: {
+                    inputTokens: estimateTokens([request.systemPrompt, request.system, request.instructions, request.prompt, JSON.stringify(request.messages ?? [])].filter(Boolean).join("\n")),
+                    outputTokens: config.costAccounting.expectedOutputTokens ?? request.maxTokens
+                },
+                cacheAssumption: "none", estimated: true
+            }));
+        }
         const attempts = [];
         const candidates = [];
         let notificationChain = Promise.resolve();
@@ -670,6 +778,10 @@ export const createGateway = (config) => {
                 }));
                 continue;
             }
+            if (config.costAccounting?.unknownCostPolicy === "reject" && routeDecision.estimatedCosts?.[targetRank]?.status === "unknown") {
+                queueAttempt(createAttempt(target, false, 0, targetRank, { reasonCode: "cost-budget", errorMessage: "Skipped because detailed request cost is unknown." }));
+                continue;
+            }
             const skip = options.getSkipReason?.(model, target);
             if (skip) {
                 queueAttempt(createAttempt(target, false, 0, targetRank, {
@@ -680,7 +792,36 @@ export const createGateway = (config) => {
             }
             candidates.push({ target, targetRank, model });
         }
+        if (config.adaptiveRouting) {
+            const policy = config.adaptiveRouting;
+            const evaluated = orderedTargets.map((target, index) => {
+                const candidate = candidates.find(x => x.target === target);
+                let snapshot;
+                try {
+                    snapshot = config.metrics?.snapshot(target);
+                }
+                catch { /* Treat unavailable metrics as cold start. */ }
+                const evaluation = scoreAdaptiveTarget(policy, target, intent, snapshot, routeDecision.estimatedCosts?.[index]);
+                if (!candidate)
+                    evaluation.exclusions.push(...attempts.filter(x => x.provider === target.provider && x.modelId === target.modelId).map(x => x.reasonCode ?? "operation-skip"));
+                if (config.circuitBreaker && !config.circuitBreaker.canAttempt(target))
+                    evaluation.exclusions.push("circuit-open");
+                if (evaluation.exclusions.length && candidate)
+                    queueAttempt(createAttempt(target, false, 0, index, { reasonCode: evaluation.exclusions.includes("circuit-open") ? "circuit-open" : "operation-skip", errorMessage: `Adaptive exclusion: ${evaluation.exclusions.join(", ")}.` }));
+                return evaluation;
+            });
+            routeDecision.reasonCode = "routing-adaptive";
+            routeDecision.adaptive = { policyVersion: policy.version, candidates: evaluated };
+            const eligible = candidates.filter(candidate => !evaluated.find(x => x.target.provider === candidate.target.provider && x.target.modelId === candidate.target.modelId).exclusions.length);
+            eligible.sort((left, right) => evaluated.find(x => x.target.provider === right.target.provider && x.target.modelId === right.target.modelId).score - evaluated.find(x => x.target.provider === left.target.provider && x.target.modelId === left.target.modelId).score || left.targetRank - right.targetRank);
+            candidates.splice(0, candidates.length, ...eligible);
+            candidates.forEach((candidate, index) => { candidate.targetRank = index; });
+            routeDecision.orderedTargets = candidates.map(x => x.target);
+            routeDecision.reason = `Ordered by adaptive policy ${policy.version}; ties preserve request order.`;
+        }
         if (!candidates.length) {
+            if (attempts.at(-1)?.reasonCode === "circuit-open")
+                throw new GatewayCircuitOpenError();
             throw new GatewayError(attempts.at(-1)?.errorMessage ?? "No gateway target satisfied the request.", false);
         }
         const context = {
@@ -691,6 +832,18 @@ export const createGateway = (config) => {
             startedAt: Date.now(),
             flushAttempts: () => notificationChain,
             recordAttempt: async (attempt) => {
+                if (config.costAccounting && ["provider-success", "provider-error", "request-aborted"].includes(attempt.reasonCode ?? "")) {
+                    const costInput = { catalog: config.modelCatalog, provider: attempt.provider, modelId: attempt.modelId };
+                    try {
+                        attempt = { ...attempt, cost: calculateModelCost({ ...costInput, usage: attempt.usage, cacheAssumption: config.costAccounting.cacheAssumption, reasoningAccounting: config.costAccounting.reasoningAccounting?.[attempt.provider] }) };
+                    }
+                    catch {
+                        // Accounting cannot turn a successful model invocation into a retry.
+                        const cost = calculateModelCost(costInput);
+                        cost.unknownReasons.push("invalid-reported-usage");
+                        attempt = { ...attempt, cost };
+                    }
+                }
                 queueAttempt(attempt);
                 await notificationChain;
             },
@@ -743,6 +896,8 @@ export const createGateway = (config) => {
             }));
         };
         const throwFinalError = () => {
+            if (context.attempts.at(-1)?.reasonCode === "circuit-open")
+                throw new GatewayCircuitOpenError();
             throw new GatewayError(context.attempts.at(-1)?.errorMessage ?? "All gateway attempts failed.", false);
         };
         const generate = async (input) => {
@@ -754,24 +909,40 @@ export const createGateway = (config) => {
             for (const candidate of candidates) {
                 const candidateInput = prepareInput(candidate.model, input);
                 const inputSkipReason = modelInputSkipReason(candidate.model, candidateInput) ??
-                    (context.toolHistory ? historyInputSkipReason(candidate.model, input) : undefined);
+                    (context.toolHistory ? historySkipReason(candidate.model, hasToolHistory(input.messages)) ?? historyInputSkipReason(candidate.model, input) : undefined);
                 if (inputSkipReason) {
                     await recordInputSkip(candidate, inputSkipReason);
                     continue;
                 }
                 for (let retry = 0; retry <= maxRetries; retry += 1) {
-                    reserveProviderAttempt();
+                    const timeoutMs = getAttemptTimeoutMs(config, candidate.target.provider);
+                    const permit = config.circuitBreaker?.acquire(candidate.target);
+                    if (config.circuitBreaker && !permit) {
+                        await context.recordAttempt(createAttempt(candidate.target, false, 0, candidate.targetRank, { reasonCode: "circuit-open", errorMessage: "Destination circuit is open or probe capacity is exhausted." }));
+                        break;
+                    }
+                    try {
+                        reserveProviderAttempt();
+                    }
+                    catch (error) {
+                        permit?.end("neutral");
+                        throw error;
+                    }
                     const attemptStartedAt = Date.now();
-                    const control = createAttemptControl(input.abortSignal, getAttemptTimeoutMs(config, candidate.target.provider));
+                    const control = createAttemptControl(input.abortSignal, timeoutMs);
+                    const metrics = beginMetrics(candidate.target, input.abortSignal);
                     try {
                         const result = await control.waitFor(candidate.model.generate({
                             ...prepareHistoryInput(candidate.model, candidateInput, context.toolHistory),
                             abortSignal: control.signal
                         }));
                         control.stopTimeout();
+                        metrics.end("success");
+                        permit?.end("success");
                         await context.recordAttempt(createAttempt(candidate.target, true, Date.now() - attemptStartedAt, candidate.targetRank, {
                             retry,
-                            reasonCode: "provider-success"
+                            reasonCode: "provider-success",
+                            ...(config.costAccounting ? { usage: result.usage } : {})
                         }));
                         await context.lock(candidate);
                         control.dispose();
@@ -779,10 +950,12 @@ export const createGateway = (config) => {
                     }
                     catch (rawError) {
                         const callerAborted = input.abortSignal?.aborted === true;
+                        metrics.end(callerAborted ? "cancelled" : "error");
                         const error = control.timedOut() ? control.timeoutError : rawError;
                         control.abort(error);
                         control.dispose();
                         if (callerAborted) {
+                            permit?.end("neutral");
                             await context.recordAttempt(createAttempt(candidate.target, false, Date.now() - attemptStartedAt, candidate.targetRank, {
                                 retry,
                                 reasonCode: "request-aborted",
@@ -791,11 +964,14 @@ export const createGateway = (config) => {
                             throw abortReason(input.abortSignal);
                         }
                         const disposition = dispositionFor(error);
+                        permit?.end(disposition.retrySameTarget ? "retryable-error" : "neutral", disposition.retryAfterMs);
                         await context.recordAttempt(createAttempt(candidate.target, false, Date.now() - attemptStartedAt, candidate.targetRank, {
                             retry,
                             reasonCode: "provider-error",
                             errorMessage: disposition.error.message
                         }));
+                        if (config.circuitBreaker?.snapshot(candidate.target)?.state === "open")
+                            break;
                         if (retry < maxRetries && disposition.retrySameTarget) {
                             await abortableSleep(retryBackoffMs(config, retry, disposition.retryAfterMs), input.abortSignal);
                             continue;
@@ -818,7 +994,7 @@ export const createGateway = (config) => {
             for (const candidate of candidates) {
                 const candidateInput = prepareInput(candidate.model, input);
                 const inputSkipReason = modelInputSkipReason(candidate.model, candidateInput) ??
-                    (context.toolHistory ? historyInputSkipReason(candidate.model, input) : undefined);
+                    (context.toolHistory ? historySkipReason(candidate.model, hasToolHistory(input.messages)) ?? historyInputSkipReason(candidate.model, input) : undefined);
                 if (inputSkipReason) {
                     await recordInputSkip(candidate, inputSkipReason);
                     continue;
@@ -828,10 +1004,23 @@ export const createGateway = (config) => {
                     continue;
                 }
                 for (let retry = 0; retry <= maxRetries; retry += 1) {
-                    reserveProviderAttempt();
+                    const timeoutMs = getAttemptTimeoutMs(config, candidate.target.provider);
+                    const permit = config.circuitBreaker?.acquire(candidate.target);
+                    if (config.circuitBreaker && !permit) {
+                        await context.recordAttempt(createAttempt(candidate.target, false, 0, candidate.targetRank, { reasonCode: "circuit-open", errorMessage: "Destination circuit is open or probe capacity is exhausted." }));
+                        break;
+                    }
+                    try {
+                        reserveProviderAttempt();
+                    }
+                    catch (error) {
+                        permit?.end("neutral");
+                        throw error;
+                    }
                     const attemptStartedAt = Date.now();
-                    const control = createAttemptControl(input.abortSignal, getAttemptTimeoutMs(config, candidate.target.provider));
+                    const control = createAttemptControl(input.abortSignal, timeoutMs);
                     let iterator;
+                    const metrics = beginMetrics(candidate.target, input.abortSignal);
                     try {
                         const providerStream = await control.waitFor(candidate.model.stream({
                             ...prepareHistoryInput(candidate.model, candidateInput, context.toolHistory),
@@ -845,6 +1034,8 @@ export const createGateway = (config) => {
                         if (firstEvent.value.type === "error") {
                             throw firstEvent.value.error;
                         }
+                        if (firstEvent.value.type === "text-delta")
+                            metrics.firstText();
                         control.stopTimeout();
                         await context.lock(candidate);
                         const streamIdleTimeoutMs = getStreamIdleTimeoutMs(config, candidate.target.provider);
@@ -863,28 +1054,39 @@ export const createGateway = (config) => {
                         };
                         return (async function* () {
                             let completed = false;
+                            let usage = firstEvent.value.type === "finish" ? firstEvent.value.usage : undefined;
                             try {
                                 yield firstEvent.value;
                                 for (;;) {
                                     const next = await nextEvent();
                                     if (next.done) {
                                         completed = true;
+                                        metrics.end("success");
+                                        permit?.end("success");
                                         await context.recordAttempt(createAttempt(candidate.target, true, Date.now() - attemptStartedAt, candidate.targetRank, {
-                                            retry, reasonCode: "provider-success"
+                                            retry, reasonCode: "provider-success", ...(config.costAccounting ? { usage } : {})
                                         }));
                                         return;
                                     }
                                     if (next.value.type === "error")
                                         throw next.value.error;
+                                    if (next.value.type === "text-delta")
+                                        metrics.firstText();
+                                    if (next.value.type === "finish" && next.value.usage)
+                                        usage = { ...usage, ...next.value.usage };
                                     yield next.value;
                                 }
                             }
                             catch (error) {
                                 const aborted = input.abortSignal?.aborted === true;
-                                const diagnostic = dispositionFor(error).error;
+                                metrics.end(aborted ? "cancelled" : "error");
+                                const disposition = dispositionFor(error);
+                                permit?.end(aborted ? "neutral" : disposition.retrySameTarget ? "retryable-error" : "neutral", disposition.retryAfterMs);
+                                const diagnostic = disposition.error;
                                 const failure = aborted ? abortReason(input.abortSignal) : context.toolHistory ? diagnostic : error;
                                 await context.recordAttempt(createAttempt(candidate.target, false, Date.now() - attemptStartedAt, candidate.targetRank, {
                                     retry,
+                                    ...(config.costAccounting ? { usage } : {}),
                                     reasonCode: aborted ? "request-aborted" : "provider-error",
                                     errorMessage: aborted ? abortReason(input.abortSignal).message : diagnostic.message
                                 }));
@@ -892,6 +1094,8 @@ export const createGateway = (config) => {
                             }
                             finally {
                                 if (!completed) {
+                                    metrics.end("cancelled");
+                                    permit?.end("neutral");
                                     control.abort(new DOMException("Gateway stream consumer closed.", "AbortError"));
                                 }
                                 control.dispose();
@@ -908,6 +1112,7 @@ export const createGateway = (config) => {
                     }
                     catch (rawError) {
                         const callerAborted = input.abortSignal?.aborted === true;
+                        metrics.end(callerAborted ? "cancelled" : "error");
                         const error = control.timedOut() ? control.timeoutError : rawError;
                         control.abort(error);
                         control.dispose();
@@ -918,6 +1123,7 @@ export const createGateway = (config) => {
                             catch { /* Cleanup must not prevent fallback. */ }
                         }
                         if (callerAborted) {
+                            permit?.end("neutral");
                             await context.recordAttempt(createAttempt(candidate.target, false, Date.now() - attemptStartedAt, candidate.targetRank, {
                                 retry,
                                 reasonCode: "request-aborted",
@@ -926,11 +1132,14 @@ export const createGateway = (config) => {
                             throw abortReason(input.abortSignal);
                         }
                         const disposition = dispositionFor(error);
+                        permit?.end(disposition.retrySameTarget ? "retryable-error" : "neutral", disposition.retryAfterMs);
                         await context.recordAttempt(createAttempt(candidate.target, false, Date.now() - attemptStartedAt, candidate.targetRank, {
                             retry,
                             reasonCode: "provider-error",
                             errorMessage: disposition.error.message
                         }));
+                        if (config.circuitBreaker?.snapshot(candidate.target)?.state === "open")
+                            break;
                         if (retry < maxRetries && disposition.retrySameTarget) {
                             await abortableSleep(retryBackoffMs(config, retry, disposition.retryAfterMs), input.abortSignal);
                             continue;
@@ -968,7 +1177,7 @@ export const createGateway = (config) => {
             model: createRoutedLanguageModel(context)
         };
     };
-    return {
+    const gateway = {
         async generate(request) {
             const route = createStandardRoute(request);
             const result = await generateText(createTextOptions(route.model, request));
@@ -1036,7 +1245,7 @@ export const createGateway = (config) => {
             };
         },
         async runAgent(request) {
-            assertLegacyAgentMessages(request);
+            request = prepareAgentHistoryRequest(configuredAgentRequest(request));
             const route = createStandardRoute(request, {
                 defaultIntent: "tool-heavy",
                 getSkipReason: (model) => supportsRequiredAgentCapabilities(model, request.requiredAgentCapabilities)
@@ -1056,7 +1265,10 @@ export const createGateway = (config) => {
                     });
                 }
             });
+            if (request.state?.metadata?.gatewayPortableHistory === true)
+                route.context.toolHistory = true;
             const agent = createAgent({
+                ...request.agent,
                 id: request.agentId,
                 model: route.model,
                 instructions: request.instructions,
@@ -1070,7 +1282,7 @@ export const createGateway = (config) => {
                 providerOptions: request.providerOptions,
                 policy: request.policy,
                 metadata: request.metadata,
-                store: request.store,
+                store: agentHistoryStore(request.store, route.context, request.agent ? request.metadata?.gatewayAgentRouteBinding : undefined),
                 memory: request.memory,
                 onTelemetryEvent: request.onTelemetryEvent,
                 hookFailurePolicy: request.hookFailurePolicy
@@ -1079,7 +1291,7 @@ export const createGateway = (config) => {
             return enrichAgentResult(targetForResult(route.context), route.context.attempts, route.context.routeDecision, route.context.startedAt, result);
         },
         streamAgent(request) {
-            assertLegacyAgentMessages(request);
+            request = prepareAgentHistoryRequest(configuredAgentRequest(request));
             const route = createStandardRoute(request, {
                 defaultIntent: "tool-heavy",
                 extraRequiredCapabilities: { streaming: true },
@@ -1100,7 +1312,10 @@ export const createGateway = (config) => {
                     });
                 }
             });
+            if (request.state?.metadata?.gatewayPortableHistory === true)
+                route.context.toolHistory = true;
             const agent = createAgent({
+                ...request.agent,
                 id: request.agentId,
                 model: route.model,
                 instructions: request.instructions,
@@ -1114,7 +1329,7 @@ export const createGateway = (config) => {
                 providerOptions: request.providerOptions,
                 policy: request.policy,
                 metadata: request.metadata,
-                store: request.store,
+                store: agentHistoryStore(request.store, route.context, request.agent ? request.metadata?.gatewayAgentRouteBinding : undefined),
                 memory: request.memory,
                 onTelemetryEvent: request.onTelemetryEvent,
                 hookFailurePolicy: request.hookFailurePolicy
@@ -1130,5 +1345,55 @@ export const createGateway = (config) => {
             };
         }
     };
+    const managedStream = (request, start) => {
+        if (!config.metrics && !config.circuitBreaker)
+            return start(request);
+        const controller = new AbortController();
+        const abort = () => controller.abort(new DOMException("Gateway stream consumer closed.", "AbortError"));
+        request.abortSignal?.addEventListener("abort", abort, { once: true });
+        if (request.abortSignal?.aborted)
+            abort();
+        const cleanup = () => request.abortSignal?.removeEventListener("abort", abort);
+        try {
+            const result = start({ ...request, abortSignal: controller.signal });
+            const completion = result.collect().finally(cleanup);
+            void completion.catch(() => undefined);
+            const wrapped = { ...result, collect: () => completion };
+            for (const key of ["eventStream", "textStream", "partialObjectStream"]) {
+                const source = result[key];
+                if (!source)
+                    continue;
+                wrapped[key] = {
+                    [Symbol.asyncIterator]() {
+                        const iterator = source[Symbol.asyncIterator]();
+                        return {
+                            next: () => iterator.next(),
+                            return: async () => {
+                                abort();
+                                cleanup();
+                                try {
+                                    void Promise.resolve(iterator.return?.()).catch(() => undefined);
+                                }
+                                catch { /* Best effort. */ }
+                                return { done: true, value: undefined };
+                            }
+                        };
+                    }
+                };
+            }
+            return wrapped;
+        }
+        catch (error) {
+            abort();
+            cleanup();
+            throw error;
+        }
+    };
+    return {
+        ...gateway,
+        streamText: (request) => managedStream(request, gateway.streamText),
+        streamObject: (request) => managedStream(request, gateway.streamObject),
+        streamAgent: (request) => managedStream(request, gateway.streamAgent)
+    };
 };
 //# sourceMappingURL=index.js.map