@opengeni/sdk 3.3.2 → 3.4.0

package/dist/browser.d.ts

@@ -1,6 +1,11 @@
 /** Browser-console client. Optional SDK surfaces must not enter this eager graph. */
 export { OpenGeniClient as OpenGeniBrowserClient } from "./client.js";
-export type { FetchLike, GetSessionOptions, OpenGeniClientOptions, OpenGeniRequestOptions, SendMessageInput, SteerMessageResult, TranscribeAudioInput, WorkspaceControlEventPage, } from "./client.js";
-export { OpenGeniApiContractMismatchError, OpenGeniApiError, OpenGeniSessionListCursorError, OpenGeniStreamError, isRetryableStreamError, } from "./errors.js";
+export type { SessionMessageSearchRequest, SessionMessageSearchMatch, SessionMessageSearchResponse, SessionMessagePreview, SessionMessagePreviewReference, } from "./session-message-search.js";
+export { OpenGeniToolCallError, OpenGeniToolReapprovalRequiredError, OpenGeniToolsClient, } from "./tools.js";
+export type { OpenGeniGeneratedTools, OpenGeniDynamicToolNode, OpenGeniToolCallOptions, OpenGeniToolFunction, OpenGeniToolsFacade, OpenGeniWorkspaceTools, } from "./tools.js";
+export type { FetchLike, FetchResponse, GetSessionOptions, OpenGeniClientOptions, OpenGeniRequestOptions, SendMessageInput, SteerMessageResult, TranscribeAudioInput, WorkspaceControlEventPage, } from "./client.js";
+export { OpenGeniApiContractMismatchError, OpenGeniApiError, OpenGeniSetupError, OpenGeniAllowanceExhaustedError, OpenGeniSessionUsageLimitReachedError, OpenGeniSessionUsageLimitUnsupportedError, OpenGeniSecureContextRequiredError, OpenGeniSessionListCursorError, OpenGeniStreamError, formatErrorMessage, isRetryableStreamError, } from "./errors.js";
+export type { OpenGeniSecureContextRequiredReason } from "./errors.js";
 export { resolveWorkspaceVoiceInputEnabled } from "./transcription.js";
 export { OPENGENI_API_CONTRACT_HEADER, OPENGENI_API_CONTRACT_REVISION } from "./types.js";
+export type { ConnectorToolPermission, ConnectorToolPermissionEntry, ConnectorToolPermissionsResponse, UpdateConnectorToolPermissionsRequest, SessionMcpToolPermissionsResponse, UpdateSessionMcpToolPermissionsRequest, } from "./types.js";

package/dist/browser.js

@@ -1,29 +1,51 @@
 import {
   resolveWorkspaceVoiceInputEnabled
-} from "./chunk-VYCTL62C.js";
+} from "./chunk-GZQSWAKD.js";
+import {
+  OpenGeniToolCallError,
+  OpenGeniToolReapprovalRequiredError,
+  OpenGeniToolsClient
+} from "./chunk-P7UWKORG.js";
 import {
   OpenGeniClient
-} from "./chunk-TRNI7KEO.js";
+} from "./chunk-S2NLS3ES.js";
+import "./chunk-X5ITQVXE.js";
+import "./chunk-4AHR4KGA.js";
 import {
   OPENGENI_API_CONTRACT_HEADER,
   OPENGENI_API_CONTRACT_REVISION
-} from "./chunk-JUS2UYRP.js";
-import "./chunk-KKRO2VCP.js";
+} from "./chunk-NCU5OAN7.js";
+import "./chunk-YJCHB7R3.js";
 import {
+  OpenGeniAllowanceExhaustedError,
   OpenGeniApiContractMismatchError,
   OpenGeniApiError,
+  OpenGeniSecureContextRequiredError,
   OpenGeniSessionListCursorError,
+  OpenGeniSessionUsageLimitReachedError,
+  OpenGeniSessionUsageLimitUnsupportedError,
+  OpenGeniSetupError,
   OpenGeniStreamError,
+  formatErrorMessage,
   isRetryableStreamError
-} from "./chunk-C4DJPZRU.js";
+} from "./chunk-7EWT3PV6.js";
 export {
   OPENGENI_API_CONTRACT_HEADER,
   OPENGENI_API_CONTRACT_REVISION,
+  OpenGeniAllowanceExhaustedError,
   OpenGeniApiContractMismatchError,
   OpenGeniApiError,
   OpenGeniClient as OpenGeniBrowserClient,
+  OpenGeniSecureContextRequiredError,
   OpenGeniSessionListCursorError,
+  OpenGeniSessionUsageLimitReachedError,
+  OpenGeniSessionUsageLimitUnsupportedError,
+  OpenGeniSetupError,
   OpenGeniStreamError,
+  OpenGeniToolCallError,
+  OpenGeniToolReapprovalRequiredError,
+  OpenGeniToolsClient,
+  formatErrorMessage,
   isRetryableStreamError,
   resolveWorkspaceVoiceInputEnabled
 };

