@opengeni/sdk 3.1.0 → 3.1.2

package/dist/site-document.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/site-http.d.ts

@@ -0,0 +1,17 @@
+/** HTTP transport for the ordinary SDK. One response port per request keeps
+ * event streams incremental and cancellation independent of other requests. */
+export declare const SITE_HTTP = "opengeni.site.http";
+export declare const SITE_WORKSPACE = "site-host";
+export type SiteHttpRequest = {
+    type: typeof SITE_HTTP;
+    requestId: string;
+    path: string;
+    method: string;
+    headers: [string, string][];
+    /** Text for JSON requests; bytes for Site Data file uploads. */
+    body?: string | ArrayBuffer;
+};
+export { siteSessionPath } from "@opengeni/contracts/site-session-http";
+export declare function isSiteHttpRequest(value: unknown): value is SiteHttpRequest;
+export declare function serveSiteHttp(message: SiteHttpRequest, port: MessagePort, fetchResponse: (request: SiteHttpRequest, signal: AbortSignal) => Promise<Response>, signal: AbortSignal): Promise<void>;
+export declare function sitePortFetch(port: MessagePort, input: RequestInfo | URL, init?: RequestInit): Promise<Response>;

package/dist/site-sql.d.ts

@@ -0,0 +1,31 @@
+export type OpenGeniSiteSqlErrorCode = "validation" | "not_found" | "forbidden"
+/** This viewer may not do this on this Site (a role the Site's rules exclude). */
+ | "not_available_for_viewer" | "conflict" | "quota_exceeded" | "rate_limited" | "sql_error" | "unavailable" | "disabled" | "site_sql_unsupported" | "request_failed";
+export declare class OpenGeniSiteSqlError extends Error {
+    readonly code: OpenGeniSiteSqlErrorCode;
+    readonly status: number;
+    readonly details: Record<string, unknown>;
+    constructor(code: OpenGeniSiteSqlErrorCode, message: string, status: number, details?: Record<string, unknown>);
+}
+/** A parameter value. Booleans bind as 1 and 0. */
+export type OpenGeniSiteSqlValue = string | number | boolean | null;
+export type OpenGeniSiteSqlResult<Row extends Record<string, unknown> = Record<string, unknown>> = {
+    columns: string[];
+    /** Rows keyed by column name; blobs come back as `{ $base64: string }`. */
+    rows: Row[];
+    /** True when the query's row or size limit cut the result short. */
+    truncated: boolean;
+    rowsRead: number;
+    rowsWritten: number;
+};
+export type OpenGeniSiteSql = {
+    /**
+     * Run the named query `name` with `params` (names without the colon). Do
+     * not pass `viewer` or any `viewer_*` parameter: the host binds them.
+     */
+    run<Row extends Record<string, unknown> = Record<string, unknown>>(name: string, params?: Record<string, OpenGeniSiteSqlValue>): Promise<OpenGeniSiteSqlResult<Row>>;
+};
+type SiteSqlFetch = (path: string, init: RequestInit) => Promise<Response>;
+/** Build `site.sql` over a Site HTTP fetch; `ready` says whether the host serves the pinned Site. */
+export declare function createOpenGeniSiteSql(fetchSite: SiteSqlFetch, ready: () => Promise<boolean>): OpenGeniSiteSql;
+export {};

package/dist/site-tool-bridge.d.ts

