@byteplus-iga-pages/agent 0.0.0-stage → 1.0.4

package/dist/cjs/504.js

@@ -0,0 +1,760 @@
+"use strict";
+exports.ids = [
+    "504"
+];
+exports.modules = {
+    "../store/src/credential-error.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            y: ()=>toStoreCredentialError
+        });
+        var _iga_pages_data_plane__rspack_import_0 = __webpack_require__("../data-plane/dist/esm/index.js");
+        var _errors_js__rspack_import_1 = __webpack_require__("../store/src/errors.ts");
+        function toStoreCredentialError(error) {
+            if (error instanceof _errors_js__rspack_import_1.A) return error;
+            const source = error instanceof _iga_pages_data_plane__rspack_import_0.d ? error : void 0;
+            const codes = {
+                authentication_failed: "Unauthorized",
+                timeout: "TimeoutError",
+                aborted: "AbortError",
+                rate_limited: "TooManyRequests",
+                unavailable: "ServiceUnavailable",
+                unknown: "UnknownError"
+            };
+            let type = "unavailable";
+            if (source) {
+                if ("authentication_failed" === source.failureKind || "unauthenticated" === source.code || "permission_denied" === source.code) type = "authentication_failed";
+                else if ("timeout" === source.failureKind) type = "timeout";
+                else if ("aborted" === source.code) type = "aborted";
+                else if ("rate_limited" === source.code) type = "rate_limited";
+                else if ("unavailable" !== source.code) type = "unknown";
+            }
+            const messages = {
+                authentication_failed: "Store authentication failed",
+                timeout: "Store authentication request timed out",
+                aborted: "Store request was cancelled",
+                rate_limited: "Store authentication is receiving too many requests",
+                unavailable: "Store authentication is temporarily unavailable",
+                unknown: "Store returned invalid credentials"
+            };
+            return new _errors_js__rspack_import_1.A(codes[type], messages[type], {
+                status: source?.status,
+                error: null
+            });
+        }
+    },
+    "../store/src/credential-provider.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Up: ()=>StoreCredentialProviderCache,
+            q1: ()=>StoreCredentialProvider
+        });
+        var _iga_pages_data_plane__rspack_import_0 = __webpack_require__("../data-plane/dist/esm/index.js");
+        var _errors_js__rspack_import_1 = __webpack_require__("../store/src/errors.ts");
+        var _credential_error_js__rspack_import_2 = __webpack_require__("../store/src/credential-error.ts");
+        function toDataPlaneError(error) {
+            if (error instanceof _iga_pages_data_plane__rspack_import_0.d) return error;
+            if (error instanceof _errors_js__rspack_import_1.A) return new _iga_pages_data_plane__rspack_import_0.d("Unauthorized" === error.code ? "unauthenticated" : "TooManyRequests" === error.code ? "rate_limited" : "AbortError" === error.code ? "aborted" : "ServiceUnavailable" === error.code || "TimeoutError" === error.code ? "unavailable" : "internal", error.message, {
+                operation: "data-plane.authenticate",
+                status: error.status,
+                ..."TimeoutError" === error.code ? {
+                    failureKind: "timeout"
+                } : {}
+            });
+            return new _iga_pages_data_plane__rspack_import_0.d("unavailable", "Data plane authentication is temporarily unavailable", {
+                operation: "data-plane.authenticate",
+                retryable: true
+            });
+        }
+        class StoreCredentialProvider {
+            async getValidCredentials() {
+                try {
+                    return await this.delegate.getValidCredentials();
+                } catch (error) {
+                    throw (0, _credential_error_js__rspack_import_2.y)(error);
+                }
+            }
+            async getProjectId() {
+                try {
+                    return await this.delegate.getProjectId();
+                } catch (error) {
+                    throw (0, _credential_error_js__rspack_import_2.y)(error);
+                }
+            }
+            invalidate(jwt) {
+                this.delegate.invalidate(jwt);
+            }
+            constructor(options){
+                this.delegate = new _iga_pages_data_plane__rspack_import_0.ZQ({
+                    now: options.now,
+                    fetchCredentials: async ()=>{
+                        try {
+                            return await options.fetchCredentials();
+                        } catch (error) {
+                            throw toDataPlaneError(error);
+                        }
+                    }
+                });
+            }
+        }
+        class StoreCredentialProviderCache {
+            get(scope) {
+                if (!scope.environment || !scope.projectId) throw new _errors_js__rspack_import_1.A("ServiceUnavailable", "Store credentials are unavailable");
+                let projects = this.providers.get(scope.environment);
+                if (!projects) {
+                    projects = new Map();
+                    this.providers.set(scope.environment, projects);
+                }
+                let provider = projects.get(scope.projectId);
+                if (!provider) {
+                    provider = this.createProvider(Object.freeze({
+                        ...scope
+                    }));
+                    projects.set(scope.projectId, provider);
+                }
+                return provider;
+            }
+            clear(scope) {
+                if (!scope) return void this.providers.clear();
+                const projects = this.providers.get(scope.environment);
+                projects?.delete(scope.projectId);
+                if (projects?.size === 0) this.providers.delete(scope.environment);
+            }
+            constructor(options){
+                this.providers = new Map();
+                this.createProvider = options.createProvider;
+            }
+        }
+    },
+    "../store/src/errors.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>StoreError,
+            Q: ()=>storeCodeForStatus
+        });
+        class StoreError extends Error {
+            toJSON() {
+                return {
+                    code: this.code,
+                    message: this.error?.message ?? this.message,
+                    ...void 0 !== this.status ? {
+                        status: this.status
+                    } : {},
+                    ...void 0 !== this.error ? {
+                        error: this.error
+                    } : {}
+                };
+            }
+            constructor(code, message, options = {}){
+                super(options.error?.message ?? message);
+                this.name = "StoreError";
+                this.code = code;
+                if (null !== options.error) this.error = options.error ?? {
+                    message
+                };
+                if (Number.isInteger(options.status) && options.status >= 0 && options.status <= 599) this.status = options.status;
+            }
+        }
+        function storeCodeForStatus(status) {
+            const codes = {
+                0: "NetworkError",
+                400: "BadRequest",
+                401: "Unauthorized",
+                402: "PaymentRequired",
+                403: "Forbidden",
+                404: "NotFound",
+                405: "MethodNotAllowed",
+                406: "NotAcceptable",
+                408: "RequestTimeout",
+                409: "Conflict",
+                410: "Gone",
+                411: "LengthRequired",
+                412: "PreconditionFailed",
+                413: "PayloadTooLarge",
+                414: "URITooLong",
+                415: "UnsupportedMediaType",
+                416: "RangeNotSatisfiable",
+                417: "ExpectationFailed",
+                418: "ImATeapot",
+                422: "UnprocessableEntity",
+                423: "Locked",
+                424: "FailedDependency",
+                425: "TooEarly",
+                426: "UpgradeRequired",
+                428: "PreconditionRequired",
+                429: "TooManyRequests",
+                431: "RequestHeaderFieldsTooLarge",
+                451: "UnavailableForLegalReasons",
+                500: "InternalServerError",
+                501: "NotImplemented",
+                502: "BadGateway",
+                503: "ServiceUnavailable",
+                504: "GatewayTimeout",
+                505: "HTTPVersionNotSupported"
+            };
+            return codes[status] ?? "UnknownError";
+        }
+    },
+    "../store/src/json.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            P: ()=>cloneJsonObject,
+            j: ()=>cloneJsonValue
+        });
+        var _errors_js__rspack_import_0 = __webpack_require__("../store/src/errors.ts");
+        function invalidJson(field) {
+            return new _errors_js__rspack_import_0.A("BadRequest", `${field} must contain only JSON-compatible values`);
+        }
+        function cloneJsonValueInternal(value, field, ancestors) {
+            if (null === value || "string" == typeof value || "boolean" == typeof value) return value;
+            if ("number" == typeof value) {
+                if (!Number.isFinite(value)) throw invalidJson(field);
+                return value;
+            }
+            if (Array.isArray(value)) {
+                if (ancestors.has(value)) throw invalidJson(field);
+                ancestors.add(value);
+                const cloned = [];
+                for(let index = 0; index < value.length; index += 1){
+                    if (!(index in value)) throw invalidJson(field);
+                    cloned.push(cloneJsonValueInternal(value[index], field, ancestors));
+                }
+                ancestors.delete(value);
+                return cloned;
+            }
+            if ("object" == typeof value) {
+                const prototype = Object.getPrototypeOf(value);
+                if (prototype !== Object.prototype && null !== prototype) throw invalidJson(field);
+                if (ancestors.has(value)) throw invalidJson(field);
+                ancestors.add(value);
+                const cloned = {};
+                for (const [key, child] of Object.entries(value))Object.defineProperty(cloned, key, {
+                    configurable: true,
+                    enumerable: true,
+                    writable: true,
+                    value: cloneJsonValueInternal(child, field, ancestors)
+                });
+                ancestors.delete(value);
+                return cloned;
+            }
+            throw invalidJson(field);
+        }
+        function cloneJsonValue(value, field) {
+            return cloneJsonValueInternal(value, field, new WeakSet());
+        }
+        function cloneJsonObject(value, field) {
+            const cloned = cloneJsonValue(value, field);
+            if (null === cloned || Array.isArray(cloned) || "object" != typeof cloned) throw new _errors_js__rspack_import_0.A("BadRequest", `${field} must be a JSON object`);
+            return cloned;
+        }
+    },
+    "../store/src/store.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            y$: ()=>createStore
+        });
+        var external_node_crypto_ = __webpack_require__("node:crypto");
+        var errors = __webpack_require__("../store/src/errors.ts");
+        var json = __webpack_require__("../store/src/json.ts");
+        function materializeAppendMessages(messages, generateUuid = external_node_crypto_.randomUUID) {
+            if (!Array.isArray(messages) || messages.length < 1 || messages.length > 100) throw new errors.A("BadRequest", "appendMessages requires between 1 and 100 messages");
+            const ids = new Set();
+            return messages.map((message, index)=>{
+                if (null === message || "object" != typeof message) throw new errors.A("BadRequest", `messages[${index}] must be an object`);
+                if (void 0 !== message.role && null !== message.role && "string" != typeof message.role) throw new errors.A("BadRequest", `messages[${index}].role must be a string or null`);
+                if (void 0 !== message.type && null !== message.type && "string" != typeof message.type) throw new errors.A("BadRequest", `messages[${index}].type must be a string or null`);
+                if (void 0 !== message.messageId && "string" != typeof message.messageId) throw new errors.A("BadRequest", `messages[${index}].messageId must be a string`);
+                const messageId = message.messageId ?? generateUuid();
+                if (ids.has(messageId)) throw new errors.A("BadRequest", "appendMessages contains duplicate messageId values");
+                ids.add(messageId);
+                return Object.freeze({
+                    messageId,
+                    role: message.role ?? null,
+                    type: message.type ?? null,
+                    payload: (0, json.j)(message.payload, `messages[${index}].payload`),
+                    metadata: void 0 === message.metadata ? {} : (0, json.P)(message.metadata, `messages[${index}].metadata`)
+                });
+            });
+        }
+        const DEFAULT_STORE_PAGE_LIMIT = 50;
+        const MAX_STORE_PAGE_LIMIT = 100;
+        const TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+        function validationError() {
+            return new errors.A("BadRequest", "Store cursor is invalid");
+        }
+        function encode(value) {
+            return Buffer.from(JSON.stringify(value)).toString("base64url");
+        }
+        function decode(value) {
+            try {
+                return JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+            } catch  {
+                throw validationError();
+            }
+        }
+        function isObject(value) {
+            return null !== value && "object" == typeof value && !Array.isArray(value);
+        }
+        function isTimestamp(value) {
+            return "string" == typeof value && TIMESTAMP_PATTERN.test(value) && Number.isFinite(Date.parse(value));
+        }
+        function isConversationId(value) {
+            return "string" == typeof value && value.length > 0 && Buffer.byteLength(value, "utf8") <= 256;
+        }
+        function isSequence(value) {
+            return "string" == typeof value && /^(0|[1-9]\d*)$/.test(value);
+        }
+        function normalizeStorePageLimit(limit) {
+            if (void 0 === limit) return DEFAULT_STORE_PAGE_LIMIT;
+            if (!Number.isInteger(limit) || limit < 1 || limit > MAX_STORE_PAGE_LIMIT) throw new errors.A("BadRequest", `Store page limit must be an integer from 1 to ${MAX_STORE_PAGE_LIMIT}`);
+            return limit;
+        }
+        function encodeConversationCursor(cursor) {
+            return encode({
+                version: 1,
+                kind: "conversations",
+                ...cursor
+            });
+        }
+        function decodeConversationCursor(value) {
+            const cursor = decode(value);
+            if (!isObject(cursor) || 1 !== cursor.version || "conversations" !== cursor.kind || !isTimestamp(cursor.updatedAt) || !isConversationId(cursor.conversationId)) throw validationError();
+            return {
+                updatedAt: cursor.updatedAt,
+                conversationId: cursor.conversationId
+            };
+        }
+        function encodeMessageCursor(cursor) {
+            return encode({
+                version: 1,
+                kind: "messages",
+                ...cursor
+            });
+        }
+        function decodeMessageCursor(value, expected) {
+            const cursor = decode(value);
+            if (!isObject(cursor) || 1 !== cursor.version || "messages" !== cursor.kind || !isConversationId(cursor.conversationId) || cursor.conversationId !== expected.conversationId || cursor.order !== expected.order || !isSequence(cursor.snapshotSeq) || !isSequence(cursor.lastSeq)) throw validationError();
+            return {
+                conversationId: cursor.conversationId,
+                order: expected.order,
+                snapshotSeq: cursor.snapshotSeq,
+                lastSeq: cursor.lastSeq
+            };
+        }
+        const SEQUENCE_PATTERN = /^(0|[1-9]\d*)$/;
+        const CONVERSATION_COLUMNS = "conversation_id,metadata,created_at,updated_at";
+        const MESSAGE_COLUMNS = "event_id,conversation_id,seq_text,role,event_type,payload,metadata,created_at,updated_at";
+        const DEFAULT_STORE_RPC_NAMES = Object.freeze({
+            appendMessages: "append_messages",
+            updateConversation: "update_conversation",
+            deleteConversation: "delete_conversation",
+            deleteMessage: "delete_event",
+            clearMessages: "clear_messages"
+        });
+        function invalid(message) {
+            throw new errors.A("BadRequest", message);
+        }
+        function internal() {
+            throw new errors.A("UnknownError", "Store returned invalid data");
+        }
+        function requireObject(value, field) {
+            if (null === value || "object" != typeof value || Array.isArray(value)) invalid(`${field} must be an object`);
+            return value;
+        }
+        function requireConversationId(value) {
+            if ("string" != typeof value || 0 === value.length) invalid("conversationId must be a non-empty string");
+            if (Buffer.byteLength(value, "utf8") > 256) invalid("conversationId must not exceed 256 UTF-8 bytes");
+            return value;
+        }
+        function requireMessageId(value) {
+            if ("string" != typeof value || "" === value) invalid("messageId must be a non-empty string");
+            return value;
+        }
+        function requireTimestamp(value) {
+            if ("string" != typeof value || "" === value || !Number.isFinite(Date.parse(value))) internal();
+            return value;
+        }
+        function requireNextSequence(value) {
+            if ("string" == typeof value && SEQUENCE_PATTERN.test(value)) return value;
+            if ("number" == typeof value && Number.isSafeInteger(value) && value >= 0) return String(value);
+            internal();
+        }
+        function mapConversation(value) {
+            const row = requireStoreRow(value);
+            if ("string" != typeof row.conversation_id) internal();
+            return {
+                conversationId: row.conversation_id,
+                metadata: readStoreJsonObject(row.metadata),
+                createdAt: requireTimestamp(row.created_at),
+                updatedAt: requireTimestamp(row.updated_at)
+            };
+        }
+        function mapMessage(value) {
+            const row = requireStoreRow(value);
+            if ("string" != typeof row.event_id || "string" != typeof row.conversation_id || "string" != typeof row.seq_text || !SEQUENCE_PATTERN.test(row.seq_text) || null !== row.role && "string" != typeof row.role || null !== row.event_type && "string" != typeof row.event_type) internal();
+            return {
+                messageId: row.event_id,
+                conversationId: row.conversation_id,
+                seq: row.seq_text,
+                role: row.role,
+                type: row.event_type,
+                payload: readStoreJsonValue(row.payload),
+                metadata: readStoreJsonObject(row.metadata),
+                createdAt: requireTimestamp(row.created_at),
+                updatedAt: requireTimestamp(row.updated_at)
+            };
+        }
+        function requireStoreRow(value) {
+            if (null === value || "object" != typeof value || Array.isArray(value)) internal();
+            return value;
+        }
+        function readStoreJsonValue(value) {
+            try {
+                return (0, json.j)(value, "Store data");
+            } catch  {
+                internal();
+            }
+        }
+        function readStoreJsonObject(value) {
+            try {
+                return (0, json.P)(value, "Store data");
+            } catch  {
+                internal();
+            }
+        }
+        function requireRows(value) {
+            if (!Array.isArray(value)) internal();
+            return value;
+        }
+        class SupabaseStore {
+            async createConversation(input = {}) {
+                const value = requireObject(input, "createConversation input");
+                const conversationId = void 0 === value.conversationId ? requireConversationId(this.generateUuid()) : requireConversationId(value.conversationId);
+                const metadata = void 0 === value.metadata ? {} : (0, json.P)(value.metadata, "metadata");
+                const data = await this.execute((client)=>client.from("conversations").insert({
+                        project_id: this.projectId,
+                        conversation_id: conversationId,
+                        metadata
+                    }).select(CONVERSATION_COLUMNS).single(), {
+                    operation: "store.createConversation",
+                    retryNetwork: false
+                });
+                return mapConversation(data);
+            }
+            async getConversation(input) {
+                const value = requireObject(input, "getConversation input");
+                const conversationId = requireConversationId(value.conversationId);
+                const data = await this.execute((client)=>client.from("conversations").select(CONVERSATION_COLUMNS).eq("project_id", this.projectId).eq("conversation_id", conversationId).maybeSingle(), {
+                    operation: "store.getConversation",
+                    retryNetwork: true
+                });
+                return null === data ? null : mapConversation(data);
+            }
+            async listConversations(input = {}) {
+                const value = requireObject(input, "listConversations input");
+                const limit = normalizeStorePageLimit(value.limit);
+                const cursor = void 0 === value.cursor ? void 0 : "string" == typeof value.cursor ? decodeConversationCursor(value.cursor) : invalid("cursor must be a string");
+                const data = await this.execute((client)=>{
+                    let query = client.from("conversations").select(CONVERSATION_COLUMNS).eq("project_id", this.projectId).order("updated_at", {
+                        ascending: false
+                    }).order("conversation_id", {
+                        ascending: false
+                    }).limit(limit + 1);
+                    if (cursor) {
+                        const quotedId = `"${cursor.conversationId.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+                        query = query.or(`updated_at.lt.${cursor.updatedAt},and(updated_at.eq.${cursor.updatedAt},conversation_id.lt.${quotedId})`);
+                    }
+                    return query;
+                }, {
+                    operation: "store.listConversations",
+                    retryNetwork: true
+                });
+                const rows = requireRows(data);
+                const hasMore = rows.length > limit;
+                const items = rows.slice(0, limit).map(mapConversation);
+                const last = items.at(-1);
+                return {
+                    items,
+                    nextCursor: hasMore && last ? encodeConversationCursor({
+                        updatedAt: last.updatedAt,
+                        conversationId: last.conversationId
+                    }) : null
+                };
+            }
+            async updateConversation(input) {
+                const value = requireObject(input, "updateConversation input");
+                const conversationId = requireConversationId(value.conversationId);
+                if (!("metadata" in value)) invalid("metadata is required");
+                const metadata = (0, json.P)(value.metadata, "metadata");
+                const removalKeys = [];
+                for (const [key, item] of Object.entries(metadata))if (null === item) {
+                    removalKeys.push(key);
+                    delete metadata[key];
+                }
+                const data = await this.execute((client)=>client.rpc(this.rpcNames.updateConversation, {
+                        p_project_id: this.projectId,
+                        p_conversation_id: conversationId,
+                        p_metadata: metadata,
+                        p_remove_metadata_keys: removalKeys
+                    }).maybeSingle(), {
+                    operation: "store.updateConversation",
+                    retryNetwork: false
+                });
+                if (null === data) throw new errors.A("NotFound", "Conversation was not found");
+                return mapConversation(data);
+            }
+            async deleteConversation(input) {
+                const value = requireObject(input, "deleteConversation input");
+                const conversationId = requireConversationId(value.conversationId);
+                await this.execute((client)=>client.rpc(this.rpcNames.deleteConversation, {
+                        p_project_id: this.projectId,
+                        p_conversation_id: conversationId
+                    }), {
+                    operation: "store.deleteConversation",
+                    retryNetwork: true
+                });
+            }
+            async appendMessage(input) {
+                const value = requireObject(input, "appendMessage input");
+                const { conversationId, ...message } = value;
+                const [result] = await this.appendMessages({
+                    conversationId: conversationId,
+                    messages: [
+                        message
+                    ]
+                });
+                return result;
+            }
+            async appendMessages(input) {
+                const value = requireObject(input, "appendMessages input");
+                const conversationId = requireConversationId(value.conversationId);
+                const materialized = materializeAppendMessages(value.messages, this.generateUuid);
+                const rpcMessages = materialized.map((message)=>({
+                        message_id: message.messageId,
+                        role: message.role,
+                        event_type: message.type,
+                        payload: message.payload,
+                        metadata: message.metadata
+                    }));
+                const data = await this.execute((client)=>client.rpc(this.rpcNames.appendMessages, {
+                        p_project_id: this.projectId,
+                        p_conversation_id: conversationId,
+                        p_messages: rpcMessages
+                    }), {
+                    operation: "store.appendMessages",
+                    retryNetwork: true
+                });
+                const byId = new Map(requireRows(data).map((row)=>{
+                    const message = mapMessage(row);
+                    return [
+                        message.messageId,
+                        message
+                    ];
+                }));
+                if (byId.size !== materialized.length) internal();
+                return materialized.map((inputMessage)=>{
+                    const message = byId.get(inputMessage.messageId);
+                    if (!message || message.conversationId !== conversationId) internal();
+                    return message;
+                });
+            }
+            async getMessage(input) {
+                const value = requireObject(input, "getMessage input");
+                const messageId = requireMessageId(value.messageId);
+                const data = await this.execute((client)=>client.from("events").select(MESSAGE_COLUMNS).eq("project_id", this.projectId).eq("event_id", messageId).maybeSingle(), {
+                    operation: "store.getMessage",
+                    retryNetwork: true
+                });
+                return null === data ? null : mapMessage(data);
+            }
+            async listMessages(input) {
+                const value = requireObject(input, "listMessages input");
+                const conversationId = requireConversationId(value.conversationId);
+                const limit = normalizeStorePageLimit(value.limit);
+                const order = value.order ?? "asc";
+                if ("asc" !== order && "desc" !== order) invalid('order must be "asc" or "desc"');
+                const cursor = void 0 === value.cursor ? void 0 : "string" == typeof value.cursor ? decodeMessageCursor(value.cursor, {
+                    conversationId,
+                    order
+                }) : invalid("cursor must be a string");
+                const snapshotSeq = cursor?.snapshotSeq ?? await this.readSnapshotSeq(conversationId);
+                if (null === snapshotSeq) return {
+                    items: [],
+                    nextCursor: null
+                };
+                const data = await this.execute((client)=>{
+                    let query = client.from("events").select(MESSAGE_COLUMNS).eq("project_id", this.projectId).eq("conversation_id", conversationId).lte("seq", snapshotSeq).order("seq", {
+                        ascending: "asc" === order
+                    }).limit(limit + 1);
+                    if (cursor) query = "asc" === order ? query.gt("seq", cursor.lastSeq) : query.lt("seq", cursor.lastSeq);
+                    return query;
+                }, {
+                    operation: "store.listMessages",
+                    retryNetwork: true
+                });
+                const rows = requireRows(data);
+                const hasMore = rows.length > limit;
+                const items = rows.slice(0, limit).map(mapMessage);
+                const last = items.at(-1);
+                return {
+                    items,
+                    nextCursor: hasMore && last ? encodeMessageCursor({
+                        conversationId,
+                        order,
+                        snapshotSeq,
+                        lastSeq: last.seq
+                    }) : null
+                };
+            }
+            async updateMessage(input) {
+                const value = requireObject(input, "updateMessage input");
+                const messageId = requireMessageId(value.messageId);
+                const update = {};
+                if ("role" in value) {
+                    if (null !== value.role && "string" != typeof value.role) invalid("role must be a string or null");
+                    update.role = value.role;
+                }
+                if ("type" in value) {
+                    if (null !== value.type && "string" != typeof value.type) invalid("type must be a string or null");
+                    update.event_type = value.type;
+                }
+                if ("payload" in value) update.payload = (0, json.j)(value.payload, "payload");
+                if ("metadata" in value) update.metadata = (0, json.P)(value.metadata, "metadata");
+                if (0 === Object.keys(update).length) invalid("updateMessage requires at least one mutable field");
+                const data = await this.execute((client)=>client.from("events").update(update).eq("project_id", this.projectId).eq("event_id", messageId).select(MESSAGE_COLUMNS).maybeSingle(), {
+                    operation: "store.updateMessage",
+                    retryNetwork: false
+                });
+                if (null === data) throw new errors.A("NotFound", "Message was not found");
+                return mapMessage(data);
+            }
+            async deleteMessage(input) {
+                const value = requireObject(input, "deleteMessage input");
+                const messageId = requireMessageId(value.messageId);
+                await this.execute((client)=>client.rpc(this.rpcNames.deleteMessage, {
+                        p_project_id: this.projectId,
+                        p_event_id: messageId
+                    }), {
+                    operation: "store.deleteMessage",
+                    retryNetwork: true
+                });
+            }
+            async clearMessages(input) {
+                const value = requireObject(input, "clearMessages input");
+                const conversationId = requireConversationId(value.conversationId);
+                await this.execute((client)=>client.rpc(this.rpcNames.clearMessages, {
+                        p_project_id: this.projectId,
+                        p_conversation_id: conversationId
+                    }), {
+                    operation: "store.clearMessages",
+                    retryNetwork: true
+                });
+            }
+            async readSnapshotSeq(conversationId) {
+                const data = await this.execute((client)=>client.from("conversations").select("next_seq").eq("project_id", this.projectId).eq("conversation_id", conversationId).maybeSingle(), {
+                    operation: "store.listMessages",
+                    retryNetwork: true
+                });
+                if (null === data) return null;
+                const row = requireStoreRow(data);
+                const next = BigInt(requireNextSequence(row.next_seq));
+                return next > 0n ? String(next - 1n) : "0";
+            }
+            async execute(operation, options) {
+                const result = await this.transport.execute({
+                    operationName: options.operation,
+                    retryOnUnauthorized: true,
+                    retryOnNetworkError: options.retryNetwork,
+                    operation
+                });
+                return result.data;
+            }
+            constructor(options){
+                if (!options.projectId) throw new errors.A("UnknownError", "Store project scope is missing");
+                this.projectId = options.projectId;
+                this.transport = options.transport;
+                this.generateUuid = options.generateUuid ?? external_node_crypto_.randomUUID;
+                this.rpcNames = {
+                    ...DEFAULT_STORE_RPC_NAMES,
+                    ...options.rpcNames
+                };
+            }
+        }
+        function createStore(options) {
+            return new SupabaseStore(options);
+        }
+    },
+    "../store/src/supabase-transport.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            H: ()=>SupabaseStoreTransport
+        });
+        var _iga_pages_data_plane__rspack_import_0 = __webpack_require__("../data-plane/dist/esm/index.js");
+        var _errors_js__rspack_import_1 = __webpack_require__("../store/src/errors.ts");
+        function throwForStatus(status, error) {
+            throw new _errors_js__rspack_import_1.A((0, _errors_js__rspack_import_1.Q)(status), error?.message ?? "Store request failed", {
+                status,
+                ...error ? {
+                    error
+                } : {}
+            });
+        }
+        class SupabaseStoreTransport {
+            async execute(options) {
+                const attempts = options.retryOnUnauthorized || options.retryOnNetworkError ? 2 : 1;
+                for(let attempt = 0; attempt < attempts; attempt += 1){
+                    const credentials = await this.credentialProvider.getValidCredentials();
+                    const client = (0, _iga_pages_data_plane__rspack_import_0.Ju)({
+                        credentials,
+                        fetch: this.fetch,
+                        createClient: this.createClient,
+                        realtimeError: ()=>new _errors_js__rspack_import_1.A("UnknownError", "Store does not support Supabase Realtime")
+                    });
+                    let result;
+                    try {
+                        result = await options.operation(client);
+                    } catch (error) {
+                        if (error instanceof _errors_js__rspack_import_1.A) throw error;
+                        const name = error?.name;
+                        if ("AbortError" === name) throw new _errors_js__rspack_import_1.A("AbortError", "Store request was cancelled");
+                        if (options.retryOnNetworkError && attempt + 1 < attempts) continue;
+                        throw new _errors_js__rspack_import_1.A("TimeoutError" === name ? "TimeoutError" : "NetworkError", error instanceof Error ? error.message : "Store request failed");
+                    }
+                    if (0 !== result.status || !options.retryOnNetworkError || !(attempt + 1 < attempts)) {
+                        if (401 === result.status && attempt + 1 < attempts) {
+                            this.credentialProvider.invalidate(credentials.jwt);
+                            continue;
+                        }
+                        if (!result.success || result.status < 200 || result.status >= 300) throwForStatus(result.status, result.error);
+                        return {
+                            data: result.data,
+                            count: result.count ?? null
+                        };
+                    }
+                }
+                throw new _errors_js__rspack_import_1.A("Unauthorized", "Store authorization failed");
+            }
+            constructor(options){
+                this.credentialProvider = options.credentialProvider;
+                this.fetch = options.fetch ?? globalThis.fetch;
+                this.createClient = options.createClient;
+            }
+        }
+    },
+    "../store/src/token-client.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            f: ()=>validateStoreRootUrl,
+            o: ()=>fetchStoreCredentials
+        });
+        var _iga_pages_data_plane__rspack_import_0 = __webpack_require__("../data-plane/dist/esm/index.js");
+        var _credential_error_js__rspack_import_1 = __webpack_require__("../store/src/credential-error.ts");
+        function validateStoreRootUrl(value, isAllowedHostname) {
+            try {
+                return (0, _iga_pages_data_plane__rspack_import_0.uk)(value, isAllowedHostname);
+            } catch (error) {
+                throw (0, _credential_error_js__rspack_import_1.y)(error);
+            }
+        }
+        async function fetchStoreCredentials(options) {
+            try {
+                return await (0, _iga_pages_data_plane__rspack_import_0.R5)(options);
+            } catch (error) {
+                throw (0, _credential_error_js__rspack_import_1.y)(error);
+            }
+        }
+    }
+};