package/dist/chat/fold.d.ts

@@ -0,0 +1,75 @@
+import type { SessionEvent } from "../types.js";
+import { OpenGeniChatError, type ChatChunk, type ChatPending, type ChatReply } from "./types.js";
+/**
+ * Event folding shared by `send`, `stream`, and every protocol adapter.
+ *
+ * One fold covers one logical turn: text deltas accumulate into message
+ * segments (a tool call closes the current segment, the completed event
+ * reconciles it), tool call/output pairs become tool chunks, and the turn
+ * settles on a terminal event or a human wait. Events that carry a different
+ * turn id than the expected one are ignored so a queued follow-up never ends
+ * early on the previous turn's settlement.
+ *
+ * A segment belongs to one provider message when events carry `messageId`: a
+ * delta for another message starts a new segment, and a completion reconciles
+ * only the segment of its own message. Completions may arrive after later
+ * messages already streamed, so matching by position would let one message's
+ * completion close another's segment and repeat its text.
+ *
+ * Commentary (`phase: "commentary"`) narrates the work, like a tool chunk, so
+ * it is held back from the reply text. Only a turn that settles without any
+ * answer text falls back to its latest commentary, emitted at settlement.
+ */
+export type ChatTurnTerminal = "completed" | "failed" | "cancelled" | "pending";
+export type ChatFoldStep = {
+    chunks: ChatChunk[];
+    terminal: ChatTurnTerminal | null;
+};
+/** Incremental replay of unresolved requests, without retaining the event log. */
+export declare class ChatPendingFold {
+    private readonly requests;
+    push(event: SessionEvent): void;
+    pending(now?: number): ChatPending[];
+    private put;
+}
+export declare class ChatTurnFold {
+    private readonly workspaceId;
+    private readonly sessionId;
+    readonly events: SessionEvent[];
+    turnId: string | null;
+    pending: ChatPending | null;
+    failure: SessionEvent | null;
+    private emptyFinalReply;
+    private readonly segments;
+    private readonly openTools;
+    constructor(workspaceId: string, sessionId: string, expectedTurnId: string | null);
+    get text(): string;
+    push(event: SessionEvent): ChatFoldStep;
+    reply(terminal: ChatTurnTerminal): ChatReply;
+    /** The error to throw for a `turn.failed` settlement. */
+    failureError(): OpenGeniChatError;
+    private messageDelta;
+    private messageCompleted;
+    private segmentOf;
+    /** Deltas that carried no identity, still streaming the text this completion names. */
+    private unidentifiedStreamingSegment;
+    private latestAnswer;
+    private findLastSegment;
+    /**
+     * Complete an answer segment. Only the newest answer can grow: a remainder
+     * for an earlier one would land after later text for append-only consumers.
+     */
+    private extendAnswer;
+    private closeSegments;
+    /**
+     * Close the turn's text. A turn that produced commentary but no answer text
+     * (for example one that ends waiting for a worker) replies with its latest
+     * commentary rather than nothing.
+     */
+    private settleSegments;
+    private startSegment;
+}
+export declare function approvalPending(payload: Record<string, unknown>): ChatPending | null;
+export declare function humanInputPending(payload: Record<string, unknown>): ChatPending | null;
+export declare function asRecord(value: unknown): Record<string, unknown>;
+export declare function stringValue(value: unknown): string | undefined;

package/dist/chat/handler.d.ts