@@ -0,0 +1,57 @@
+import { type SiteHttpRequest } from "./site-http.js";
+import type { OpenGeniSiteToolCatalog } from "./site.js";
+import type { OpenGeniWorkspaceTools } from "./tools.js";
+import type { ToolGatewayCallRequest, ToolGatewayCallResponse, ToolGatewayIdentity, ToolGatewayResolveRequest, ToolGatewayResolvedTool, ToolGatewayInvokeRequest, ToolGatewayInvokeResponse } from "./types.js";
+export type SiteToolCallRequest = ToolGatewayCallRequest & {
+    siteArtifactId: string;
+    siteVersionId: string;
+};
+export type SiteToolCaller = (input: {
+    workspaceId: string;
+    request: ToolGatewayCallRequest & Partial<Pick<SiteToolCallRequest, "siteArtifactId" | "siteVersionId">>;
+    signal: AbortSignal;
+}) => Promise<ToolGatewayCallResponse>;
+export type SiteToolBridge = {
+    resolve?: (request: ToolGatewayResolveRequest, options: {
+        signal: AbortSignal;
+    }) => Promise<ToolGatewayResolvedTool>;
+    invoke?: (request: ToolGatewayInvokeRequest, options: {
+        signal: AbortSignal;
+    }) => Promise<ToolGatewayInvokeResponse>;
+    fetch?: (request: SiteHttpRequest, signal: AbortSignal) => Promise<Response>;
+    /** The host serves Site Data for its pinned published Site through `fetch`. */
+    siteData?: boolean;
+    catalog: (options: {
+        signal: AbortSignal;
+    }) => Promise<OpenGeniSiteToolCatalog>;
+    call: (request: ToolGatewayCallRequest, options: {
+        signal: AbortSignal;
+    }) => Promise<ToolGatewayCallResponse>;
+};
+export type CreateSiteToolBridgeOptions = {
+    workspaceTools: Pick<OpenGeniWorkspaceTools, "$catalog"> & Partial<Pick<OpenGeniWorkspaceTools, "$targetProtocol" | "$resolve" | "$invoke" | "$manifest">>;
+    workspaceId: string;
+    callTool: SiteToolCaller;
+    isCatalogStale?: (error: unknown) => boolean;
+    /** Optional authenticated host transport for the host-bound workspace API.
+     * Omit to expose tools only. Site-provided authorization headers are never forwarded. */
+    fetchResponse?: (path: string, init: RequestInit) => Promise<Response>;
+} & ({
+    artifactId: string;
+    siteVersionId: string;
+    requestedTools: readonly ToolGatewayIdentity[];
+} | {
+    artifactId?: never;
+    siteVersionId?: never;
+    requestedTools?: never;
+});
+/** Host-side bridge for the opaque Site frame. Supply an authenticated transport;
+ * the server independently checks live viewer access and the exact Site version.
+ * Recreate on actor/version change. Never take these pinned fields from HTML.
+ *
+ * `fetch` forwards only the `SITE_OPERATIONS` allowlist (`siteSessionPath`);
+ * every other route is refused before a request is made. Each bridge is one
+ * frame: it mints a frame id, so a frame without a published Site reaches only
+ * the sessions it started. */
+export declare function createSiteToolBridge(input: CreateSiteToolBridgeOptions): SiteToolBridge;
+export declare function isSiteCatalogStaleError(error: unknown): boolean;

package/dist/site.d.ts

