@gea-ai/extensions-sdk 0.1.261014-alpha.0 → 0.1.261016-alpha.0

package/README.md

@@ -141,17 +141,47 @@ import { actions } from "../contract";
 type Sdk = ExtensionBackendSdk<never, { appData: typeof schema }>;
 
 export const backend = defineBackendActions<typeof actions, Sdk>(actions, {
-  createIdea: async ({ input, sdk }) =>
-    await sdk.databases.appData.transaction(async (tx) => {
-      const idea = { id: crypto.randomUUID(), title: input.title };
-      await tx.insert(schema.ideas).values(idea);
-      return idea;
-    }),
+  createIdea: async ({ input, sdk }) => {
+    if (!sdk.createId || !sdk.requestId) {
+      throw new Error("Extension request id is unavailable.");
+    }
+    const idea = { id: sdk.createId("idea"), title: input.title };
+    const eventId = sdk.createId("idea-event");
+    await sdk.databases.appData.batch([
+      sdk.databases.appData.insert(schema.ideas).values(idea),
+      sdk.databases.appData.insert(schema.ideaEvents).values({
+        id: eventId,
+        ideaId: idea.id,
+        kind: "created",
+      }),
+    ]);
+    return idea;
+  },
 });
 ```
 
-Normal Drizzle selects, writes, batches, and interactive transactions execute
-against the host-owned database. The host revalidates the installed extension,
+`schema.ideaEvents` is the audit table declared next to `schema.ideas`. Derive
+both ids from `sdk.createId` before calling `batch()` so the two inserts are
+one host request and a retry sends the same primary keys. `batch()` runs
+inside a single SQLite transaction: a failure rolls the whole batch back. The
+caller supplies the request id, and a lost response retries with that same id
+after the host process is gone instead of inserting again. The database write
+id follows that caller id and the statement text, so an extra read on retry
+does not run the write again. Full replay records and the host change log
+each stay inside a byte budget for 24 hours. Compacted ids share one
+fixed-size tombstone capped by that same budget, so the record does not grow
+with each write. A compacted id is not executed again while it remains in
+that record. The tombstone rolls forward in 24 hour generations and can keep
+a compacted id refused for up to two generations. When that fixed record is
+saturated, a new id can be refused instead of expanding past the budget or
+running an old write again.
+
+Normal Drizzle selects, writes, and batches execute
+against the host-owned database. Interactive `transaction()` is not available.
+A `BEGIN`, `COMMIT`, `ROLLBACK`, `SAVEPOINT`, or `END` statement, including a
+keyword glued to a comment or a leading semicolon, or an old transaction
+session is rejected before any write with an error that says to use `batch()`.
+The host revalidates the installed extension,
 workspace, declared resource key, engine readiness, and caller on every proxy
 operation. The same proxy protocol is used by `gea ext dev`.
 
@@ -267,8 +297,9 @@ intentionally narrow:
 - `sdk.chats.list(...)` for listing the authenticated user's ordinary top-level
   chats in the current workspace, plus `sdk.chats.messages.list(...)` for
   reading a selected chat.
-- `sdk.databases.<handle>` for typed Drizzle SQLite Proxy queries, batches, and
-  transactions against SQLite resources declared by this extension. No path,
+- `sdk.databases.<handle>` for typed Drizzle SQLite Proxy queries and batches
+  against SQLite resources declared by this extension. Use `batch()` when
+  several writes must commit or roll back together. No path,
   provider locator, credential, or arbitrary resource lookup is exposed.
 
 Legacy host helpers outside this surface are not part of the third-party SDK

package/dist/actions.d.ts

@@ -16,6 +16,7 @@ export type ExtensionActionTransport = (input: {
     action: string;
     extensionSlug: string;
     input: unknown;
+    requestId?: string;
 }) => Promise<unknown>;
 export declare function defineActions<const TActions extends Record<string, AnyExtensionActionContract>>(actions: TActions): TActions;
 export declare function createExtensionActionTransport(options?: ExtensionHostMessageClientOptions): ExtensionActionTransport;
@@ -24,7 +25,9 @@ export declare function createExtensionActionClient<const TActions extends Exten
     extensionSlug: string;
     transport: ExtensionActionTransport;
 }): {
-    call: <const TAction extends keyof TActions & string>(action: TAction, inputValue: ExtensionActionInput<TActions, TAction>) => Promise<ExtensionActionOutput<TActions, TAction>>;
+    call: <const TAction extends keyof TActions & string>(action: TAction, inputValue: ExtensionActionInput<TActions, TAction>, options?: {
+        requestId?: string;
+    }) => Promise<ExtensionActionOutput<TActions, TAction>>;
     mutationOptions<const TAction extends keyof TActions & string, TInput extends ExtensionActionInput<TActions, TAction> = ExtensionActionInput<TActions, TAction>, TOutput extends ExtensionActionOutput<TActions, TAction> = ExtensionActionOutput<TActions, TAction>>(action: TAction, options?: Omit<UseMutationOptions<TOutput, Error, TInput, unknown>, "mutationFn" | "mutationKey">): import("@tanstack/react-query").WithRequired<UseMutationOptions<TOutput, Error, TInput, unknown>, "mutationKey">;
     queryOptions<const TAction extends keyof TActions & string, TInput extends ExtensionActionInput<TActions, TAction> = ExtensionActionInput<TActions, TAction>, TOutput extends ExtensionActionOutput<TActions, TAction> = ExtensionActionOutput<TActions, TAction>>(action: TAction, inputValue: TInput, options?: Omit<UseQueryOptions<TOutput, Error, TOutput, QueryKey>, "queryFn" | "queryKey">): ExtensionActionQueryOptions<TOutput>;
 };

package/dist/actions.js

@@ -1,23 +1,44 @@
 import { mutationOptions as createTanStackMutationOptions, queryOptions as createTanStackQueryOptions, } from "@tanstack/react-query";
-import { createExtensionHostMethodCaller, } from "./host-message.js";
+import { createExtensionHostMethodCaller, ExtensionHostError, } from "./host-message.js";
+import { createExtensionClientRequestId } from "./request-id.js";
 export function defineActions(actions) {
     return actions;
 }
 export function createExtensionActionTransport(options = {}) {
     const callHostMethod = createExtensionHostMethodCaller(options);
-    return async (input) => await callHostMethod("extension.call", {
-        input,
-    });
+    return async (input) => {
+        const requestId = input.requestId ?? createExtensionClientRequestId();
+        const send = () => callHostMethod("extension.call", {
+            input: {
+                action: input.action,
+                extensionSlug: input.extensionSlug,
+                input: input.input,
+                requestId,
+            },
+        });
+        try {
+            return await send();
+        }
+        catch (error) {
+            if (error instanceof ExtensionHostError &&
+                error.code === "invalid_input") {
+                throw error;
+            }
+            return await send();
+        }
+    };
 }
 export function createExtensionActionClient(input) {
     const { actions, extensionSlug, transport } = input;
-    async function call(action, inputValue) {
+    async function call(action, inputValue, options) {
         const actionContract = actions[action];
         const parsedInput = actionContract.inputSchema.parse(inputValue);
+        const requestId = options?.requestId ?? createExtensionClientRequestId();
         const result = await transport({
             action,
             extensionSlug,
             input: parsedInput,
+            requestId,
         });
         return actionContract.outputSchema.parse(result);
     }

package/dist/backend.d.ts

@@ -206,20 +206,30 @@ export type ExtensionBackendAgentsClient<TAgentHandleKey extends string = never>
 } & Record<TAgentHandleKey, ExtensionBackendAgentHandle>;
 export type ExtensionBackendDatabaseSchemas = Record<string, Record<string, unknown>>;
 export type ExtensionBackendDatabasesClient<TSchemas extends ExtensionBackendDatabaseSchemas = Record<string, Record<string, never>>> = {
-    [TDatabase in keyof TSchemas]: SqliteRemoteDatabase<TSchemas[TDatabase]>;
+    [TDatabase in keyof TSchemas]: ExtensionSqliteDatabase<TSchemas[TDatabase]>;
 };
 export type ExtensionBackendDatabaseTransport = {
     batch: AsyncBatchRemoteCallback;
     execute: AsyncRemoteCallback;
 };
-export declare function createExtensionBackendDatabase<TSchema extends Record<string, unknown> = Record<string, never>>(transport: ExtensionBackendDatabaseTransport): SqliteRemoteDatabase<TSchema>;
+export declare const extensionDatabaseTransactionErrorMessage = "Extension database transactions are not supported. Use batch().";
+export declare function extensionDatabaseStatementsUseTransaction(statements: ReadonlyArray<{
+    sql: string;
+}>): boolean;
+export declare function isExtensionDatabaseTransactionSql(sql: string): boolean;
+export type ExtensionSqliteDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = Omit<SqliteRemoteDatabase<TSchema>, "transaction">;
+export declare function createExtensionBackendDatabase<TSchema extends Record<string, unknown> = Record<string, never>>(transport: ExtensionBackendDatabaseTransport, options?: {
+    rejectTransactionSql?: boolean;
+}): ExtensionSqliteDatabase<TSchema>;
 export declare function getExtensionAgentHandleKey(slug: string): string;
 export type ExtensionBackendSdk<TAgentHandleKey extends string = never, TDatabaseSchemas extends ExtensionBackendDatabaseSchemas = Record<string, Record<string, never>>> = {
     agents: ExtensionBackendAgentsClient<TAgentHandleKey>;
     artifacts: ExtensionBackendArtifactsClient;
     chats: ExtensionBackendChatsClient;
     connectors: ExtensionBackendConnectorsClient;
+    createId?(name: string): string;
     databases: ExtensionBackendDatabasesClient<TDatabaseSchemas>;
+    requestId?: string;
     resources: ExtensionBackendResourcesClient;
     state: {
         records: ExtensionBackendStateRecordsClient;
@@ -236,10 +246,12 @@ export type ExtensionBackendActionContext = {
     workspaceId: string;
 };
 export type ExtensionBackendActionHandlerInput<TInput, TSdk> = {
+    clientRequestId?: string;
     context: ExtensionBackendActionContext;
     input: TInput;
     sdk: TSdk;
 };
+export { createExtensionClientRequestId, extensionClientRequestId, extensionDatabaseRequestId, extensionDatabaseStatementsKey, extensionRequestNamespaceHex, nextExtensionDatabaseRequestId, extensionRequestTimestampMs, extensionScopedId, } from "./request-id.js";
 export type ExtensionBackendHandlers<TActions extends ExtensionActionsInput, TSdk> = {
     [TAction in keyof TActions & string]: (input: ExtensionBackendActionHandlerInput<ExtensionActionInput<TActions, TAction>, TSdk>) => ExtensionActionOutput<TActions, TAction> | Promise<ExtensionActionOutput<TActions, TAction>>;
 };
@@ -278,4 +290,3 @@ export declare function defineDurableObjects<const TActions extends ExtensionAct
     durableObjects: TObjects;
 };
 export declare function defineBackendActions<const TActions extends ExtensionActionsInput, TSdk = ExtensionBackendSdk>(actions: TActions, handlers: ExtensionBackendHandlers<TActions, TSdk>): ExtensionBackendDefinition<TActions, TSdk>;
-export {};

package/dist/backend.js

@@ -1,6 +1,186 @@
 import { drizzle, } from "drizzle-orm/sqlite-proxy";
-export function createExtensionBackendDatabase(transport) {
-    return drizzle(transport.execute, transport.batch);
+export const extensionDatabaseTransactionErrorMessage = "Extension database transactions are not supported. Use batch().";
+export function extensionDatabaseStatementsUseTransaction(statements) {
+    return statements.some((statement) => isExtensionDatabaseTransactionSql(statement.sql));
+}
+const extensionDatabaseTransactionKeywords = new Set([
+    "begin",
+    "commit",
+    "end",
+    "release",
+    "rollback",
+    "savepoint",
+]);
+function isSqlWhitespace(char) {
+    return (char === " " ||
+        char === "\t" ||
+        char === "\n" ||
+        char === "\r" ||
+        char === "\f");
+}
+function isSqlWordChar(char) {
+    return ((char >= "A" && char <= "Z") ||
+        (char >= "a" && char <= "z") ||
+        (char >= "0" && char <= "9") ||
+        char === "_");
+}
+function skipSqlQuote(source, index, quote) {
+    let cursor = index + 1;
+    while (cursor < source.length) {
+        if (source[cursor] === quote) {
+            if (source[cursor + 1] === quote) {
+                cursor += 2;
+                continue;
+            }
+            return cursor + 1;
+        }
+        cursor += 1;
+    }
+    return cursor;
+}
+function skipSqlStatementRemainder(source, index) {
+    let cursor = index;
+    while (cursor < source.length) {
+        const char = source[cursor] ?? "";
+        if (char === "-" && source[cursor + 1] === "-") {
+            const newline = source.indexOf("\n", cursor + 2);
+            cursor = newline < 0 ? source.length : newline + 1;
+            continue;
+        }
+        if (char === "/" && source[cursor + 1] === "*") {
+            const end = source.indexOf("*/", cursor + 2);
+            if (end < 0)
+                return source.length;
+            cursor = end + 2;
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`" || char === "[") {
+            if (char === "[") {
+                const end = source.indexOf("]", cursor + 1);
+                cursor = end < 0 ? source.length : end + 1;
+                continue;
+            }
+            cursor = skipSqlQuote(source, cursor, char);
+            continue;
+        }
+        if (char === ";")
+            return cursor + 1;
+        cursor += 1;
+    }
+    return cursor;
+}
+export function isExtensionDatabaseTransactionSql(sql) {
+    const source = sql;
+    let index = 0;
+    while (index < source.length) {
+        while (index < source.length && isSqlWhitespace(source[index] ?? "")) {
+            index += 1;
+        }
+        if (index >= source.length)
+            return false;
+        if (source[index] === "-" && source[index + 1] === "-") {
+            const newline = source.indexOf("\n", index + 2);
+            index = newline < 0 ? source.length : newline + 1;
+            continue;
+        }
+        if (source[index] === "/" && source[index + 1] === "*") {
+            const end = source.indexOf("*/", index + 2);
+            if (end < 0)
+                return false;
+            index = end + 2;
+            continue;
+        }
+        if (source[index] === ";") {
+            index += 1;
+            continue;
+        }
+        const first = source[index] ?? "";
+        if (isSqlWordChar(first) && !(first >= "0" && first <= "9")) {
+            let end = index + 1;
+            while (end < source.length && isSqlWordChar(source[end] ?? ""))
+                end += 1;
+            const word = source.slice(index, end).toLowerCase();
+            if (extensionDatabaseTransactionKeywords.has(word))
+                return true;
+            index = skipSqlStatementRemainder(source, end);
+            continue;
+        }
+        index = skipSqlStatementRemainder(source, index);
+    }
+    return false;
+}
+const extensionDatabaseExecutingMethods = new Set([
+    "all",
+    "batch",
+    "execute",
+    "get",
+    "run",
+    "values",
+]);
+function rejectedExtensionDatabaseTransaction(error) {
+    let current = error;
+    for (let depth = 0; depth < 5; depth += 1) {
+        if (!(current instanceof Error))
+            return null;
+        if (current.message === extensionDatabaseTransactionErrorMessage) {
+            return current;
+        }
+        current = current.cause;
+    }
+    return null;
+}
+export function createExtensionBackendDatabase(transport, options) {
+    const rejectTransactionSql = options?.rejectTransactionSql !== false;
+    const guardedTransport = {
+        batch: async (statements) => {
+            if (extensionDatabaseStatementsUseTransaction(statements)) {
+                throw new Error(extensionDatabaseTransactionErrorMessage);
+            }
+            return await transport.batch(statements);
+        },
+        execute: async (sql, params, method) => {
+            if (isExtensionDatabaseTransactionSql(sql)) {
+                throw new Error(extensionDatabaseTransactionErrorMessage);
+            }
+            return await transport.execute(sql, params, method);
+        },
+    };
+    const activeTransport = rejectTransactionSql ? guardedTransport : transport;
+    const database = drizzle(activeTransport.execute, activeTransport.batch);
+    return new Proxy(database, {
+        get(target, property, receiver) {
+            if (property === "transaction") {
+                return async () => {
+                    throw new Error(extensionDatabaseTransactionErrorMessage);
+                };
+            }
+            const value = Reflect.get(target, property, receiver);
+            if (typeof property !== "string" ||
+                typeof value !== "function" ||
+                !extensionDatabaseExecutingMethods.has(property)) {
+                return value;
+            }
+            return (...args) => {
+                const result = value.apply(target, args);
+                const then = result?.then;
+                if (typeof then !== "function")
+                    return result;
+                return new Proxy(result, {
+                    get(inner, key, receiver) {
+                        if (key !== "then")
+                            return Reflect.get(inner, key, receiver);
+                        return (onFulfilled, onRejected) => then.call(inner, onFulfilled, (error) => {
+                            const transactionError = rejectedExtensionDatabaseTransaction(error);
+                            const unwrapped = transactionError ?? error;
+                            if (onRejected)
+                                return onRejected(unwrapped);
+                            throw unwrapped;
+                        });
+                    },
+                });
+            };
+        },
+    });
 }
 export function getExtensionAgentHandleKey(slug) {
     return slug
@@ -9,6 +189,7 @@ export function getExtensionAgentHandleKey(slug) {
         .map((segment, index) => index === 0 ? segment : `${segment[0]?.toUpperCase()}${segment.slice(1)}`)
         .join("");
 }
+export { createExtensionClientRequestId, extensionClientRequestId, extensionDatabaseRequestId, extensionDatabaseStatementsKey, extensionRequestNamespaceHex, nextExtensionDatabaseRequestId, extensionRequestTimestampMs, extensionScopedId, } from "./request-id.js";
 export function defineDurableObjects(backend, durableObjects) {
     for (const [className, definition] of Object.entries(durableObjects)) {
         if (!/^[a-z][a-z0-9-]{0,63}$/u.test(className)) {

package/dist/request-id.d.ts

@@ -0,0 +1,27 @@
+export declare function extensionUuidV5(name: string): string;
+export declare const extensionRequestNamespaceHex: string;
+export declare function extensionDatabaseStatementsKey(statements: ReadonlyArray<{
+    method: string;
+    params?: readonly unknown[];
+    sql: string;
+}>): string;
+export declare function extensionDatabaseRequestId(input: {
+    clientRequestId: string;
+    occurrence: number;
+    resourceKey: string;
+    statementsKey: string;
+}): string;
+export declare function nextExtensionDatabaseRequestId(input: {
+    clientRequestId: string;
+    occurrences: Map<string, number>;
+    resourceKey: string;
+    statements: ReadonlyArray<{
+        method: string;
+        params?: readonly unknown[];
+        sql: string;
+    }>;
+}): string;
+export declare function extensionScopedId(clientRequestId: string, name: string): string;
+export declare function extensionClientRequestId(seed: string): string;
+export declare function extensionRequestTimestampMs(requestId: string): number;
+export declare function createExtensionClientRequestId(): string;

package/dist/request-id.js

@@ -0,0 +1,160 @@
+const EXTENSION_REQUEST_NAMESPACE = "9c6b5b2e-1f4a-5d3c-8e7b-6a5d4c3b2a19";
+function leftRotate(value, shift) {
+    return ((value << shift) | (value >>> (32 - shift))) >>> 0;
+}
+function sha1(bytes) {
+    const bitLength = bytes.length * 8;
+    const paddedLength = ((bytes.length + 9 + 63) >> 6) << 6;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x100000000));
+    view.setUint32(paddedLength - 4, bitLength >>> 0);
+    let hash0 = 0x67452301;
+    let hash1 = 0xefcdab89;
+    let hash2 = 0x98badcfe;
+    let hash3 = 0x10325476;
+    let hash4 = 0xc3d2e1f0;
+    const words = new Uint32Array(80);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let index = 0; index < 16; index += 1) {
+            words[index] = view.getUint32(offset + index * 4);
+        }
+        for (let index = 16; index < 80; index += 1) {
+            words[index] = leftRotate((words[index - 3] ^
+                words[index - 8] ^
+                words[index - 14] ^
+                words[index - 16]) >>>
+                0, 1);
+        }
+        let a = hash0;
+        let b = hash1;
+        let c = hash2;
+        let d = hash3;
+        let e = hash4;
+        for (let index = 0; index < 80; index += 1) {
+            let mixed = 0;
+            let constant = 0;
+            if (index < 20) {
+                mixed = (b & c) | ((~b >>> 0) & d);
+                constant = 0x5a827999;
+            }
+            else if (index < 40) {
+                mixed = b ^ c ^ d;
+                constant = 0x6ed9eba1;
+            }
+            else if (index < 60) {
+                mixed = (b & c) | (b & d) | (c & d);
+                constant = 0x8f1bbcdc;
+            }
+            else {
+                mixed = b ^ c ^ d;
+                constant = 0xca62c1d6;
+            }
+            const next = (leftRotate(a, 5) + mixed + e + constant + words[index]) >>> 0;
+            e = d;
+            d = c;
+            c = leftRotate(b, 30);
+            b = a;
+            a = next;
+        }
+        hash0 = (hash0 + a) >>> 0;
+        hash1 = (hash1 + b) >>> 0;
+        hash2 = (hash2 + c) >>> 0;
+        hash3 = (hash3 + d) >>> 0;
+        hash4 = (hash4 + e) >>> 0;
+    }
+    const digest = new Uint8Array(20);
+    const digestView = new DataView(digest.buffer);
+    digestView.setUint32(0, hash0);
+    digestView.setUint32(4, hash1);
+    digestView.setUint32(8, hash2);
+    digestView.setUint32(12, hash3);
+    digestView.setUint32(16, hash4);
+    return digest;
+}
+function bytesToUuid(bytes) {
+    const hex = [...bytes]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function uuidToBytes(uuid) {
+    const hex = uuid.replaceAll("-", "");
+    const bytes = new Uint8Array(16);
+    for (let index = 0; index < 16; index += 1) {
+        bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+    }
+    return bytes;
+}
+export function extensionUuidV5(name) {
+    const namespace = uuidToBytes(EXTENSION_REQUEST_NAMESPACE);
+    const nameBytes = new TextEncoder().encode(name);
+    const input = new Uint8Array(namespace.length + nameBytes.length);
+    input.set(namespace);
+    input.set(nameBytes, namespace.length);
+    const digest = sha1(input).slice(0, 16);
+    digest[6] = ((digest[6] ?? 0) & 0x0f) | 0x50;
+    digest[8] = ((digest[8] ?? 0) & 0x3f) | 0x80;
+    return bytesToUuid(digest);
+}
+export const extensionRequestNamespaceHex = EXTENSION_REQUEST_NAMESPACE.replaceAll("-", "");
+export function extensionDatabaseStatementsKey(statements) {
+    return statements
+        .map((statement) => `${statement.method}\n${statement.sql}\n${JSON.stringify(statement.params ?? [])}`)
+        .join("\n;");
+}
+export function extensionDatabaseRequestId(input) {
+    return extensionUuidV5(`${input.clientRequestId}\n${input.resourceKey}\n${input.occurrence}\n${input.statementsKey}`);
+}
+export function nextExtensionDatabaseRequestId(input) {
+    const statementsKey = extensionDatabaseStatementsKey(input.statements);
+    const occurrenceKey = `${input.resourceKey}\n${statementsKey}`;
+    const occurrence = input.occurrences.get(occurrenceKey) ?? 0;
+    input.occurrences.set(occurrenceKey, occurrence + 1);
+    return extensionDatabaseRequestId({
+        clientRequestId: input.clientRequestId,
+        occurrence,
+        resourceKey: input.resourceKey,
+        statementsKey,
+    });
+}
+export function extensionScopedId(clientRequestId, name) {
+    return extensionUuidV5(`${clientRequestId}\n${name}`);
+}
+export function extensionClientRequestId(seed) {
+    return extensionUuidV5(`client\n${seed}`);
+}
+export function extensionRequestTimestampMs(requestId) {
+    const hex = requestId.replaceAll("-", "").toLowerCase();
+    if (hex.length === 32 && hex[12] === "7") {
+        const timestamp = Number.parseInt(hex.slice(0, 12), 16);
+        if (Number.isSafeInteger(timestamp))
+            return timestamp;
+    }
+    let hash = 2166136261;
+    for (let index = 0; index < requestId.length; index += 1) {
+        hash ^= requestId.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+}
+export function createExtensionClientRequestId() {
+    const bytes = new Uint8Array(16);
+    const cryptoApi = globalThis.crypto;
+    if (!cryptoApi?.getRandomValues) {
+        throw new Error("Extension request id source is unavailable.");
+    }
+    cryptoApi.getRandomValues(bytes);
+    const timestamp = Date.now();
+    bytes[0] = Math.floor(timestamp / 0x10000000000) & 0xff;
+    bytes[1] = Math.floor(timestamp / 0x100000000) & 0xff;
+    bytes[2] = Math.floor(timestamp / 0x1000000) & 0xff;
+    bytes[3] = Math.floor(timestamp / 0x10000) & 0xff;
+    bytes[4] = Math.floor(timestamp / 0x100) & 0xff;
+    bytes[5] = timestamp & 0xff;
+    bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x70;
+    bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+    return bytesToUuid(bytes);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gea-ai/extensions-sdk",
-  "version": "0.1.261014-alpha.0",
+  "version": "0.1.261016-alpha.0",
   "private": false,
   "homepage": "https://musegea.com/developers/extensions",
   "license": "Apache-2.0",
@@ -50,7 +50,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@gea-ai/contract": "0.1.261014-alpha.0",
+    "@gea-ai/contract": "0.1.261016-alpha.0",
     "@tanstack/react-query": "5.102.0",
     "zod": "4.3.6"
   },