@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/providers/amazonBedrock/constants.d.ts

@@ -1 +0,0 @@
-export declare const bedrockTracer: import("@opentelemetry/api").Tracer;

package/dist/lib/providers/amazonBedrock/constants.js

@@ -1,3 +0,0 @@
-import { tracers } from "../../telemetry/index.js";
-export const bedrockTracer = tracers.provider;
-//# sourceMappingURL=constants.js.map

package/dist/lib/providers/amazonBedrock/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./client.js";
-export * from "./constants.js";
-export * from "./utils.js";

package/dist/lib/providers/amazonBedrock/index.js

@@ -1,4 +0,0 @@
-export * from "./client.js";
-export * from "./constants.js";
-export * from "./utils.js";
-//# sourceMappingURL=index.js.map

package/dist/lib/providers/amazonBedrock/inferenceProfile.d.ts

@@ -1,72 +0,0 @@
-/**
- * Bedrock cross-region inference profile resolution.
- *
- * Most current Bedrock models cannot be invoked by their bare model id. Each
- * model card carries a Regional Availability table with three columns, and for
- * a great many model/region pairs the In-Region column is "No" — Claude Opus
- * 4.5 is No in every region AWS lists, Sonnet 4.6 is Yes only in eu-west-2.
- * Those models are reachable only through a cross-region inference profile: the
- * same id with a geography prefix (`us.`, `eu.`, `au.`, `jp.`, `apac.`) or the
- * worldwide `global.` prefix.
- *
- * Sending the bare id where In-Region is No fails with a ValidationException
- * telling you to use an inference profile. This module detects that specific
- * failure and works out which prefixed id to retry with.
- *
- * ## Why prefixes are derived rather than tabulated
- *
- * The obvious implementation — a table of model to supported prefixes — is the
- * one to avoid. The prefix set is per-model, not per-region: from the same
- * caller region `ap-northeast-1`, Claude Opus 4.5 accepts only `global.`,
- * Sonnet 4.5 also accepts `jp.`, and Haiku 4.5 works bare. A static table
- * would need a row per model per region and would be wrong the day a model
- * ships. AWS itself moved this data out of a central page and onto each
- * model's detail page for the same reason.
- *
- * So resolution is empirical: on the specific error, try the geography that
- * covers the caller's region, then `global.`, and remember what worked.
- *
- * `bedrock:ListInferenceProfiles` would give an authoritative answer, but it
- * is a control-plane call needing a separate SDK client and an IAM permission
- * a caller with plain inference access will not necessarily hold. Deriving
- * candidates needs neither, and costs at most two extra attempts once per
- * model/region pair.
- */
-/**
- * Does this error mean "this model needs an inference profile in this region"?
- *
- * Deliberately narrow. A ValidationException covers many unrelated causes —
- * a malformed body, an unknown parameter, a model the account has no access to
- * — and retrying those with a different model id would turn one clear failure
- * into two confusing ones. Both the exception name and the distinctive phrase
- * must match.
- *
- * The phrase is matched loosely enough to survive AWS rewording the sentence
- * around it, and the retry is a no-op when nothing resolves, so a miss here
- * costs nothing beyond the original error surfacing unchanged — which is the
- * behaviour without this module at all.
- */
-export declare function isInferenceProfileRequiredError(error: unknown): boolean;
-/**
- * Candidate ids to retry, most specific first: the caller's own geography,
- * then worldwide.
- *
- * Returns an empty array when the id already carries a prefix — a prefixed id
- * that still fails is a real error, not something to re-prefix.
- */
-export declare function inferenceProfileCandidates(modelId: string, region: string): string[];
-/** The id that previously worked for this model in this region, if any. */
-export declare function getResolvedModelId(modelId: string, region: string): string | undefined;
-export declare function rememberResolvedModelId(modelId: string, region: string, resolvedId: string): void;
-/** Exposed so tests can start from a known state. */
-export declare function clearResolvedModelIds(): void;
-/**
- * Run `send` against the given model id, falling back to inference-profile
- * ids if — and only if — Bedrock says the bare id needs one.
- *
- * A previously resolved id is used straight away. Any error other than the
- * inference-profile one propagates untouched on the first attempt, so this
- * cannot mask an unrelated failure or silently change behaviour for a caller
- * whose bare ids already work.
- */
-export declare function withInferenceProfileFallback<T>(modelId: string, region: string, send: (effectiveModelId: string) => Promise<T>): Promise<T>;