@@ -0,0 +1,182 @@
+export { createSiteToolBridge, isSiteCatalogStaleError } from "./site-tool-bridge.js";
+export type { SiteToolBridge, SiteToolCaller, SiteToolCallRequest, CreateSiteToolBridgeOptions, } from "./site-tool-bridge.js";
+import { type OpenGeniWorkspaceTools } from "./tools.js";
+import { OpenGeniClient } from "./client.js";
+import { type OpenGeniSiteData, type OpenGeniSiteFiles } from "./site-data.js";
+import { type OpenGeniSiteSql } from "./site-sql.js";
+export { OpenGeniSiteSqlError, type OpenGeniSiteSql, type OpenGeniSiteSqlErrorCode, type OpenGeniSiteSqlResult, type OpenGeniSiteSqlValue, } from "./site-sql.js";
+export { OpenGeniSiteDataError, SITE_DATA_PATH_PREFIX, type OpenGeniSiteData, type OpenGeniSiteDataCollection, type OpenGeniSiteDataErrorCode, type OpenGeniSiteDataFilter, type OpenGeniSiteDataListOptions, type OpenGeniSiteDataOperation, type OpenGeniSiteDataPage, type OpenGeniSiteDataRecord, type OpenGeniSiteDataRef, type OpenGeniSiteDataScalar, type OpenGeniSiteDataWriteResult, type OpenGeniSiteFile, type OpenGeniSiteFiles, } from "./site-data.js";
+export { isSiteHttpRequest, serveSiteHttp, siteSessionPath, type SiteHttpRequest, } from "./site-http.js";
+import type { SiteViewer, SiteViewerCapabilities } from "@opengeni/contracts";
+import type { ToolGatewayCallRequest, ToolGatewayCallResponse, ToolGatewayCatalog, ToolGatewayDeclarationsResponse, ToolGatewayResolveRequest, ToolGatewayResolvedTool, ToolGatewayInvokeRequest, ToolGatewayInvokeResponse } from "./types.js";
+export declare const OPENGENI_SITE_BRIDGE_VERSION: 2;
+export declare const OPENGENI_SITE_BRIDGE_CONNECT: "opengeni.site.connect";
+export declare const OPENGENI_SITE_BRIDGE_READY: "opengeni.site.ready";
+export declare const OPENGENI_SITE_BRIDGE_REQUEST: "opengeni.site.request";
+export declare const OPENGENI_SITE_BRIDGE_RESPONSE: "opengeni.site.response";
+export declare const OPENGENI_SITE_BRIDGE_CANCEL: "opengeni.site.cancel";
+export declare const OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL: "__opengeniSiteBridgeBootstrapV2";
+export declare const OPENGENI_SITE_LOCAL_CODEMODE_PATH: "/__opengeni/site-tools";
+/** Bridge request method that returns the viewer (advertised by `viewer: 1`). */
+export declare const OPENGENI_SITE_BRIDGE_VIEWER_METHOD: "viewer";
+/** Bridge request method that asks the host to sign the viewer in (advertised by `viewer: 1`). */
+export declare const OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD: "auth.signIn";
+/**
+ * The person viewing a Site, as the host reports it. Guests of public
+ * published Sites have no name or email. `id` is stable per Site and is the
+ * Site Data owner principal; it is not an Opengeni subject id usable elsewhere.
+ */
+export type OpenGeniSiteViewer = SiteViewer;
+/**
+ * What the current viewer may do on this published Site, so a page can hide
+ * features instead of failing: `agent`, `workspaceTools` (workspace members
+ * only), `siteData` (`"guest"` when a collection's guest access applies),
+ * the Site SQL query audiences the viewer may call, and `viewAs` while a
+ * member previews the Site as a visitor. Anything refused at call time
+ * still answers with the error code `not_available_for_viewer`.
+ */
+export type OpenGeniSiteCapabilities = SiteViewerCapabilities;
+/** Result of `site.auth.signIn()`: `started` is true when the host began a sign-in navigation. */
+export type OpenGeniSiteSignInResult = {
+    started: boolean;
+};
+export type OpenGeniSiteBridgeConnectMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_CONNECT;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+};
+export type OpenGeniSiteBridgeReadyMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_READY;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+    targetTools?: 1;
+    /** The host serves Site Data for this published Site over the Site HTTP channel. */
+    siteData?: 1;
+    /** The host answers the `viewer` and `auth.signIn` bridge methods. */
+    viewer?: 1;
+};
+/** Site-originated calls cannot carry host-only approval tokens or Site-version authority. */
+export type OpenGeniSiteToolCallRequest = Omit<ToolGatewayCallRequest, "approvalToken" | "siteArtifactId" | "siteVersionId">;
+/** Host-filtered catalog projection. Tenant routing context never enters Site code. */
+export type OpenGeniSiteToolCatalog = Omit<ToolGatewayCatalog, "accountId" | "workspaceId">;
+export type OpenGeniSiteWorkspaceTools = OpenGeniWorkspaceTools<OpenGeniSiteToolCatalog>;
+export type OpenGeniSiteBridgeRequestMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_REQUEST;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+    requestId: string;
+} & ({
+    method: "catalog";
+} | {
+    method: "call";
+    payload: OpenGeniSiteToolCallRequest;
+} | {
+    method: "declarations";
+} | {
+    method: "resolve";
+    payload: ToolGatewayResolveRequest;
+} | {
+    method: "invoke";
+    payload: ToolGatewayInvokeRequest;
+} | {
+    method: typeof OPENGENI_SITE_BRIDGE_VIEWER_METHOD;
+} | {
+    method: typeof OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD;
+});
+export type OpenGeniSiteBridgeCancelMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_CANCEL;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+    requestId: string;
+};
+export type OpenGeniSiteBridgeResponseMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_RESPONSE;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+    requestId: string;
+} & ({
+    ok: true;
+    value: OpenGeniSiteToolCatalog | ToolGatewayCallResponse | ToolGatewayDeclarationsResponse | ToolGatewayResolvedTool | ToolGatewayInvokeResponse | OpenGeniSiteViewer | OpenGeniSiteSignInResult;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        outcomeUnknown?: boolean;
+    };
+});
+export type OpenGeniSiteClient = {
+    /** Ordinary SDK, including React session/composer methods and SSE streams. */
+    readonly client: OpenGeniClient;
+    /** Host-bound routing alias, not a credential or a caller-selected tenant. */
+    readonly workspaceId: string;
+    /** Workspace-bound typed facade. The parent host owns workspace identity and credentials. */
+    readonly tools: OpenGeniSiteWorkspaceTools;
+    /** Persistent collections of JSON records that belong to this published Site. */
+    readonly data: OpenGeniSiteData;
+    /** Files stored with this published Site. */
+    readonly files: OpenGeniSiteFiles;
+    /**
+     * The Site's optional SQL database: run the named queries its owner
+     * defined (`await site.sql.run("top_votes", { limit: 10 })`). Served by
+     * hosts bound to a published Site, like `data`; the owner turns it on.
+     */
+    readonly sql: OpenGeniSiteSql;
+    /**
+     * The person viewing this Site, resolved once from the host and cached for
+     * the life of the client (`await site.viewer`). In the console this is the
+     * signed-in workspace member; on a published Site it is the signed-in
+     * viewer or an anonymous guest (`kind: "guest"`, `signedIn: false`).
+     * Resolves `null` when the host does not report viewers (older hosts and
+     * local previews). A failed lookup is not cached; reading again retries.
+     */
+    readonly viewer: Promise<OpenGeniSiteViewer | null>;
+    /**
+     * What this viewer may do on the published Site (`await site.capabilities`),
+     * resolved once and cached like `viewer`. Resolves `null` when the host
+     * does not report it (the console, older hosts and local previews): treat
+     * null as "everything the Site declares", as for a workspace member.
+     */
+    readonly capabilities: Promise<OpenGeniSiteCapabilities | null>;
+    readonly auth: {
+        /**
+         * Ask the host to sign the viewer in. On a published Site the host
+         * navigates the whole page to sign-in and returns `{ started: true }`;
+         * the page reloads signed in afterwards. Resolves `{ started: false }`
+         * when the viewer is already signed in or the host has no sign-in.
+         */
+        signIn(): Promise<OpenGeniSiteSignInResult>;
+    };
+    close(): void;
+};
+export type OpenGeniSiteClientOptions = {
+    /** Explicit compatibility with hosts predating targeted tool calls; never an automatic fallback. */
+    toolGatewayMode?: "catalog" | "target";
+    /** Advanced embedding seam; ordinary Sites accept bootstrap only from their exact parent. */
+    parentWindow?: MessageEventSource;
+    /** Advanced embedding seam for listening to the host's document-bound bootstrap message. */
+    siteWindow?: Pick<Window, "parent" | "addEventListener" | "removeEventListener">;
+    /** Test/embedding seam for an already document-bound host bootstrap port. */
+    bootstrapPort?: MessagePort;
+    connectTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    createMessageChannel?: () => MessageChannel;
+    /** Local-preview seam. Top-level pages use this same-origin Codemode proxy automatically. */
+    localCodemodePath?: string | false;
+    /** Test/embedding seam for local-preview requests. */
+    fetch?: typeof globalThis.fetch;
+};
+export declare class OpenGeniSiteBridgeError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly outcomeUnknown: boolean;
+    constructor(code: string, message: string, retryable?: boolean, outcomeUnknown?: boolean);
+}
+/**
+ * Create the browser client used by a Site. Published iframes use the parent
+ * MessagePort; top-level sandbox previews use the same-origin Codemode adapter.
+ * Credentials remain in the selected host and never enter Site code.
+ */
+export declare function createOpenGeniSiteClient(options?: OpenGeniSiteClientOptions): OpenGeniSiteClient;
+export declare function isOpenGeniSiteBridgeConnectMessage(value: unknown): value is OpenGeniSiteBridgeConnectMessage;
+export declare function isOpenGeniSiteBridgeRequestMessage(value: unknown): value is OpenGeniSiteBridgeRequestMessage;
+export declare function isOpenGeniSiteBridgeCancelMessage(value: unknown): value is OpenGeniSiteBridgeCancelMessage;
+/** Strip every host-only field before a call crosses the Site boundary. */
+export declare function sanitizeOpenGeniSiteToolCallRequest(value: ToolGatewayCallRequest): OpenGeniSiteToolCallRequest;
+export declare function sanitizeOpenGeniSiteToolInvokeRequest(value: ToolGatewayInvokeRequest): ToolGatewayInvokeRequest;