@@ -0,0 +1,41 @@
+import { type ChatResolve } from "./http.js";
+import type { Opengeni } from "./opengeni.js";
+import { type ChatChunk, type ChatRespondInput } from "./types.js";
+export { CHAT_CONVERSATION_HEADER, type ChatResolution, type ChatResolve } from "./http.js";
+export type ChatHandlerFormat = "native" | "vercel" | "openai-chat" | "openai-responses";
+export type ChatHandlerOptions = {
+    /** Mandatory host auth hook; see {@link ChatResolve}. */
+    resolve: ChatResolve;
+    /** Default wire format; a request may override it with the format header. */
+    format?: ChatHandlerFormat | undefined;
+    /** Vercel format only: also emit Opengeni's own tool activity (see `UIMessageStreamOptions.toolParts`). */
+    toolParts?: boolean | undefined;
+};
+/** Per-request wire-format override header. */
+export declare const CHAT_FORMAT_HEADER = "x-opengeni-chat-format";
+/**
+ * One request handler for a product's chat endpoint. `POST` with `{ message }`
+ * streams the reply in the selected format; `POST .../respond` answers a
+ * pending approval or human-input request and streams the continuation;
+ * `GET` returns the conversation's history as JSON. Every other method is a
+ * 405. The conversation is the host's resolution, else the
+ * `x-opengeni-conversation` header, else the wire format's own field.
+ */
+export declare function createChatHandler(og: Opengeni, options: ChatHandlerOptions): (request: Request) => Promise<Response>;
+/** `POST { message }` -> native SSE of {@link ChatChunk} (`event: chunk`). */
+export declare function handleNativeChatRequest(og: Opengeni, request: Request, resolve: ChatResolve): Promise<Response>;
+/**
+ * `GET` -> `{ conversation, sessionId, created, messages, pending, status }`: the user and
+ * assistant text of the conversation so a client can restore it on reload
+ * (`messages` is empty and `created` false before the first message).
+ */
+export declare function handleNativeHistoryRequest(og: Opengeni, request: Request, resolve: ChatResolve): Promise<Response>;
+/** `POST .../respond { requestId, decision | answers | skip }` -> native SSE of the continuation. */
+export declare function handleNativeRespondRequest(og: Opengeni, request: Request, resolve: ChatResolve): Promise<Response>;
+export declare function respondInputFromBody(body: Record<string, unknown> | null): ChatRespondInput | null;
+/** Native wire format: `event: chunk` per {@link ChatChunk}, `event: error` on failure. */
+export declare function chatChunksToSseBlocks(chunks: AsyncIterable<ChatChunk>): AsyncGenerator<string, void, void>;
+export declare function chatChunksToSseStream(chunks: AsyncIterable<ChatChunk>, onCancel?: () => void): ReadableStream<Uint8Array>;
+export declare function chatChunksToSseResponse(chunks: AsyncIterable<ChatChunk>): Response;
+/** Browser-side reader for the native wire format. Throws {@link OpenGeniChatError} on `event: error`. */
+export declare function parseChatChunkStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<ChatChunk, void, void>;

package/dist/chat/http.d.ts

@@ -0,0 +1,67 @@
+import type { Opengeni } from "./opengeni.js";
+import { type ChatImportedMessage, type ChatOptions } from "./types.js";
+/** Internal HTTP plumbing shared by the native handler and the protocol adapters. */
+/**
+ * Header a client uses to name the conversation it is on. Every handler reads
+ * the client conversation as: the host's resolution, else this header, else
+ * the protocol's own field.
+ */
+export declare const CHAT_CONVERSATION_HEADER = "x-opengeni-conversation";
+/** What the host's auth hook returns: identity from the host, conversation optional per protocol. */
+export type ChatResolution = Omit<ChatOptions, "conversation"> & {
+    conversation?: string | undefined;
+};
+/**
+ * The host's authentication hook. It receives the raw request and returns the
+ * tenant/user/conversation the caller is allowed to use, or a `Response` to
+ * reject the request. Never derive tenant or user from the request body.
+ */
+export type ChatResolve = (request: Request) => Promise<ChatResolution | Response> | ChatResolution | Response;
+export type ChatErrorSummary = {
+    status: number;
+    code: string;
+    message: string;
+};
+export declare function jsonResponse(body: unknown, status?: number, headers?: HeadersInit): Response;
+export declare function errorResponse(status: number, message: string, code: string): Response;
+export declare function readJsonObject(request: Request): Promise<Record<string, unknown> | null>;
+export declare function resolveChatRequest(request: Request, resolve: ChatResolve): Promise<{
+    resolution: ChatResolution;
+    response?: undefined;
+} | {
+    response: Response;
+}>;
+/** The client-supplied conversation: the header, else the protocol's own field. */
+export declare function clientConversation(request: Request, protocolField: unknown): string | undefined;
+/**
+ * Open a chat from a resolution plus the conversation the client supplied.
+ * The host names the conversation, or the host names the user and the client
+ * conversation id is namespaced to that user; anything else is a 400, because
+ * an unscoped client id could address any conversation in the workspace.
+ */
+export declare function openResolvedChat(og: Opengeni, resolution: ChatResolution, clientConversationId: string | undefined): Promise<{
+    chat: Awaited<ReturnType<Opengeni["chat"]>>;
+    response?: undefined;
+} | {
+    response: Response;
+}>;
+export declare function chatErrorSummary(error: unknown): ChatErrorSummary;
+export declare function sseHeaders(extra?: Record<string, string>): Record<string, string>;
+export declare function sseLine(data: string, event?: string): string;
+/**
+ * Pull-based text-to-bytes stream over already-formatted SSE blocks. Upstream
+ * consumption follows downstream demand; cancelling fires `onCancel` so the
+ * producer can abort its Opengeni stream.
+ */
+export declare function sseByteStream(blocks: AsyncIterable<string>, onCancel?: () => void): ReadableStream<Uint8Array>;
+/** Text from an OpenAI-style message content: a string or `[{ type, text }]` parts. */
+export declare function messageContentText(content: unknown, partTypes: string[]): string | null;
+/** The last user-role message's text from an OpenAI/Vercel-style `messages` array. */
+export declare function lastUserMessageText(messages: unknown, partTypes: string[], partsField: "parts" | "content"): string | null;
+/**
+ * Every user/assistant/system message before the last user message, as
+ * imported history for the first create. Items without a role or text
+ * (tool calls, files) are skipped.
+ */
+export declare function importedHistoryBefore(messages: unknown, partTypes: string[], partsField: "parts" | "content"): ChatImportedMessage[];
+export declare function unixSeconds(): number;

