@zhivex-ai/gateway 0.3.1-next.0 → 0.4.0

package/dist/index.js

@@ -1,13 +1,96 @@
-import { generateObject, generateText, streamObject, streamText } from "@zhivex-ai/core";
-import { executeRoutedOperation } from "./attempts.js";
-import { gatewayMessagesToModelMessages, stripImagesForUnsupportedModel } from "./compat.js";
-import { createDefaultRetryPolicy, createDefaultRouterPolicy } from "./policies.js";
-import { createInMemoryGatewayRuntimeStore, gatewayTargetKey } from "./runtime-state.js";
+import { createAgent, generateObject, runAgent, generateText, streamAgent, streamObject, streamText } from "@zhivex-ai/core";
+import { createRouteDecision, gatewayMessagesToModelMessages, stripImagesForUnsupportedModel } from "./compat.js";
 import { GatewayError } from "./types.js";
-export * from "./policies.js";
-export * from "./runtime-state.js";
-export * from "./types.js";
+const scoreTarget = (mode, intent, target, config) => {
+    const model = target.modelId.toLowerCase();
+    const localBoost = target.provider === "ollama" ? -2 : 0;
+    const qualityBoost = model.includes("pro") || model.includes("claude") ? 2 : 0;
+    const speedBoost = model.includes("flash") || model.includes("lite") ? 2 : 0;
+    const reasoningBoost = model.includes("pro") || model.includes("claude") ? 2 : 0;
+    const catalogCost = config.modelCatalog?.find(target.provider, target.modelId)?.costPer1kTokens;
+    const costPenalty = config.providerCostsPer1kTokens?.[target.provider] ?? catalogCost ?? 0;
+    const latencyPenalty = (config.latencyBiasMs?.[target.provider] ?? 0) / 100;
+    if (mode === "speed") {
+        return speedBoost + localBoost - latencyPenalty;
+    }
+    if (mode === "quality") {
+        return qualityBoost + (intent === "reasoning" ? reasoningBoost : 0) - costPenalty;
+    }
+    return speedBoost + qualityBoost + localBoost + (intent === "reasoning" ? 1 : 0) - costPenalty - latencyPenalty;
+};
+const orderTargets = (mode, intent, primary, fallbacks, config) => [primary, ...fallbacks]
+    .filter((target, index, list) => list.findIndex((candidate) => candidate.provider === target.provider && candidate.modelId === target.modelId) === index)
+    .sort((left, right) => scoreTarget(mode, intent, right, config) - scoreTarget(mode, intent, left, config));
+const supportsRequiredCapabilities = (adapter, target, requiredCapabilities) => {
+    if (!requiredCapabilities) {
+        return true;
+    }
+    const capabilities = adapter.languageModel(target.modelId).capabilities;
+    return Object.entries(requiredCapabilities).every(([key, required]) => required !== true || capabilities[key] === true);
+};
+const agentTierRank = (tier) => tier === "tier-a" ? 3 : tier === "tier-b" ? 2 : tier === "tier-c" ? 1 : 0;
+const supportsRequiredAgentCapabilities = (adapter, target, requiredAgentCapabilities) => {
+    if (!requiredAgentCapabilities) {
+        return true;
+    }
+    const capabilities = adapter.languageModel(target.modelId).capabilities.agentCapabilities;
+    if (!capabilities) {
+        return false;
+    }
+    return Object.entries(requiredAgentCapabilities).every(([key, value]) => {
+        if (value == null) {
+            return true;
+        }
+        if (key === "supportTier") {
+            return agentTierRank(capabilities.supportTier) >= agentTierRank(value);
+        }
+        return value !== true || capabilities[key] === true;
+    });
+};
+const withinCostBudget = (config, request, target) => {
+    if (request.maxCostPer1kTokens == null) {
+        return true;
+    }
+    const configuredCost = config.providerCostsPer1kTokens?.[target.provider];
+    const catalogCost = config.modelCatalog?.find(target.provider, target.modelId)?.costPer1kTokens;
+    const effectiveCost = configuredCost ?? catalogCost;
+    if (effectiveCost == null) {
+        return true;
+    }
+    return effectiveCost <= request.maxCostPer1kTokens;
+};
 const estimateTokens = (text) => Math.max(1, Math.ceil(text.trim().length / 4));
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const withTimeout = async (promise, timeoutMs) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new GatewayError(`Provider timed out after ${timeoutMs}ms.`, true)), timeoutMs);
+    promise
+        .then((value) => {
+        clearTimeout(timer);
+        resolve(value);
+    })
+        .catch((error) => {
+        clearTimeout(timer);
+        reject(error);
+    });
+});
+const normalizeError = (error) => {
+    if (error instanceof GatewayError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        if (message.includes("timed out") || message.includes("429") || message.includes("rate")) {
+            return new GatewayError(error.message, true);
+        }
+        if (message.includes("connect") || message.includes("econnrefused") || message.includes("503")) {
+            return new GatewayError(error.message, true);
+        }
+        return new GatewayError(error.message, false);
+    }
+    return new GatewayError("Unknown gateway error.", false);
+};
+const getAttemptTimeoutMs = (config, provider) => config.attemptTimeoutsMs?.[provider] ?? config.attemptTimeoutMs ?? 20_000;
+const retryBackoffMs = (config, retry) => (config.retryBackoffMs ?? 200) * (retry + 1);
 const normalizeUsage = (usage, inputText, outputText) => {
     const inputTokens = usage?.inputTokens ?? estimateTokens(inputText);
     const outputTokens = usage?.outputTokens ?? estimateTokens(outputText);
@@ -19,17 +102,14 @@ const normalizeUsage = (usage, inputText, outputText) => {
         estimated: usage?.inputTokens == null || usage?.outputTokens == null || usage?.totalTokens == null
     };
 };