package/dist/site.js

@@ -0,0 +1,62 @@
+import {
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL,
+  OPENGENI_SITE_BRIDGE_CANCEL,
+  OPENGENI_SITE_BRIDGE_CONNECT,
+  OPENGENI_SITE_BRIDGE_READY,
+  OPENGENI_SITE_BRIDGE_REQUEST,
+  OPENGENI_SITE_BRIDGE_RESPONSE,
+  OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD,
+  OPENGENI_SITE_BRIDGE_VERSION,
+  OPENGENI_SITE_BRIDGE_VIEWER_METHOD,
+  OPENGENI_SITE_LOCAL_CODEMODE_PATH,
+  OpenGeniSiteBridgeError,
+  OpenGeniSiteDataError,
+  OpenGeniSiteSqlError,
+  SITE_DATA_PATH_PREFIX,
+  createOpenGeniSiteClient,
+  createSiteToolBridge,
+  isOpenGeniSiteBridgeCancelMessage,
+  isOpenGeniSiteBridgeConnectMessage,
+  isOpenGeniSiteBridgeRequestMessage,
+  isSiteCatalogStaleError,
+  isSiteHttpRequest,
+  sanitizeOpenGeniSiteToolCallRequest,
+  sanitizeOpenGeniSiteToolInvokeRequest,
+  serveSiteHttp,
+  siteSessionPath
+} from "./chunk-JXXCTW5W.js";
+import "./chunk-P7UWKORG.js";
+import "./chunk-NEM5N6C6.js";
+import "./chunk-VPVMLM7Q.js";
+import "./chunk-4AHR4KGA.js";
+import "./chunk-KADZ5PGG.js";
+import "./chunk-O7KANXC3.js";
+import "./chunk-7EWT3PV6.js";
+export {
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL,
+  OPENGENI_SITE_BRIDGE_CANCEL,
+  OPENGENI_SITE_BRIDGE_CONNECT,
+  OPENGENI_SITE_BRIDGE_READY,
+  OPENGENI_SITE_BRIDGE_REQUEST,
+  OPENGENI_SITE_BRIDGE_RESPONSE,
+  OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD,
+  OPENGENI_SITE_BRIDGE_VERSION,
+  OPENGENI_SITE_BRIDGE_VIEWER_METHOD,
+  OPENGENI_SITE_LOCAL_CODEMODE_PATH,
+  OpenGeniSiteBridgeError,
+  OpenGeniSiteDataError,
+  OpenGeniSiteSqlError,
+  SITE_DATA_PATH_PREFIX,
+  createOpenGeniSiteClient,
+  createSiteToolBridge,
+  isOpenGeniSiteBridgeCancelMessage,
+  isOpenGeniSiteBridgeConnectMessage,
+  isOpenGeniSiteBridgeRequestMessage,
+  isSiteCatalogStaleError,
+  isSiteHttpRequest,
+  sanitizeOpenGeniSiteToolCallRequest,
+  sanitizeOpenGeniSiteToolInvokeRequest,
+  serveSiteHttp,
+  siteSessionPath
+};
+//# sourceMappingURL=site.js.map