package/dist/lib/providers/amazonBedrock/inferenceProfile.js

@@ -1,186 +0,0 @@
-/**
- * Bedrock cross-region inference profile resolution.
- *
- * Most current Bedrock models cannot be invoked by their bare model id. Each
- * model card carries a Regional Availability table with three columns, and for
- * a great many model/region pairs the In-Region column is "No" — Claude Opus
- * 4.5 is No in every region AWS lists, Sonnet 4.6 is Yes only in eu-west-2.
- * Those models are reachable only through a cross-region inference profile: the
- * same id with a geography prefix (`us.`, `eu.`, `au.`, `jp.`, `apac.`) or the
- * worldwide `global.` prefix.
- *
- * Sending the bare id where In-Region is No fails with a ValidationException
- * telling you to use an inference profile. This module detects that specific
- * failure and works out which prefixed id to retry with.
- *
- * ## Why prefixes are derived rather than tabulated
- *
- * The obvious implementation — a table of model to supported prefixes — is the
- * one to avoid. The prefix set is per-model, not per-region: from the same
- * caller region `ap-northeast-1`, Claude Opus 4.5 accepts only `global.`,
- * Sonnet 4.5 also accepts `jp.`, and Haiku 4.5 works bare. A static table
- * would need a row per model per region and would be wrong the day a model
- * ships. AWS itself moved this data out of a central page and onto each
- * model's detail page for the same reason.
- *
- * So resolution is empirical: on the specific error, try the geography that
- * covers the caller's region, then `global.`, and remember what worked.
- *
- * `bedrock:ListInferenceProfiles` would give an authoritative answer, but it
- * is a control-plane call needing a separate SDK client and an IAM permission
- * a caller with plain inference access will not necessarily hold. Deriving
- * candidates needs neither, and costs at most two extra attempts once per
- * model/region pair.
- */
-import { logger } from "../../utils/logger.js";
-/**
- * Geography prefixes, in the order AWS documents them. `global.` is not a
- * geography — it routes anywhere and is tried last, as the broadest option.
- */
-const GLOBAL_PREFIX = "global";
-/**
- * Maps an AWS region to the geography whose inference profile covers it.
- *
- * Derived from the Geo inference tables on the model cards: the US geography
- * covers `us-*` plus the Canadian regions, EU covers `eu-*` plus Israel, the
- * Middle East and Africa, Japan covers the two Japanese regions, and Australia
- * covers Sydney, Melbourne and New Zealand. Everything else in Asia Pacific
- * falls under `apac`.
- */
-function geoPrefixForRegion(region) {
-    if (/^(us|ca)-/.test(region)) {
-        return "us";
-    }
-    if (/^(eu|il|me|af)-/.test(region)) {
-        return "eu";
-    }
-    if (/^ap-northeast-[13]$/.test(region)) {
-        return "jp";
-    }
-    if (/^ap-southeast-[246]$/.test(region)) {
-        return "au";
-    }
-    if (/^ap-/.test(region)) {
-        return "apac";
-    }
-    return undefined;
-}
-/** True when `modelId` already carries a geography or global prefix. */
-function hasProfilePrefix(modelId) {
-    return /^(us|eu|au|jp|apac|global)\./.test(modelId);
-}
-/**
- * Does this error mean "this model needs an inference profile in this region"?
- *
- * Deliberately narrow. A ValidationException covers many unrelated causes —
- * a malformed body, an unknown parameter, a model the account has no access to
- * — and retrying those with a different model id would turn one clear failure
- * into two confusing ones. Both the exception name and the distinctive phrase
- * must match.
- *
- * The phrase is matched loosely enough to survive AWS rewording the sentence
- * around it, and the retry is a no-op when nothing resolves, so a miss here
- * costs nothing beyond the original error surfacing unchanged — which is the
- * behaviour without this module at all.
- */
-export function isInferenceProfileRequiredError(error) {
-    if (typeof error !== "object" || error === null) {
-        return false;
-    }
-    const candidate = error;
-    const name = typeof candidate.name === "string" ? candidate.name : "";
-    const message = typeof candidate.message === "string" ? candidate.message : "";
-    if (!/ValidationException/i.test(name) &&
-        !/ValidationException/i.test(message)) {
-        return false;
-    }
-    return (/inference profile/i.test(message) && /on-demand throughput/i.test(message));
-}
-/**
- * Candidate ids to retry, most specific first: the caller's own geography,
- * then worldwide.
- *
- * Returns an empty array when the id already carries a prefix — a prefixed id
- * that still fails is a real error, not something to re-prefix.
- */
-export function inferenceProfileCandidates(modelId, region) {
-    // An ARN already names a concrete model or inference-profile resource, and
-    // this provider accepts one as a model id (see `extractRegionFromArn`).
-    // Prefixing it yields a malformed identifier whose ValidationException would
-    // then replace the original, accurate error.
-    if (modelId.startsWith("arn:") || hasProfilePrefix(modelId)) {
-        return [];
-    }
-    const candidates = [];
-    const geo = geoPrefixForRegion(region);
-    if (geo) {
-        candidates.push(`${geo}.${modelId}`);
-    }
-    candidates.push(`${GLOBAL_PREFIX}.${modelId}`);
-    return candidates;
-}
-/**
- * Remembers which id actually worked, keyed by region and bare model id, so
- * the probing happens once rather than on every call.
- */
-const resolved = new Map();
-function cacheKey(region, modelId) {
-    return `${region}::${modelId}`;
-}
-/** The id that previously worked for this model in this region, if any. */
-export function getResolvedModelId(modelId, region) {
-    return resolved.get(cacheKey(region, modelId));
-}
-export function rememberResolvedModelId(modelId, region, resolvedId) {
-    resolved.set(cacheKey(region, modelId), resolvedId);
-    logger.debug("[Bedrock] Cached inference-profile resolution for subsequent calls", { region });
-}
-/** Exposed so tests can start from a known state. */
-export function clearResolvedModelIds() {
-    resolved.clear();
-}
-/**
- * Run `send` against the given model id, falling back to inference-profile
- * ids if — and only if — Bedrock says the bare id needs one.
- *
- * A previously resolved id is used straight away. Any error other than the
- * inference-profile one propagates untouched on the first attempt, so this
- * cannot mask an unrelated failure or silently change behaviour for a caller
- * whose bare ids already work.
- */
-export async function withInferenceProfileFallback(modelId, region, send) {
-    const cached = getResolvedModelId(modelId, region);
-    if (cached && cached !== modelId) {
-        return send(cached);
-    }
-    try {
-        return await send(modelId);
-    }
-    catch (error) {
-        if (!isInferenceProfileRequiredError(error)) {
-            throw error;
-        }
-        const candidates = inferenceProfileCandidates(modelId, region);
-        if (candidates.length === 0) {
-            throw error;
-        }
-        logger.warn("[Bedrock] Model requires a cross-region inference profile in this region; retrying with a prefixed id", { region, candidates: candidates.length });
-        for (const candidate of candidates) {
-            try {
-                const result = await send(candidate);
-                rememberResolvedModelId(modelId, region, candidate);
-                return result;
-            }
-            catch (retryError) {
-                if (!isInferenceProfileRequiredError(retryError)) {
-                    // A different failure against the prefixed id — for example the
-                    // account lacking access to that geography — is the more
-                    // informative error, so surface it rather than the original.
-                    throw retryError;
-                }
-            }
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=inferenceProfile.js.map

package/dist/lib/providers/amazonBedrock/loopAdapter.d.ts

@@ -1,36 +0,0 @@
-/**
- * Bedrock's adapter onto the shared agentic loop engine.
- *
- * Bedrock had two hand-rolled turn loops — one for `Converse`, one for
- * `ConverseStream` — that between them duplicated the same content-block
- * accumulation three times. Everything here is the wire-format half of that:
- * issuing the right command, folding a response into blocks, serializing tool
- * results back into the conversation, and mapping the stop reason. The turn
- * loop itself, the step cap, tool dispatch and usage accumulation belong to
- * `runAgenticLoop`.
- *
- * One adapter covers both operations because the two differ only in how a
- * step's content blocks arrive: `ConverseStream` delivers them as events that
- * are pushed to the consumer as they land, `Converse` returns them whole.
- * Block accumulation, tool-call extraction and the conversation shape are
- * identical, and were identical in the hand-rolled loops too — which is why
- * they drifted apart in the details.
- */
-import type { ConverseCommandInput, ConverseStreamCommandInput } from "@aws-sdk/client-bedrock-runtime";
-import { type BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
-import type { AgenticLoopAdapter, BedrockContentBlock, BedrockMessage } from "../../types/index.js";
-export declare function createBedrockLoopAdapter(config: {
-    client: BedrockRuntimeClient;
-    /** `ConverseStream` when true, `Converse` when false. */
-    streaming: boolean;
-    /** The region the client was constructed with, for profile resolution. */
-    region: string;
-    maxSteps: number;
-    /**
-     * Build the request for one step. Synchronous by contract, so anything
-     * async (tool declarations in particular) is resolved once before the turn
-     * starts rather than per step. Bedrock has no mid-turn tool discovery, so
-     * there is nothing that would need re-resolving.
-     */
-    buildCommandInput: (conversation: BedrockMessage[], step: number) => ConverseCommandInput & ConverseStreamCommandInput;
-}): AgenticLoopAdapter<BedrockMessage[], BedrockContentBlock[]>;

package/dist/lib/providers/amazonBedrock/loopAdapter.js

@@ -1,278 +0,0 @@
-/**
- * Bedrock's adapter onto the shared agentic loop engine.
- *
- * Bedrock had two hand-rolled turn loops — one for `Converse`, one for
- * `ConverseStream` — that between them duplicated the same content-block
- * accumulation three times. Everything here is the wire-format half of that:
- * issuing the right command, folding a response into blocks, serializing tool
- * results back into the conversation, and mapping the stop reason. The turn
- * loop itself, the step cap, tool dispatch and usage accumulation belong to
- * `runAgenticLoop`.
- *
- * One adapter covers both operations because the two differ only in how a
- * step's content blocks arrive: `ConverseStream` delivers them as events that
- * are pushed to the consumer as they land, `Converse` returns them whole.
- * Block accumulation, tool-call extraction and the conversation shape are
- * identical, and were identical in the hand-rolled loops too — which is why
- * they drifted apart in the details.
- */
-import { ConverseCommand, ConverseStreamCommand, } from "@aws-sdk/client-bedrock-runtime";
-import { withTimeout } from "../../utils/errorHandling.js";
-import { withInferenceProfileFallback } from "./inferenceProfile.js";
-const STEP_TIMEOUT_MS = 120_000;
-function newToolUseId() {
-    return `tool_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-}
-/**
- * Finalize a block once its `contentBlockStop` arrives: parse whatever tool
- * input accumulated, and attach the text a plain block collected.
- *
- * Attaching the text matters beyond this step. `buildToolResultMessages`
- * replays these blocks back to the model as the assistant turn, so a text
- * block left empty here silently drops the assistant's own words from the
- * conversation on every subsequent step of the turn.
- */
-function finalizeBlock(block, text) {
-    if (!block) {
-        return;
-    }
-    if (block.toolUse && block._inputBuffer) {
-        try {
-            block.toolUse.input = JSON.parse(block._inputBuffer);
-        }
-        catch {
-            block.toolUse.input = {};
-        }
-        delete block._inputBuffer;
-    }
-    if (text && !block.toolUse) {
-        block.text = text;
-    }
-}
-function toolCallsFrom(blocks) {
-    return blocks
-        .filter((b) => b.toolUse)
-        .map((b) => ({
-        id: b.toolUse?.toolUseId ?? newToolUseId(),
-        name: b.toolUse?.name ?? "",
-        args: b.toolUse?.input ?? {},
-    }));
-}
-/** Fold a `ConverseStream` event sequence into finished content blocks. */
-async function readStreamedStep(response, channel, signal) {
-    const blocks = [];
-    // Blocks are keyed by the index Bedrock stamps on every event rather than
-    // by arrival order, because a text block does not necessarily announce
-    // itself with `contentBlockStart` — the first thing seen for it can be a
-    // delta. Creating the block on whichever event arrives first is what keeps
-    // assistant text that precedes a tool call from being dropped: `raw` is
-    // replayed as the assistant turn on the next step, so a lost text block
-    // means the model stops seeing its own reasoning mid-turn.
-    const blocksByIndex = new Map();
-    const textByIndex = new Map();
-    const blockFor = (index) => {
-        let block = blocksByIndex.get(index);
-        if (!block) {
-            block = {};
-            blocksByIndex.set(index, block);
-            blocks.push(block);
-        }
-        return block;
-    };
-    let text = "";
-    let rawStopReason;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cacheReadTokens = 0;
-    let cacheWriteTokens = 0;
-    if (response.stream) {
-        for await (const rawChunk of response.stream) {
-            if (signal.aborted) {
-                break;
-            }
-            const chunk = rawChunk;
-            if (chunk.contentBlockStart) {
-                blockFor(chunk.contentBlockStart.contentBlockIndex ?? 0);
-            }
-            if (chunk.contentBlockDelta?.delta?.text) {
-                const index = chunk.contentBlockDelta.contentBlockIndex ?? 0;
-                const delta = chunk.contentBlockDelta.delta.text;
-                blockFor(index);
-                text += delta;
-                textByIndex.set(index, (textByIndex.get(index) ?? "") + delta);
-                channel.push({ content: delta });
-            }
-            if (chunk.contentBlockStart?.start?.toolUse) {
-                const block = blockFor(chunk.contentBlockStart.contentBlockIndex ?? 0);
-                block.toolUse = {
-                    name: chunk.contentBlockStart.start.toolUse.name ?? "",
-                    input: {},
-                    toolUseId: chunk.contentBlockStart.start.toolUse.toolUseId ?? newToolUseId(),
-                };
-            }
-            if (chunk.contentBlockDelta?.delta?.toolUse) {
-                const block = blockFor(chunk.contentBlockDelta.contentBlockIndex ?? 0);
-                block.toolUse ??= {
-                    name: "",
-                    input: {},
-                    toolUseId: newToolUseId(),
-                };
-                const deltaInput = chunk.contentBlockDelta.delta.toolUse.input;
-                if (typeof deltaInput === "string") {
-                    block._inputBuffer = (block._inputBuffer ?? "") + deltaInput;
-                }
-                else if (typeof deltaInput === "object" &&
-                    deltaInput !== null &&
-                    !Array.isArray(deltaInput)) {
-                    block.toolUse.input = {
-                        ...(block.toolUse.input ?? {}),
-                        ...deltaInput,
-                    };
-                }
-            }
-            if (chunk.contentBlockStop) {
-                const index = chunk.contentBlockStop.contentBlockIndex ?? 0;
-                finalizeBlock(blocksByIndex.get(index), textByIndex.get(index) ?? "");
-            }
-            if (chunk.messageStop) {
-                rawStopReason = chunk.messageStop.stopReason ?? "end_turn";
-                // Not a break: the metadata event carrying usage arrives after this.
-                continue;
-            }
-            if (chunk.metadata?.usage) {
-                inputTokens += chunk.metadata.usage.inputTokens ?? 0;
-                outputTokens += chunk.metadata.usage.outputTokens ?? 0;
-                // Converse follows the Anthropic additive convention — inputTokens is
-                // the uncached remainder, so cache reads/writes are counted apart.
-                cacheReadTokens += chunk.metadata.usage.cacheReadInputTokens ?? 0;
-                cacheWriteTokens += chunk.metadata.usage.cacheWriteInputTokens ?? 0;
-                break;
-            }
-        }
-    }
-    // Finalize anything the stream never closed. `contentBlockStop` is not
-    // guaranteed to arrive for every block: an abort breaks the loop, the
-    // metadata event breaks it, and a truncated stream simply ends. A block
-    // left unfinalized keeps `text` undefined and its tool input unparsed, and
-    // since `raw` is replayed as the assistant message — where an unrecognized
-    // block maps to `{ text: "" }`, which Bedrock rejects — that would fail the
-    // NEXT step of the turn rather than this one.
-    for (const [index, block] of blocksByIndex) {
-        finalizeBlock(block, textByIndex.get(index) ?? "");
-    }
-    // A block that opened and then received nothing carries no content at all,
-    // and `convertToAWSMessages` maps an unrecognized block to `{ text: "" }`,
-    // which Bedrock rejects. Drop them rather than replay them.
-    const usableBlocks = blocks.filter((block) => block.text || block.toolUse || block.image || block.document);
-    return {
-        text,
-        toolCalls: toolCallsFrom(usableBlocks),
-        usage: { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens },
-        rawStopReason,
-        raw: usableBlocks,
-    };
-}
-/** Fold a non-streaming `Converse` response into the same block shape. */
-function readGeneratedStep(response) {
-    const blocks = [];
-    let text = "";
-    for (const item of response.output?.message?.content ?? []) {
-        const block = {};
-        if ("text" in item && item.text) {
-            block.text = item.text;
-            text += text ? ` ${item.text}` : item.text;
-        }
-        if ("toolUse" in item && item.toolUse) {
-            block.toolUse = {
-                toolUseId: item.toolUse.toolUseId ?? newToolUseId(),
-                name: item.toolUse.name ?? "",
-                input: item.toolUse.input ?? {},
-            };
-        }
-        blocks.push(block);
-    }
-    return {
-        text,
-        toolCalls: toolCallsFrom(blocks),
-        usage: {
-            inputTokens: response.usage?.inputTokens ?? 0,
-            outputTokens: response.usage?.outputTokens ?? 0,
-            cacheReadTokens: response.usage?.cacheReadInputTokens ?? 0,
-            cacheWriteTokens: response.usage?.cacheWriteInputTokens ?? 0,
-        },
-        rawStopReason: response.stopReason,
-        raw: blocks,
-    };
-}
-export function createBedrockLoopAdapter(config) {
-    return {
-        providerLabel: "bedrock",
-        maxSteps: config.maxSteps,
-        // No toolFailureBreaker: Bedrock has never had strike counting — a failing
-        // tool becomes one error tool-result with no cross-step memory. Preserved.
-        buildStepRequest(conversation, step) {
-            return { raw: config.buildCommandInput(conversation, step) };
-        },
-        async executeStep(request, channel, signal) {
-            const commandInput = request.raw;
-            // Both sends go through the inference-profile fallback: most current
-            // Bedrock models are not invocable by their bare id in a given region
-            // and need a geography- or global-prefixed profile id instead. This is
-            // where the provider's two Converse call sites now live.
-            if (!config.streaming) {
-                const response = await withInferenceProfileFallback(commandInput.modelId ?? "", config.region, (effectiveModelId) => withTimeout(config.client.send(new ConverseCommand({
-                    ...commandInput,
-                    modelId: effectiveModelId,
-                })), STEP_TIMEOUT_MS, new Error("Bedrock API call timed out")));
-                if (!response.output?.message) {
-                    throw new Error("Invalid response structure from Bedrock API");
-                }
-                return readGeneratedStep(response);
-            }
-            const response = await withInferenceProfileFallback(commandInput.modelId ?? "", config.region, (effectiveModelId) => withTimeout(config.client.send(new ConverseStreamCommand({
-                ...commandInput,
-                modelId: effectiveModelId,
-            })), STEP_TIMEOUT_MS, new Error("Bedrock streaming API call timed out")));
-            return readStreamedStep(response, channel, signal);
-        },
-        buildToolResultMessages(conversation, stepResult, toolResults) {
-            const assistantMessage = {
-                role: "assistant",
-                content: stepResult.raw,
-            };
-            const toolResultMessage = {
-                role: "user",
-                content: toolResults.map((result) => ({
-                    toolResult: {
-                        toolUseId: result.id,
-                        content: [
-                            {
-                                text: result.error
-                                    ? `Error executing tool ${result.name}: ${result.error}`
-                                    : String(typeof result.output === "string"
-                                        ? result.output
-                                        : JSON.stringify(result.output)),
-                            },
-                        ],
-                        status: result.error ? "error" : "success",
-                    },
-                })),
-            };
-            return [...conversation, assistantMessage, toolResultMessage];
-        },
-        mapFinishReason(rawStopReason, hadToolCallsAtCap) {
-            switch (rawStopReason) {
-                case "end_turn":
-                case "stop_sequence":
-                    return "stop";
-                case "max_tokens":
-                    return "length";
-                case "tool_use":
-                    return "tool-calls";
-                default:
-                    return hadToolCallsAtCap ? "tool-calls" : "stop";
-            }
-        },
-    };
-}
-//# sourceMappingURL=loopAdapter.js.map

package/dist/lib/providers/amazonBedrock/utils.d.ts

@@ -1 +0,0 @@
-export declare function loadBedrockControl(): Promise<typeof import("@aws-sdk/client-bedrock")>;

package/dist/lib/providers/amazonBedrock/utils.js

@@ -1,4 +0,0 @@
-export async function loadBedrockControl() {
-    return await import(/* @vite-ignore */ "@aws-sdk/client-bedrock");
-}
-//# sourceMappingURL=utils.js.map