@openclaw/amazon-bedrock-provider 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -1,317 +0,0 @@
-import { NumericValue } from "@smithy/core/serde";
-import { alloc, extendedFloat16, extendedFloat32, extendedFloat64, majorList, majorMap, majorNegativeInt64, majorSpecial, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, specialFalse, specialNull, specialTrue, tagSymbol, } from "./cbor-types";
-const USE_BUFFER = typeof Buffer !== "undefined";
-const encodeStringCache = new Map();
-let encodeCacheEpoch = 0;
-let encodeCacheSaturated = false;
-const initialSize = 2048;
-let data = alloc(initialSize);
-let dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-let cursor = 0;
-export function encode(_input) {
-    const encodeStack = [_input];
-    while (encodeStack.length) {
-        const input = encodeStack.pop();
-        if (typeof input === "string") {
-            const len = input.length;
-            if (USE_BUFFER) {
-                ensureSpace(len * 3 + 9);
-                if (len > 23) {
-                    encodeHeader(majorUtf8String, Buffer.byteLength(input));
-                    cursor += data.write(input, cursor);
-                }
-                else {
-                    encodeStringCached(input);
-                }
-            }
-            else {
-                const maxBytes = len * 3;
-                ensureSpace(maxBytes + 9);
-                const headerPos = cursor;
-                const result = new TextEncoder().encodeInto(input, data.subarray(cursor + 9));
-                const byteLen = result.written;
-                let headerSize;
-                if (byteLen < 24) {
-                    headerSize = 1;
-                }
-                else if (byteLen < 256) {
-                    headerSize = 2;
-                }
-                else if (byteLen < 65536) {
-                    headerSize = 3;
-                }
-                else if (byteLen < 4294967296) {
-                    headerSize = 5;
-                }
-                else {
-                    headerSize = 9;
-                }
-                if (headerSize < 9) {
-                    data.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
-                }
-                cursor = headerPos;
-                encodeInteger(majorUtf8String, byteLen);
-                cursor += byteLen;
-            }
-            continue;
-        }
-        if (data.byteLength - cursor < 9) {
-            ensureSpace(64);
-        }
-        if (typeof input === "number") {
-            if (Number.isInteger(input) && input >= -0x20000000000000 && input <= 0x1fffffffffffff) {
-                const nonNegative = input >= 0;
-                const major = nonNegative ? majorUint64 : majorNegativeInt64;
-                const value = nonNegative ? input : -input - 1;
-                if (value < 24) {
-                    data[cursor++] = (major << 5) | value;
-                }
-                else if (value < 256) {
-                    data[cursor++] = (major << 5) | 24;
-                    data[cursor++] = value;
-                }
-                else if (value < 65536) {
-                    data[cursor++] = (major << 5) | extendedFloat16;
-                    data[cursor++] = value >> 8;
-                    data[cursor++] = value & 0xff;
-                }
-                else if (value < 4294967296) {
-                    data[cursor++] = (major << 5) | extendedFloat32;
-                    dataView.setUint32(cursor, value);
-                    cursor += 4;
-                }
-                else {
-                    data[cursor++] = (major << 5) | extendedFloat64;
-                    const hi = (value / 4294967296) | 0;
-                    const lo = (value - hi * 4294967296) | 0;
-                    dataView.setUint32(cursor, hi);
-                    dataView.setUint32(cursor + 4, lo);
-                    cursor += 8;
-                }
-                continue;
-            }
-            data[cursor++] = (majorSpecial << 5) | extendedFloat64;
-            dataView.setFloat64(cursor, input);
-            cursor += 8;
-            continue;
-        }
-        else if (typeof input === "bigint") {
-            const nonNegative = input >= 0;
-            const major = nonNegative ? majorUint64 : majorNegativeInt64;
-            const value = nonNegative ? input : -input - BigInt(1);
-            if (value < BigInt("18446744073709551616")) {
-                const n = Number(value);
-                if (n < 4294967296) {
-                    encodeInteger(major, n);
-                }
-                else {
-                    data[cursor++] = (major << 5) | extendedFloat64;
-                    dataView.setBigUint64(cursor, value);
-                    cursor += 8;
-                }
-            }
-            else {
-                const binaryBigInt = value.toString(2);
-                const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8));
-                let b = value;
-                let i = 0;
-                while (bigIntBytes.byteLength - ++i >= 0) {
-                    bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
-                    b >>= BigInt(8);
-                }
-                ensureSpace(bigIntBytes.byteLength * 2 + 16);
-                data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
-                encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
-                data.set(bigIntBytes, cursor);
-                cursor += bigIntBytes.byteLength;
-            }
-            continue;
-        }
-        else if (input === null) {
-            data[cursor++] = (majorSpecial << 5) | specialNull;
-            continue;
-        }
-        else if (typeof input === "boolean") {
-            data[cursor++] = (majorSpecial << 5) | (input ? specialTrue : specialFalse);
-            continue;
-        }
-        else if (typeof input === "undefined") {
-            throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
-        }
-        else if (Array.isArray(input)) {
-            encodeInteger(majorList, input.length);
-            ensureSpace(input.length * 9 + 64);
-            for (let i = input.length - 1; i >= 0; --i) {
-                encodeStack.push(input[i]);
-            }
-            continue;
-        }
-        else if (typeof input.byteLength === "number") {
-            ensureSpace(input.length * 2 + 9);
-            encodeInteger(majorUnstructuredByteString, input.length);
-            data.set(input, cursor);
-            cursor += input.byteLength;
-            continue;
-        }
-        else if (typeof input === "object") {
-            if (input instanceof NumericValue) {
-                let str = input.string;
-                let expOffset = BigInt(0);
-                const eIndex = str.search(/[eE]/);
-                if (eIndex !== -1) {
-                    expOffset = BigInt(str.slice(eIndex + 1));
-                    str = str.slice(0, eIndex);
-                }
-                const decimalIndex = str.indexOf(".");
-                const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
-                const exponent = expOffset - BigInt(fractionDigits);
-                const mantissa = BigInt(str.replace(".", ""));
-                data[cursor++] = 0b110_00100;
-                encodeInteger(majorList, 2);
-                encodeStack.push(mantissa);
-                encodeStack.push(exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn ? Number(exponent) : exponent);
-                continue;
-            }
-            if (input[tagSymbol]) {
-                if ("tag" in input && "value" in input) {
-                    encodeStack.push(input.value);
-                    encodeHeader(majorTag, input.tag);
-                    continue;
-                }
-                else {
-                    throw new Error("tag encountered with missing fields, need 'tag' and 'value', found: " + JSON.stringify(input));
-                }
-            }
-            const keys = Object.keys(input);
-            const len = keys.length;
-            encodeInteger(majorMap, len);
-            for (let i = len - 1; i >= 0; --i) {
-                encodeStack.push(input[keys[i]]);
-                encodeStack.push(keys[i]);
-            }
-            continue;
-        }
-        throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
-    }
-}
-export function advanceEncodingEpoch() {
-    encodeCacheEpoch = (encodeCacheEpoch + 1) & 0b1111_1111_1111_1111;
-    encodeCacheSaturated = false;
-}
-export function toUint8Array() {
-    const out = alloc(cursor);
-    out.set(data.subarray(0, cursor), 0);
-    cursor = 0;
-    return out;
-}
-export function resize(size) {
-    const old = data;
-    data = alloc(size);
-    if (old) {
-        if (old.copy) {
-            old.copy(data, 0, 0, old.byteLength);
-        }
-        else {
-            data.set(old, 0);
-        }
-    }
-    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-}
-function encodeStringCached(input) {
-    const cached = encodeStringCache.get(input);
-    if (cached !== undefined) {
-        data.set(cached.bytes, cursor);
-        cursor += cached.bytes.length;
-        cached.epoch = encodeCacheEpoch;
-        return;
-    }
-    const start = cursor;
-    const byteLen = Buffer.byteLength(input);
-    encodeInteger(majorUtf8String, byteLen);
-    cursor += data.write(input, cursor);
-    const bytes = Uint8Array.prototype.slice.call(data, start, cursor);
-    if (encodeStringCache.size >= 2048) {
-        if (encodeCacheSaturated) {
-            return;
-        }
-        let evicted = 0;
-        for (const [key, entry] of encodeStringCache) {
-            if (evicted >= 1024) {
-                break;
-            }
-            if (entry.epoch !== encodeCacheEpoch) {
-                encodeStringCache.delete(key);
-                evicted++;
-            }
-        }
-        if (evicted === 0) {
-            encodeCacheSaturated = true;
-            return;
-        }
-    }
-    if (encodeStringCache.size < 2048) {
-        encodeStringCache.set(input, { epoch: encodeCacheEpoch, bytes });
-    }
-}
-function ensureSpace(bytes) {
-    const remaining = data.byteLength - cursor;
-    if (remaining < bytes) {
-        if (cursor < 16_000_000) {
-            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
-        }
-        else {
-            resize(data.byteLength + bytes + 16_000_000);
-        }
-    }
-}
-function encodeHeader(major, value) {
-    if (value < 24) {
-        data[cursor++] = (major << 5) | value;
-    }
-    else if (value < 256) {
-        data[cursor++] = (major << 5) | 24;
-        data[cursor++] = value;
-    }
-    else if (value < 65536) {
-        data[cursor++] = (major << 5) | extendedFloat16;
-        dataView.setUint16(cursor, value);
-        cursor += 2;
-    }
-    else if (value < 4294967296) {
-        data[cursor++] = (major << 5) | extendedFloat32;
-        dataView.setUint32(cursor, value);
-        cursor += 4;
-    }
-    else {
-        data[cursor++] = (major << 5) | extendedFloat64;
-        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
-        cursor += 8;
-    }
-}
-function encodeInteger(major, value) {
-    if (value < 24) {
-        data[cursor++] = (major << 5) | value;
-    }
-    else if (value < 256) {
-        data[cursor++] = (major << 5) | 24;
-        data[cursor++] = value;
-    }
-    else if (value < 65536) {
-        data[cursor++] = (major << 5) | extendedFloat16;
-        data[cursor++] = value >> 8;
-        data[cursor++] = value & 0xff;
-    }
-    else if (value < 4294967296) {
-        data[cursor++] = (major << 5) | extendedFloat32;
-        dataView.setUint32(cursor, value);
-        cursor += 4;
-    }
-    else {
-        data[cursor++] = (major << 5) | extendedFloat64;
-        const hi = (value / 4294967296) | 0;
-        const lo = (value - hi * 4294967296) | 0;
-        dataView.setUint32(cursor, hi);
-        dataView.setUint32(cursor + 4, lo);
-        cursor += 8;
-    }
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-types.js

@@ -1,25 +0,0 @@
-export const majorUint64 = 0;
-export const majorNegativeInt64 = 1;
-export const majorUnstructuredByteString = 2;
-export const majorUtf8String = 3;
-export const majorList = 4;
-export const majorMap = 5;
-export const majorTag = 6;
-export const majorSpecial = 7;
-export const specialFalse = 20;
-export const specialTrue = 21;
-export const specialNull = 22;
-export const specialUndefined = 23;
-export const extendedOneByte = 24;
-export const extendedFloat16 = 25;
-export const extendedFloat32 = 26;
-export const extendedFloat64 = 27;
-export const minorIndefinite = 31;
-export function alloc(size) {
-    return typeof Buffer !== "undefined" ? Buffer.alloc(size) : new Uint8Array(size);
-}
-export const tagSymbol = Symbol("@smithy/core/cbor::tagSymbol");
-export function tag(data) {
-    data[tagSymbol] = true;
-    return data;
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/cbor/cbor.js

@@ -1,23 +0,0 @@
-import { advanceDecodingEpoch, decode, setPayload } from "./cbor-decode";
-import { advanceEncodingEpoch, encode, resize, toUint8Array } from "./cbor-encode";
-export const cbor = {
-    deserialize(payload) {
-        advanceDecodingEpoch();
-        setPayload(payload);
-        return decode(0, payload.length);
-    },
-    serialize(input) {
-        advanceEncodingEpoch();
-        try {
-            encode(input);
-            return toUint8Array();
-        }
-        catch (e) {
-            toUint8Array();
-            throw e;
-        }
-    },
-    resizeEncodingBuffer(size) {
-        resize(size);
-    },
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/cbor/codec-v1/CborShapeDeserializer.js

@@ -1,122 +0,0 @@
-import { hasOwn } from "@smithy/core/transport";
-import { SerdeContext } from "@smithy/core/protocols";
-import { NormalizedSchema } from "@smithy/core/schema";
-import { NumericValue, _parseEpochTimestamp, fromBase64 } from "@smithy/core/serde";
-import { cbor } from "../cbor";
-export class CborShapeDeserializer extends SerdeContext {
-    read(schema, bytes) {
-        const data = cbor.deserialize(bytes);
-        return this.readValue(schema, data);
-    }
-    readValue(_schema, value) {
-        const ns = NormalizedSchema.of(_schema);
-        if (ns.isTimestampSchema()) {
-            if (typeof value === "number") {
-                return _parseEpochTimestamp(value);
-            }
-            if (typeof value === "object") {
-                if (value.tag === 1 && "value" in value) {
-                    return _parseEpochTimestamp(value.value);
-                }
-            }
-        }
-        if (ns.isBlobSchema()) {
-            if (typeof value === "string") {
-                return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
-            }
-            return value;
-        }
-        if (typeof value === "undefined" ||
-            typeof value === "boolean" ||
-            typeof value === "number" ||
-            typeof value === "string" ||
-            typeof value === "bigint" ||
-            typeof value === "symbol") {
-            return value;
-        }
-        else if (typeof value === "object") {
-            if (value === null) {
-                return null;
-            }
-            if ("byteLength" in value) {
-                return value;
-            }
-            if (value instanceof Date) {
-                return value;
-            }
-            if (ns.isDocumentSchema()) {
-                return value;
-            }
-            if (ns.isListSchema()) {
-                const newArray = [];
-                const memberSchema = ns.getValueSchema();
-                for (const item of value) {
-                    const itemValue = this.readValue(memberSchema, item);
-                    newArray.push(itemValue);
-                }
-                return newArray;
-            }
-            const newObject = {};
-            if (ns.isMapSchema()) {
-                const targetSchema = ns.getValueSchema();
-                for (const key in value) {
-                    if (!hasOwn(value, key))
-                        continue;
-                    const itemValue = this.readValue(targetSchema, value[key]);
-                    newObject[key] = itemValue;
-                }
-            }
-            else if (ns.isStructSchema()) {
-                const isUnion = ns.isUnionSchema();
-                let keys;
-                if (isUnion) {
-                    keys = new Set();
-                    for (const k in value) {
-                        if (!hasOwn(value, k))
-                            continue;
-                        if (k !== "__type") {
-                            keys.add(k);
-                        }
-                    }
-                }
-                for (const [key, memberSchema] of ns.structIterator()) {
-                    if (isUnion) {
-                        keys.delete(key);
-                    }
-                    if (value[key] != null) {
-                        newObject[key] = this.readValue(memberSchema, value[key]);
-                    }
-                }
-                if (isUnion && keys?.size === 1) {
-                    let newObjectEmpty = true;
-                    for (const _ in newObject) {
-                        if (!hasOwn(newObject, _))
-                            continue;
-                        newObjectEmpty = false;
-                        break;
-                    }
-                    if (newObjectEmpty) {
-                        const k = keys.values().next().value;
-                        newObject.$unknown = [k, value[k]];
-                    }
-                }
-                else if (typeof value.__type === "string") {
-                    for (const k in value) {
-                        if (!hasOwn(value, k))
-                            continue;
-                        if (!(k in newObject)) {
-                            newObject[k] = value[k];
-                        }
-                    }
-                }
-            }
-            else if (value instanceof NumericValue) {
-                return value;
-            }
-            return newObject;
-        }
-        else {
-            return value;
-        }
-    }
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/cbor/codec-v1/CborShapeSerializer.js

@@ -1,110 +0,0 @@
-import { hasOwn } from "@smithy/core/transport";
-import { SerdeContext } from "@smithy/core/protocols";
-import { NormalizedSchema } from "@smithy/core/schema";
-import { fromBase64, generateIdempotencyToken } from "@smithy/core/serde";
-import { cbor } from "../cbor";
-import { dateToTag } from "../parseCborBody";
-export class CborShapeSerializer extends SerdeContext {
-    value;
-    write(schema, value) {
-        this.value = this.serialize(schema, value);
-    }
-    serialize(schema, source) {
-        const ns = NormalizedSchema.of(schema);
-        if (source == null) {
-            if (ns.isIdempotencyToken()) {
-                return generateIdempotencyToken();
-            }
-            return source;
-        }
-        if (ns.isBlobSchema()) {
-            if (typeof source === "string") {
-                return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
-            }
-            return source;
-        }
-        if (ns.isTimestampSchema()) {
-            if (typeof source === "number" || typeof source === "bigint") {
-                return dateToTag(new Date((Number(source) / 1000) | 0));
-            }
-            return dateToTag(source);
-        }
-        if (typeof source === "function" || typeof source === "object") {
-            const sourceObject = source;
-            if (ns.isListSchema() && Array.isArray(sourceObject)) {
-                const sparse = !!ns.getMergedTraits().sparse;
-                const newArray = [];
-                let i = 0;
-                for (const item of sourceObject) {
-                    const value = this.serialize(ns.getValueSchema(), item);
-                    if (value != null || sparse) {
-                        newArray[i++] = value;
-                    }
-                }
-                return newArray;
-            }
-            if (sourceObject instanceof Date) {
-                return dateToTag(sourceObject);
-            }
-            const newObject = {};
-            if (ns.isMapSchema()) {
-                const sparse = !!ns.getMergedTraits().sparse;
-                for (const key in sourceObject) {
-                    if (!hasOwn(sourceObject, key))
-                        continue;
-                    const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
-                    if (value != null || sparse) {
-                        newObject[key] = value;
-                    }
-                }
-            }
-            else if (ns.isStructSchema()) {
-                for (const [key, memberSchema] of ns.structIterator()) {
-                    const value = this.serialize(memberSchema, sourceObject[key]);
-                    if (value != null) {
-                        newObject[key] = value;
-                    }
-                }
-                const isUnion = ns.isUnionSchema();
-                if (isUnion && Array.isArray(sourceObject.$unknown)) {
-                    const [k, v] = sourceObject.$unknown;
-                    newObject[k] = v;
-                }
-                else if (typeof sourceObject.__type === "string") {
-                    for (const k in sourceObject) {
-                        if (!hasOwn(sourceObject, k))
-                            continue;
-                        if (!(k in newObject)) {
-                            newObject[k] = this.serialize(15, sourceObject[k]);
-                        }
-                    }
-                }
-            }
-            else if (ns.isDocumentSchema()) {
-                if (Array.isArray(sourceObject)) {
-                    const newArray = [];
-                    let i = 0;
-                    for (const item of sourceObject) {
-                        newArray[i++] = this.serialize(ns.getValueSchema(), item);
-                    }
-                    return newArray;
-                }
-                for (const key in sourceObject) {
-                    if (!hasOwn(sourceObject, key))
-                        continue;
-                    newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
-                }
-            }
-            else if (ns.isBigDecimalSchema()) {
-                return sourceObject;
-            }
-            return newObject;
-        }
-        return source;
-    }
-    flush() {
-        const buffer = cbor.serialize(this.value);
-        this.value = undefined;
-        return buffer;
-    }
-}