package/dist/site.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/skills.d.ts

@@ -0,0 +1,75 @@
+/** Public shared Skill folder/history shapes; no runtime contracts dependency. */
+export type SkillFile = {
+    path: string;
+    content: string;
+};
+export type SkillScope = "workspace" | "organization" | "user";
+export type SkillRecord = {
+    removalOperationId?: string | null;
+    activationMode: "workspace_managed" | "session_selected";
+    pendingRevisionIds: string[];
+    id: string;
+    stableKey: string;
+    scope: SkillScope;
+    scopeVersion: number;
+    status: string;
+    activeRevisionId: string | null;
+    revisionId: string | null;
+    title: string | null;
+    description: string | null;
+    contentHash: string | null;
+    files: SkillFile[];
+    source: {
+        pluginId: string;
+        facetKey: string;
+        skillFacetId: string;
+    } | null;
+};
+export type SkillSummary = Omit<SkillRecord, "files">;
+export type SkillWriteReceipt = {
+    removed?: boolean | undefined;
+    operationId: string;
+    skillId: string;
+    revisionId: string;
+    outcome: "applied" | "pending" | "preserved";
+    pendingReason?: "approval" | "source_finalization" | undefined;
+    replayed: boolean;
+    decision?: "rejected" | undefined;
+    skillReview?: import("./types.js").SkillReviewReference | undefined;
+};
+export type SkillPublicationReceipt = SkillWriteReceipt & {
+    sourceOperationId: string;
+    activationEventId: string | null;
+};
+export type SkillSourceReleaseReceipt = {
+    skillId: string;
+    revisionId: string | null;
+    disposition: "deactivated" | "preserved" | "inactive";
+    eventId: string | null;
+    warning: string | null;
+};
+export type SaveWorkspaceSkillRequest = {
+    operationId: string;
+    skillId: string;
+    expectedRevisionId: string | null;
+    expectedScopeVersion: number;
+    scope?: SkillScope;
+    stableKey: string;
+    files: SkillFile[];
+    deletions?: string[];
+    reason: string;
+};
+export type ApplyWorkspaceSkillRevisionRequest = {
+    removalOperationId?: string;
+    operationId: string;
+    revisionId: string;
+    expectedRevisionId: string | null;
+    expectedScopeVersion: number;
+    reason: string;
+};
+export type RemoveWorkspaceSkillRequest = {
+    operationId: string;
+    expectedRevisionId: string | null;
+    expectedScopeVersion: number;
+    reason: string;
+};