+const requestMessages = (request) => gatewayMessagesToModelMessages(stripImagesForUnsupportedModel(request.messages, request.primary.provider, request.primary.modelId), request.systemPrompt);
 const getInputText = (request) => `${request.systemPrompt ?? ""}\n${request.messages.map((message) => message.content).join("\n")}`.trim();
-const dedupeTargets = (primary, fallbacks = []) => [primary, ...fallbacks].filter((target, index, list) => list.findIndex((candidate) => candidate.provider === target.provider && candidate.modelId === target.modelId) === index);
 const buildRequiredCapabilities = (request, extra = {}) => ({
     ...(request.requiredCapabilities ?? {}),
     ...(request.tools ? { tools: true } : {}),
     ...(request.reasoning ? { reasoning: true } : {}),
-    ...(request.stepType === "grounded" ? { webSearch: true } : {}),
     ...extra
 });
-const getTaskIntent = (request) => request.taskIntent ??
-    (request.stepType === "plan" ? "reasoning" : request.stepType === "act" ? "tool-heavy" : "chat");
 const createTextOptions = (adapter, target, request) => ({
     model: adapter.languageModel(target.modelId),
     messages: gatewayMessagesToModelMessages(stripImagesForUnsupportedModel(request.messages, target.provider, target.modelId), request.systemPrompt),
@@ -43,176 +123,308 @@ const createTextOptions = (adapter, target, request) => ({
     providerOptions: request.providerOptions,
     abortSignal: request.abortSignal
 });
-const enrichTextResult = (request, target, attempts, routeDecision, startedAt, result, currentTime = Date.now()) => ({
+const enrichTextResult = (request, target, attempts, routeDecision, startedAt, result) => ({
     ...result,
     providerUsed: target.provider,
     modelUsed: target.modelId,
-    latencyMs: currentTime - startedAt,
+    latencyMs: Date.now() - startedAt,
     attempts,
     usage: normalizeUsage(result.usage, getInputText(request), result.text),
     routeDecision
 });
-const enrichObjectResult = (request, target, attempts, routeDecision, startedAt, result, currentTime = Date.now()) => ({
+const enrichObjectResult = (request, target, attempts, routeDecision, startedAt, result) => ({
     ...result,
     providerUsed: target.provider,
     modelUsed: target.modelId,
-    latencyMs: currentTime - startedAt,
+    latencyMs: Date.now() - startedAt,
     attempts,
     usage: normalizeUsage(result.usage, getInputText(request), result.text),
     routeDecision
 });
-const getAttemptTimeoutMs = (config, provider) => config.attemptTimeoutsMs?.[provider] ?? config.attemptTimeoutMs ?? 20_000;
-const withFirstEventReplay = (streamResult, firstEvent, iterator) => {
-    const eventStream = (async function* () {
-        if (!firstEvent.done) {
-            yield firstEvent.value;
-        }
-        while (true) {
-            const next = await iterator.next();
-            if (next.done) {
-                return;
-            }
-            yield next.value;
-        }
-    })();
+const createAgentMessages = (request, target) => request.messages
+    ? gatewayMessagesToModelMessages(stripImagesForUnsupportedModel(request.messages, target.provider, target.modelId), undefined)
+    : undefined;
+const createAgentRunInput = (request, target) => {
+    const source = request.prompt !== undefined
+        ? { prompt: request.prompt }
+        : request.messages
+            ? { messages: createAgentMessages(request, target) }
+            : {};
     return {
-        ...streamResult,
-        eventStream
+        ...source,
+        system: request.system,
+        state: request.state,
+        approvals: request.approvals,
+        handoff: request.handoff,
+        tools: request.tools,
+        toolChoice: request.toolChoice,
+        toolExecution: request.toolExecution,
+        maxSteps: request.maxSteps,
+        temperature: request.temperature,
+        maxTokens: request.maxTokens,
+        reasoning: request.reasoning,
+        providerOptions: request.providerOptions,
+        abortSignal: request.abortSignal
     };
 };
+const enrichAgentResult = (target, attempts, routeDecision, startedAt, result) => ({
+    ...result,
+    providerUsed: target.provider,
+    modelUsed: target.modelId,
+    latencyMs: Date.now() - startedAt,
+    attempts,
+    routeDecision,
+    state: {
+        ...result.state,
+        routeDecision
+    }
+});
 export const createGateway = (config) => {
-    const now = config.now ?? Date.now;
-    const runtimeStore = config.runtimeStore ?? createInMemoryGatewayRuntimeStore();
-    const routerPolicy = config.routerPolicy ?? createDefaultRouterPolicy();
-    const retryPolicy = config.retryPolicy ?? createDefaultRetryPolicy({ maxRetries: config.maxRetries, backoffMs: config.retryBackoffMs });
-    const emitEvent = async (event) => {
-        await config.onEvent?.(event);
+    const getAdapter = (provider) => {
+        const adapter = config.adapters[provider];
+        if (!adapter) {
+            throw new GatewayError(`No adapter registered for provider "${provider}".`, false);
+        }
+        return adapter;
     };
-    const getAdapter = (provider) => config.adapters[provider];
-    const planRoute = async (request, extraRequiredCapabilities = {}) => {
-        const normalizedRequest = {
-            ...request,
-            taskIntent: getTaskIntent(request)
+    const routeDecisionFor = (request) => {
+        const mode = request.routingMode ?? "balanced";
+        const intent = request.taskIntent ?? "chat";
+        const orderedTargets = orderTargets(mode, intent, request.primary, request.fallbacks ?? [], config);
+        return {
+            mode,
+            intent,
+            orderedTargets,
+            routeDecision: createRouteDecision(mode, intent, orderedTargets)
         };
-        const targets = dedupeTargets(request.primary, request.fallbacks);
-        const runtimeStates = new Map(await Promise.all(targets.map(async (target) => [gatewayTargetKey(target), await runtimeStore.get(gatewayTargetKey(target))])));
-        const routeDecision = await routerPolicy.plan({
-            request: normalizedRequest,
-            targets,
-            requiredCapabilities: buildRequiredCapabilities(normalizedRequest, extraRequiredCapabilities),
-            adapters: config.adapters,
-            runtimeStates,
-            modelCatalog: config.modelCatalog,
-            providerCostsPer1kTokens: config.providerCostsPer1kTokens,
-            latencyBiasMs: config.latencyBiasMs,
-            now: now()
-        });
-        await emitEvent({
-            type: "route-selected",
-            request: normalizedRequest,
-            timestamp: now(),
-            decision: routeDecision
-        });
-        return routeDecision;
+    };
+    const selectAgentTarget = async (request) => {
+        const mode = request.routingMode ?? "balanced";
+        const intent = request.taskIntent ?? "tool-heavy";
+        const orderedTargets = orderTargets(mode, intent, request.primary, request.fallbacks ?? [], config);
+        const routeDecision = createRouteDecision(mode, intent, orderedTargets);
+        const attempts = [];
+        for (const target of orderedTargets) {
+            const adapter = getAdapter(target.provider);
+            if (!supportsRequiredCapabilities(adapter, target, buildRequiredCapabilities(request))) {
+                attempts.push({
+                    provider: target.provider,
+                    modelId: target.modelId,
+                    ok: false,
+                    latencyMs: 0,
+                    errorMessage: "Skipped because model capabilities do not satisfy the request."
+                });
+                continue;
+            }
+            if (!supportsRequiredAgentCapabilities(adapter, target, request.requiredAgentCapabilities)) {
+                attempts.push({
+                    provider: target.provider,
+                    modelId: target.modelId,
+                    ok: false,
+                    latencyMs: 0,
+                    errorMessage: "Skipped because agent capabilities do not satisfy the request."
+                });
+                continue;
+            }
+            if (!withinCostBudget(config, request, target)) {
+                attempts.push({
+                    provider: target.provider,
+                    modelId: target.modelId,
+                    ok: false,
+                    latencyMs: 0,
+                    errorMessage: "Skipped because provider cost exceeds the configured budget."
+                });
+                continue;
+            }
+            await config.onAgentRoute?.({
+                provider: target.provider,
+                modelId: target.modelId,
+                routeDecision
+            });
+            return {
+                target,
+                attempts,
+                routeDecision,
+                startedAt: Date.now()
+            };
+        }
+        throw new GatewayError(attempts.at(-1)?.errorMessage ?? "No gateway agent target satisfied the request.", false);
     };
     const runGenerate = async (request, operation, extraRequiredCapabilities = {}) => {
-        const startedAt = now();
-        const routeDecision = await planRoute(request, extraRequiredCapabilities);
-        const executed = await executeRoutedOperation({
-            request,
-            routeDecision,
-            retryPolicy,
-            runtimeStore,
-            getAttemptTimeoutMs: (target) => getAttemptTimeoutMs(config, target.provider),
-            onAttempt: config.onAttempt,
-            onEvent: config.onEvent,
-            now,
-            operation: async (target) => {
-                const adapter = getAdapter(target.provider);
-                if (!adapter) {
-                    throw new GatewayError(`No adapter registered for provider "${target.provider}".`, false);
+        const attempts = [];
+        const startedAt = Date.now();
+        const { orderedTargets, routeDecision } = routeDecisionFor(request);
+        const maxRetries = Math.max(0, config.maxRetries ?? 2);
+        const requiredCapabilities = buildRequiredCapabilities(request, extraRequiredCapabilities);
+        for (const [targetIndex, target] of orderedTargets.entries()) {
+            const adapter = getAdapter(target.provider);
+            if (!supportsRequiredCapabilities(adapter, target, requiredCapabilities)) {
+                attempts.push({
+                    provider: target.provider,
+                    modelId: target.modelId,
+                    ok: false,
+                    latencyMs: 0,
+                    errorMessage: "Skipped because model capabilities do not satisfy the request."
+                });
+                continue;
+            }
+            if (!withinCostBudget(config, request, target)) {
+                attempts.push({
+                    provider: target.provider,
+                    modelId: target.modelId,
+                    ok: false,
+                    latencyMs: 0,
+                    errorMessage: "Skipped because provider cost exceeds the configured budget."
+                });
+                continue;
+            }
+            for (let retry = 0; retry <= maxRetries; retry += 1) {
+                const attemptStartedAt = Date.now();
+                try {
+                    await config.onAttempt?.({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: true,
+                        latencyMs: 0,
+                        retry,
+                        targetRank: targetIndex
+                    });
+                    const result = await withTimeout(operation(adapter, target), getAttemptTimeoutMs(config, target.provider));
+                    attempts.push({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: true,
+                        latencyMs: Date.now() - attemptStartedAt
+                    });
+                    return {
+                        attempts,
+                        target,
+                        startedAt,
+                        routeDecision,
+                        result
+                    };
+                }
+                catch (error) {
+                    const normalized = normalizeError(error);
+                    attempts.push({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: false,
+                        latencyMs: Date.now() - attemptStartedAt,
+                        errorMessage: normalized.message
+                    });
+                    await config.onAttempt?.({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: false,
+                        latencyMs: Date.now() - attemptStartedAt,
+                        errorMessage: normalized.message,
+                        retry,
+                        targetRank: targetIndex
+                    });
+                    if (retry < maxRetries && normalized.retryable) {
+                        await sleep(retryBackoffMs(config, retry));
+                        continue;
+                    }
+                    break;
                 }
-                return operation(adapter, target);
             }
-        });
-        return {
-            ...executed,
-            startedAt,
-            routeDecision
-        };
+        }
+        const finalError = attempts.at(-1)?.errorMessage ?? "All gateway attempts failed.";
+        throw new GatewayError(finalError, false);
     };
     const runStream = async (request, operation, extraRequiredCapabilities = {}) => {
-        const startedAt = now();
-        const routeDecision = await planRoute(request, { streaming: true, ...extraRequiredCapabilities });
-        const executed = await executeRoutedOperation({
-            request,
-            routeDecision,
-            retryPolicy,
-            runtimeStore,
-            getAttemptTimeoutMs: (target) => getAttemptTimeoutMs(config, target.provider),
-            onAttempt: config.onAttempt,
-            onEvent: config.onEvent,
-            now,
-            operation: async (target) => {
-                const adapter = getAdapter(target.provider);
-                if (!adapter) {
-                    throw new GatewayError(`No adapter registered for provider "${target.provider}".`, false);
-                }
-                const streamResult = operation(adapter, target);
+        const attempts = [];
+        const startedAt = Date.now();
+        const { orderedTargets, routeDecision } = routeDecisionFor(request);
+        const maxRetries = Math.max(0, config.maxRetries ?? 2);
+        const requiredCapabilities = buildRequiredCapabilities(request, { streaming: true, ...extraRequiredCapabilities });
+        for (const [targetIndex, target] of orderedTargets.entries()) {
+            const adapter = getAdapter(target.provider);
+            if (!supportsRequiredCapabilities(adapter, target, requiredCapabilities)) {
+                attempts.push({
+                    provider: target.provider,
+                    modelId: target.modelId,
+                    ok: false,
+                    latencyMs: 0,
+                    errorMessage: "Skipped because model capabilities do not satisfy the request."
+                });
+                continue;
+            }
+            if (!withinCostBudget(config, request, target)) {
+                attempts.push({
+                    provider: target.provider,
+                    modelId: target.modelId,
+                    ok: false,
+                    latencyMs: 0,
+                    errorMessage: "Skipped because provider cost exceeds the configured budget."
+                });
+                continue;
+            }
+            for (let retry = 0; retry <= maxRetries; retry += 1) {
+                const attemptStartedAt = Date.now();
                 try {
+                    await config.onAttempt?.({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: true,
+                        latencyMs: 0,
+                        retry,
+                        targetRank: targetIndex
+                    });
+                    const streamResult = operation(adapter, target);
                     const iterator = streamResult.eventStream[Symbol.asyncIterator]();
-                    const first = await iterator.next();
+                    const first = await withTimeout(iterator.next(), getAttemptTimeoutMs(config, target.provider));
                     if (!first.done && first.value.type === "error") {
-                        await streamResult.collect().catch(() => undefined);
                         throw first.value.error;
                     }
-                    return withFirstEventReplay(streamResult, first, iterator);
+                    attempts.push({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: true,
+                        latencyMs: Date.now() - attemptStartedAt
+                    });
+                    return {
+                        attempts,
+                        target,
+                        startedAt,
+                        routeDecision,
+                        streamResult
+                    };
                 }
                 catch (error) {
-                    await streamResult.collect().catch(() => undefined);
-                    throw error;
+                    const normalized = normalizeError(error);
+                    attempts.push({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: false,
+                        latencyMs: Date.now() - attemptStartedAt,
+                        errorMessage: normalized.message
+                    });
+                    await config.onAttempt?.({
+                        provider: target.provider,
+                        modelId: target.modelId,
+                        ok: false,
+                        latencyMs: Date.now() - attemptStartedAt,
+                        errorMessage: normalized.message,
+                        retry,
+                        targetRank: targetIndex
+                    });
+                    if (retry < maxRetries && normalized.retryable) {
+                        await sleep(retryBackoffMs(config, retry));
+                        continue;
+                    }
+                    break;
                 }
             }
-        });
-        return {
-            ...executed,
-            startedAt,
-            routeDecision
-        };
+        }
+        const finalError = attempts.at(-1)?.errorMessage ?? "All gateway attempts failed.";
+        throw new GatewayError(finalError, false);
     };
     return {
-        async resolveModel(request) {
-            const routeDecision = await planRoute(request);
-            const target = routeDecision.orderedTargets[0];
-            if (!target) {
-                throw new GatewayError("No available gateway targets matched the request.", false);
-            }
-            const adapter = getAdapter(target.provider);
-            if (!adapter) {
-                throw new GatewayError(`No adapter registered for provider "${target.provider}".`, false);
-            }
-            if (request.stepType === "grounded") {
-                const groundedModel = adapter.groundedLanguageModel?.(target.modelId);
-                if (!groundedModel) {
-                    throw new GatewayError(`Provider "${target.provider}" does not expose grounded models.`, false);
-                }
-                return {
-                    target,
-                    routeDecision,
-                    model: groundedModel,
-                    kind: "grounded"
-                };
-            }
-            return {
-                target,
-                routeDecision,
-                model: adapter.languageModel(target.modelId),
-                kind: "language"
-            };
-        },
         async generate(request) {
             const routed = await runGenerate(request, (adapter, target) => generateText(createTextOptions(adapter, target, request)));
-            return enrichTextResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, routed.result, now());
+            return enrichTextResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, routed.result);
         },
         streamText(request) {
             const selected = runStream(request, (adapter, target) => streamText(createTextOptions(adapter, target, request)));
@@ -220,21 +432,21 @@ export const createGateway = (config) => {
             const ensureRelay = async () => {
                 if (!relayPromise) {
                     relayPromise = selected.then((routed) => ({
-                        collect: async () => enrichTextResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, await routed.result.collect(), now())
+                        collect: async () => enrichTextResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, await routed.streamResult.collect())
                     }));
                 }
                 return relayPromise;
             };
             return {
                 eventStream: (async function* () {
-                    const { result } = await selected;
-                    for await (const event of result.eventStream) {
+                    const { streamResult } = await selected;
+                    for await (const event of streamResult.eventStream) {
                         yield event;
                     }
                 })(),
                 textStream: (async function* () {
-                    const { result } = await selected;
-                    for await (const chunk of result.textStream) {
+                    const { streamResult } = await selected;
+                    for await (const chunk of streamResult.textStream) {
                         yield chunk;
                     }
                 })(),
@@ -248,8 +460,8 @@ export const createGateway = (config) => {
                 mode: request.mode,
                 schemaName: request.schemaName,
                 schemaDescription: request.schemaDescription
-            }), { structuredOutput: request.mode === "native" ? true : undefined });
-            return enrichObjectResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, routed.result, now());
+            }));
+            return enrichObjectResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, routed.result);
         },
         streamObject(request) {
             const selected = runStream(request, (adapter, target) => streamObject({
@@ -258,21 +470,21 @@ export const createGateway = (config) => {
                 mode: request.mode,
                 schemaName: request.schemaName,
                 schemaDescription: request.schemaDescription
-            }), { structuredOutput: request.mode === "native" ? true : undefined });
+            }));
             let relayPromise;
             const ensureRelay = async () => {
                 if (!relayPromise) {
                     relayPromise = selected.then((routed) => ({
-                        streamResult: routed.result,
-                        collect: async () => enrichObjectResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, await routed.result.collect(), now())
+                        streamResult: routed.streamResult,
+                        collect: async () => enrichObjectResult(request, routed.target, routed.attempts, routed.routeDecision, routed.startedAt, await routed.streamResult.collect())
                     }));
                 }
                 return relayPromise;
             };
             return {
                 eventStream: (async function* () {
-                    const { result } = await selected;
-                    for await (const event of result.eventStream) {
+                    const { streamResult } = await selected;
+                    for await (const event of streamResult.eventStream) {
                         yield event;
                     }
                 })(),
@@ -290,6 +502,82 @@ export const createGateway = (config) => {
                 })(),
                 collect: async () => (await ensureRelay()).collect()
             };
+        },
+        async runAgent(request) {
+            const selection = await selectAgentTarget(request);
+            const adapter = getAdapter(selection.target.provider);
+            const model = adapter.languageModel(selection.target.modelId);
+            const agent = createAgent({
+                id: request.agentId,
+                model,
+                instructions: request.instructions,
+                tools: request.tools,
+                maxSteps: request.maxSteps,
+                temperature: request.temperature,
+                maxTokens: request.maxTokens,
+                reasoning: request.reasoning,
+                toolExecution: request.toolExecution,
+                providerOptions: request.providerOptions,
+                metadata: request.metadata,
+                store: request.store,
+                memory: request.memory,
+                onTelemetryEvent: request.onTelemetryEvent
+            });
+            const result = await runAgent(agent, {
+                ...createAgentRunInput(request, selection.target)
+            });
+            return enrichAgentResult(selection.target, selection.attempts, selection.routeDecision, selection.startedAt, result);
+        },
+        streamAgent(request) {
+            const selection = selectAgentTarget(request);
+            let relayPromise;
+            const ensureRelay = async () => {
+                if (!relayPromise) {
+                    relayPromise = selection.then(async (selected) => {
+                        const adapter = getAdapter(selected.target.provider);
+                        const model = adapter.languageModel(selected.target.modelId);
+                        const agent = createAgent({
+                            id: request.agentId,
+                            model,
+                            instructions: request.instructions,
+                            tools: request.tools,
+                            maxSteps: request.maxSteps,
+                            temperature: request.temperature,
+                            maxTokens: request.maxTokens,
+                            reasoning: request.reasoning,
+                            toolExecution: request.toolExecution,
+                            providerOptions: request.providerOptions,
+                            metadata: request.metadata,
+                            store: request.store,
+                            memory: request.memory,
+                            onTelemetryEvent: request.onTelemetryEvent
+                        });
+                        const streamResult = streamAgent(agent, {
+                            ...createAgentRunInput(request, selected.target)
+                        });
+                        return {
+                            streamResult,
+                            collect: async () => enrichAgentResult(selected.target, selected.attempts, selected.routeDecision, selected.startedAt, await streamResult.collect())
+                        };
+                    });
+                }
+                return relayPromise;
+            };
+            return {
+                eventStream: (async function* () {
+                    const relay = await ensureRelay();
+                    for await (const event of relay.streamResult.eventStream) {
+                        yield event;
+                    }
+                })(),
+                textStream: (async function* () {
+                    const relay = await ensureRelay();
+                    for await (const chunk of relay.streamResult.textStream) {
+                        yield chunk;
+                    }
+                })(),
+                collect: async () => (await ensureRelay()).collect()
+            };
         }
     };
 };