package/dist/chat/ids.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Deterministic chat identities. A conversation id maps to exactly one
+ * session id per workspace, so any process can address the same session
+ * without storing a mapping, and a double-submitted create collapses through
+ * the idempotency key. The optional legacy label argument is retained only to
+ * reproduce historical addresses. New chat calls do not use it: authorization
+ * is independent of addressing, so collaborators can share a conversation.
+ */
+/** The end-user label a conversation is namespaced to: the product `source` plus the opaque user id. */
+export type ChatUserLabel = {
+    source: string;
+    id: string;
+};
+/** Fixed RFC 4122 namespace for chat session ids. Never change it. */
+export declare const CHAT_SESSION_NAMESPACE = "7c1e6d3a-5b2f-4e8a-9d4c-0f3b6a8e2c17";
+/** RFC 4122 version 5 (SHA-1) UUID of `name` inside `namespace`. */
+export declare function uuidV5(name: string, namespace: string): Promise<string>;
+/**
+ * The session id of `conversation` in `workspaceId`: RFC 4122 v5 of the JSON
+ * tuple `[workspaceId, conversation]`, or `[workspaceId, source, id, conversation]`
+ * when the conversation belongs to an end user. JSON encoding keeps the tuple
+ * unambiguous: an id containing `:` or any other delimiter can never make two
+ * different (user, conversation) pairs share a session.
+ */
+export declare function chatSessionId(workspaceId: string, conversation: string, user?: ChatUserLabel | undefined): Promise<string>;
+/** The exact v5 name behind {@link chatSessionId}; exported for tests and audits. */
+export declare function chatIdentityName(workspaceId: string, conversation: string, user?: ChatUserLabel | undefined): string;
+/**
+ * The create idempotency key for a chat session: `chat:<sessionId>`. The
+ * session id already encodes the workspace, user label, and conversation as an
+ * unambiguous tuple, so the key inherits that and stays bounded.
+ */
+export declare function chatIdempotencyKey(sessionId: string): string;
+export declare function isUuid(value: string): boolean;

package/dist/chat/index.d.ts

@@ -0,0 +1,9 @@
+export type { Chats } from "../chats.js";
+export { OpenGeniSetupError } from "../errors.js";
+export { Chat, DEFAULT_CHAT_SOURCE, DEFAULT_OPENGENI_BASE_URL, IMPORTED_HISTORY_MAX_CHARS, OpenGeni, Opengeni, formatImportedHistory, } from "./opengeni.js";
+export { OpenGeniChatError, type ChatAgentAccess, type ChatChunk, type ChatImportedMessage, type ChatMemory, type ChatMessage, type ChatOptions, type ChatPending, type ChatReply, type ChatReplyStatus, type ChatRespondInput, type ChatSendOptions, type ChatSessionListOptions, type ChatSnapshot, type ChatTarget, type WorkspaceTarget, type ChatToolStatus, type OpenGeniOptions, } from "./types.js";
+export { CHAT_SESSION_NAMESPACE, chatIdempotencyKey, chatIdentityName, chatSessionId, uuidV5, type ChatUserLabel, } from "./ids.js";
+export { ChatTurnFold, approvalPending, humanInputPending, type ChatFoldStep, type ChatTurnTerminal, } from "./fold.js";
+export { CHAT_CONVERSATION_HEADER, CHAT_FORMAT_HEADER, chatChunksToSseBlocks, chatChunksToSseResponse, chatChunksToSseStream, createChatHandler, handleNativeChatRequest, handleNativeHistoryRequest, handleNativeRespondRequest, parseChatChunkStream, respondInputFromBody, type ChatHandlerFormat, type ChatHandlerOptions, type ChatResolution, type ChatResolve, } from "./handler.js";
+export { UI_MESSAGE_STREAM_HEADER, UI_MESSAGE_STREAM_VERSION, chatChunksToUIMessageStream, handleVercelChatRequest, lastUIMessageText, uiMessageStreamBlocks, uiMessageStreamParts, uiMessageStreamResponse, type UIMessageStreamOptions, } from "./vercel.js";
+export { chatCompletionBlocks, chatCompletionObject, decodeResponseId, encodeResponseId, handleChatCompletionsRequest, handleResponsesRequest, responsesBlocks, responsesInputText, } from "./openai.js";