package/dist/sse.d.ts

@@ -1,7 +1,7 @@
 /**
  * Minimal incremental Server-Sent Events parser over a byte stream.
  *
- * Implements the parts of the SSE wire format OpenGeni uses: `id`, `event`,
+ * Implements the parts of the SSE wire format Opengeni uses: `id`, `event`,
  * and `data` fields, multi-line data, comment lines, and both LF and CRLF
  * line endings. Messages without any `data` (comments, id-only blocks) are
  * not emitted.

package/dist/stream.d.ts

@@ -61,3 +61,5 @@ export declare function streamSessionEvents(transport: SessionEventStreamTranspo
 export declare function runBeforeLive(beforeLive: (() => void | Promise<void>) | undefined, timeoutMs: number, signal: AbortSignal | undefined): Promise<void>;
 export declare function jitteredDelay(delayMs: number, ratio: number): number;
 export declare function withStreamInactivityTimeout(stream: ReadableStream<Uint8Array>, timeoutMs: number, signal: AbortSignal | undefined): ReadableStream<Uint8Array>;
+/** Trusted SSE coverage attached non-enumerably to a streamed event. */
+export declare function sessionEventStreamCoveredThrough(event: SessionEvent): number | null;

package/dist/tenant-workspaces.d.ts

@@ -0,0 +1,47 @@
+import type { OpenGeniEmbeddingClient } from "./embedding-client.js";
+import type { Permission } from "./types.js";
+export type WorkspaceIdTarget = {
+    /**
+     * Your tenant id. With user isolation and no tenant, the user gets one
+     * workspace of their own, independent of any tenant.
+     */
+    tenant?: string | undefined;
+    user?: string | undefined;
+    /** External user identity source; defaults to the resolver's source. */
+    source?: string | undefined;
+};
+export type WorkspaceIdOptions = {
+    /**
+     * `tenant`: one workspace per tenant. `user`: a separate workspace for the
+     * user (per tenant when a tenant is given, otherwise one per user).
+     */
+    isolation: "tenant" | "user";
+};
+export type WorkspaceIdResolverOptions = {
+    /** The organization id, or a lazy lookup (for example derived from the API key). */
+    organizationId: string | (() => Promise<string>);
+    source: string;
+    /** Workspace display name; receives the tenant id, or the user id for a per-user workspace. */
+    workspaceName?: ((tenant: string) => string) | undefined;
+    /**
+     * Per-user workspaces only (user isolation): permissions for the one member
+     * this resolver adds explicitly, its owner. Replaces the defaults: workspace
+     * read, session create/read/control (including sending messages), file
+     * upload/read, and attaching the host's per-session MCP servers. No admin
+     * permissions are granted by default. Tenant workspaces rely on the API,
+     * which adds a missing member with those defaults on their first request.
+     * Existing grants are never changed here; change them with
+     * `updateExternalWorkspaceMember`. The organization API key must also allow
+     * the selected permissions.
+     */
+    memberPermissions?: readonly Permission[] | undefined;
+};
+/**
+ * Server-only workspace resolution using external workspace provisioning.
+ * Workspaces are created on first use and cached. A tenant workspace's members
+ * are added by the API on their first `asUser` request (the organization key
+ * needs `members:manage`). A per-user workspace stays single-user: the API
+ * never auto-admits anyone there, and this resolver adds its owner with a
+ * stable onboarding key, so retries never restore a revoked grant.
+ */
+export declare function createWorkspaceIdResolver(client: Pick<OpenGeniEmbeddingClient, "ensureWorkspace" | "addExternalWorkspaceMember">, options: WorkspaceIdResolverOptions): (target: WorkspaceIdTarget, resolution: WorkspaceIdOptions) => Promise<string>;

package/dist/tenant-workspaces.js

@@ -0,0 +1,8 @@
+import {
+  createWorkspaceIdResolver
+} from "./chunk-XA7HVIHI.js";
+import "./chunk-7EWT3PV6.js";
+export {
+  createWorkspaceIdResolver
+};
+//# sourceMappingURL=tenant-workspaces.js.map

package/dist/tenant-workspaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tool-auth.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Per-user credentials for a product's own MCP tool server.
+ *
+ * `createSessionProxyHandler({ toolServer })` mints a short-lived token for the
+ * user its `resolve` hook authenticated, attaches it to each session it creates,
+ * and refreshes it on every message, approval, and answer. The product's MCP
+ * endpoint calls {@link verifyToolRequest} on every request and scopes all data
+ * access to the returned identity, never to ids the model supplied.
+ *
+ * Wire format (for non-Node verifiers): an HS256 JWT in `Authorization: Bearer`,
+ * signed with the hex key from {@link deriveToolTokenKey} (`HMAC-SHA256(key =
+ * secret, message = "opengeni-tool-token:v1")`, where `secret` is
+ * `OPENGENI_API_KEY` unless configured). Give a non-Node verifier that derived
+ * key, never the organization key. Claims: `iss` = `"opengeni-session-proxy"`,
+ * `aud` = the tool server URL, `sub` = the external user id, `workspace_id`,
+ * `source`, optional `tenant`, `iat`, `exp`.
+ */
+/** `iss` of every tool token. */
+export declare const TOOL_TOKEN_ISSUER = "opengeni-session-proxy";
+/** HMAC message used to derive the signing key from the secret. */
+export declare const TOOL_TOKEN_KEY_LABEL = "opengeni-tool-token:v1";
+/** Default token lifetime: 24 hours, refreshed on every message, approval, and answer. */
+export declare const TOOL_TOKEN_DEFAULT_TTL_SECONDS: number;
+/** Default `toolServer.url` and `verifyToolRequest` audience. */
+export declare const TOOL_SERVER_URL_ENV = "OPENGENI_TOOL_SERVER_URL";
+/** The user a verified tool request acts for. */
+export type ToolRequestIdentity = {
+    /** External user id the session proxy's `resolve` hook authenticated. */
+    user: string;
+    /** Tenant from `resolve`, when it returned one. */
+    tenant?: string | undefined;
+    workspaceId: string;
+    /** External identity source (same as the proxy's `asUser` source). */
+    source: string;
+    expiresAt: Date;
+};
+export type VerifyToolRequestOptions = {
+    /** Signing secret. Defaults to `OPENGENI_API_KEY`; must match the proxy's. */
+    secret?: string | undefined;
+    /**
+     * Exact tool server URL the token must be issued for (the proxy's
+     * `toolServer.url`). Defaults to `OPENGENI_TOOL_SERVER_URL`.
+     */
+    audience?: string | undefined;
+};
+/** A Web `Request`, or a Node/Express request (`headers` plus `originalUrl`/`url`). */
+export type ToolRequestLike = Request | {
+    headers: Record<string, string | string[] | undefined>;
+    originalUrl?: string | undefined;
+    url?: string | undefined;
+};
+/** Missing, expired, forged, or misdirected tool token. Respond with `status` (401). */
+export declare class ToolRequestError extends Error {
+    readonly code: string;
+    readonly status = 401;
+    constructor(code: string);
+    /** A ready 401 response with a `WWW-Authenticate: Bearer` challenge. */
+    toResponse(): Response;
+}
+/**
+ * Verify the tool token on one MCP request and return who it acts for.
+ * Throws {@link ToolRequestError} (401) for every invalid token. Call it on
+ * every request, before any tool runs.
+ *
+ * ```ts
+ * const user = await verifyToolRequest(request); // { user, tenant, workspaceId }
+ * ```
+ */
+export declare function verifyToolRequest(request: ToolRequestLike, options?: VerifyToolRequestOptions): Promise<ToolRequestIdentity>;
+/** Mint one tool token. The session proxy calls this; products rarely need to. */
+export declare function mintToolToken(input: {
+    /** Tool server URL; becomes `aud`. */
+    audience: string;
+    user: string;
+    tenant?: string | undefined;
+    workspaceId: string;
+    source: string;
+    secret?: string | undefined;
+    ttlSeconds?: number | undefined;
+}): Promise<string>;
+/**
+ * The hex HS256 key tool tokens are signed with. Give this (not the
+ * organization key) to a tool server written in Python, Ruby, Go, and so on.
+ */
+export declare function deriveToolTokenKey(secret?: string): Promise<string>;
+/** The configured secret, else `OPENGENI_API_KEY`. Throws when neither is set. */
+export declare function resolveToolTokenSecret(secret: string | undefined): string;

package/dist/tool-auth.js

@@ -0,0 +1,23 @@
+import {
+  TOOL_SERVER_URL_ENV,
+  TOOL_TOKEN_DEFAULT_TTL_SECONDS,
+  TOOL_TOKEN_ISSUER,
+  TOOL_TOKEN_KEY_LABEL,
+  ToolRequestError,
+  deriveToolTokenKey,
+  mintToolToken,
+  resolveToolTokenSecret,
+  verifyToolRequest
+} from "./chunk-QGEIL4TR.js";
+export {
+  TOOL_SERVER_URL_ENV,
+  TOOL_TOKEN_DEFAULT_TTL_SECONDS,
+  TOOL_TOKEN_ISSUER,
+  TOOL_TOKEN_KEY_LABEL,
+  ToolRequestError,
+  deriveToolTokenKey,
+  mintToolToken,
+  resolveToolTokenSecret,
+  verifyToolRequest
+};
+//# sourceMappingURL=tool-auth.js.map

package/dist/tool-auth.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tool-display-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDisplayMetadata } from "@opengeni/contracts";
+/** Browser/native-safe event projection; do not import server schema runtimes. */
+export declare function parseToolDisplayMetadata(value: unknown): ToolDisplayMetadata | undefined;

package/dist/tools-37DCTCNZ.js

@@ -0,0 +1,12 @@
+import {
+  OpenGeniToolCallError,
+  OpenGeniToolReapprovalRequiredError,
+  OpenGeniToolsClient
+} from "./chunk-P7UWKORG.js";
+import "./chunk-7EWT3PV6.js";
+export {
+  OpenGeniToolCallError,
+  OpenGeniToolReapprovalRequiredError,
+  OpenGeniToolsClient
+};
+//# sourceMappingURL=tools-37DCTCNZ.js.map

package/dist/tools-37DCTCNZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}