@belonguniverseai/react-sdk 0.6.15 → 0.6.17

package/dist/api/account-connector-contract.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const accountConnectorCatalogEntryIdSchema: z.ZodString;

package/dist/api/account-connectors.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { ApiClient } from './client.ts';
+declare const accountConnectorSchema: z.ZodObject<{
+    catalogEntryId: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        needs_auth: "needs_auth";
+        connected: "connected";
+        disconnected: "disconnected";
+    }>;
+    account: z.ZodNullable<z.ZodObject<{
+        displayName: z.ZodString;
+        principal: z.ZodString;
+    }, z.core.$strip>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            needs_auth: "needs_auth";
+            ready: "ready";
+            needs_admin_consent: "needs_admin_consent";
+            disabled: "disabled";
+        }>;
+    }, z.core.$strip>>;
+    actions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            authorization: "authorization";
+            disconnect: "disconnect";
+        }>;
+        label: z.ZodEnum<{
+            disconnect: "disconnect";
+            connect: "connect";
+            reconnect: "reconnect";
+            grant_admin_consent: "grant_admin_consent";
+        }>;
+        tone: z.ZodEnum<{
+            primary: "primary";
+            destructive: "destructive";
+            secondary: "secondary";
+        }>;
+        requiresConfirmation: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const accountConnectorActionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"authorization">;
+    authorizationUrl: z.ZodURL;
+    completion: z.ZodLiteral<"action_unavailable">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"completed">;
+}, z.core.$strip>], "kind">;
+export type AccountConnector = z.infer<typeof accountConnectorSchema>;
+export type AccountConnectorActionResult = z.infer<typeof accountConnectorActionResultSchema>;
+export type AccountConnectorListResult = {
+    readonly status: "ready";
+    readonly connectors: readonly AccountConnector[];
+} | {
+    readonly status: "featureAbsent";
+};
+export type RunAccountConnectorActionInput = {
+    readonly catalogEntryId: string;
+    readonly actionId: string;
+    readonly returnPath: string;
+};
+export type AccountConnectorActionFailure = {
+    readonly status: "invalid";
+} | {
+    readonly status: "invalid_return_path";
+} | {
+    readonly status: "forbidden";
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "action_unavailable";
+} | {
+    readonly status: "provider_unavailable";
+} | {
+    readonly status: "error";
+};
+export type RunAccountConnectorActionResult = AccountConnectorActionResult | AccountConnectorActionFailure;
+export declare const listAccountConnectorsRequest: (api: ApiClient, signal?: AbortSignal) => Promise<AccountConnectorListResult>;
+export declare const runAccountConnectorActionRequest: (api: ApiClient, input: RunAccountConnectorActionInput) => Promise<RunAccountConnectorActionResult>;
+export declare const useAccountConnectors: () => import('@tanstack/react-query').UseQueryResult<NoInfer<AccountConnectorListResult>, Error>;
+export declare const useRunAccountConnectorAction: () => import('@tanstack/react-query').UseMutationResult<RunAccountConnectorActionResult, Error, RunAccountConnectorActionInput, unknown>;
+export {};

package/dist/api/client.d.ts

@@ -1195,6 +1195,186 @@ export declare const createApiClient: (baseUrl: string) => {
             };
         };
     };
+} & {
+    v1: {
+        questions: {
+            ":questionRequestId": {
+                answer: import('hono/client').ClientRequest<string, "/v1/questions/:questionRequestId/answer", {
+                    $post: {
+                        input: {
+                            param: {
+                                questionRequestId: string;
+                            };
+                        } & {
+                            json: {
+                                answers: Record<string, {
+                                    kind: "options";
+                                    optionIds: string[];
+                                    text?: string;
+                                } | {
+                                    kind: "text";
+                                    text: string;
+                                } | {
+                                    kind: "skipped";
+                                }>;
+                            } | {
+                                reply: string;
+                            } | {
+                                dismissed: true;
+                            };
+                        };
+                        output: {
+                            continuation?: {
+                                readonly messageId: import('node_modules/@belong/cloud/src/platform/ids').MessageId;
+                                readonly taskId: import('node_modules/@belong/cloud/src/platform/ids').TaskId;
+                                readonly runId: import('node_modules/@belong/cloud/src/platform/ids').RunId;
+                                readonly text: string;
+                            } | undefined;
+                            status: "accepted";
+                            questionStatus: import('node_modules/@belong/cloud/src/features/runs/run-event.types').QuestionState;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                questionRequestId: string;
+                            };
+                        } & {
+                            json: {
+                                answers: Record<string, {
+                                    kind: "options";
+                                    optionIds: string[];
+                                    text?: string;
+                                } | {
+                                    kind: "text";
+                                    text: string;
+                                } | {
+                                    kind: "skipped";
+                                }>;
+                            } | {
+                                reply: string;
+                            } | {
+                                dismissed: true;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                questionRequestId: string;
+                            };
+                        } & {
+                            json: {
+                                answers: Record<string, {
+                                    kind: "options";
+                                    optionIds: string[];
+                                    text?: string;
+                                } | {
+                                    kind: "text";
+                                    text: string;
+                                } | {
+                                    kind: "skipped";
+                                }>;
+                            } | {
+                                reply: string;
+                            } | {
+                                dismissed: true;
+                            };
+                        };
+                        output: {
+                            error: {
+                                reply?: string | undefined;
+                                answers?: {
+                                    readonly [x: string]: {
+                                        readonly kind: "options";
+                                        readonly optionIds: readonly string[];
+                                        readonly text?: string | undefined;
+                                    } | {
+                                        readonly kind: "text";
+                                        readonly text: string;
+                                    } | {
+                                        readonly kind: "skipped";
+                                    };
+                                } | undefined;
+                                type: string;
+                                questionStatus: import('node_modules/@belong/cloud/src/features/runs/run-event.types').QuestionState;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 409;
+                    } | {
+                        input: {
+                            param: {
+                                questionRequestId: string;
+                            };
+                        } & {
+                            json: {
+                                answers: Record<string, {
+                                    kind: "options";
+                                    optionIds: string[];
+                                    text?: string;
+                                } | {
+                                    kind: "text";
+                                    text: string;
+                                } | {
+                                    kind: "skipped";
+                                }>;
+                            } | {
+                                reply: string;
+                            } | {
+                                dismissed: true;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 403;
+                    } | {
+                        input: {
+                            param: {
+                                questionRequestId: string;
+                            };
+                        } & {
+                            json: {
+                                answers: Record<string, {
+                                    kind: "options";
+                                    optionIds: string[];
+                                    text?: string;
+                                } | {
+                                    kind: "text";
+                                    text: string;
+                                } | {
+                                    kind: "skipped";
+                                }>;
+                            } | {
+                                reply: string;
+                            } | {
+                                dismissed: true;
+                            };
+                        };
+                        output: {
+                            error: {
+                                type: string;
+                                reason: string;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 400;
+                    };
+                }>;
+            };
+        };
+    };
 } & {
     v1: {
         files: import('hono/client').ClientRequest<string, "/v1/files", {
@@ -3793,7 +3973,6 @@ export declare const createApiClient: (baseUrl: string) => {
                 output: {
                     error: {
                         type: string;
-                        maxPendingSchedules: number;
                     };
                 };
                 outputFormat: "json";
@@ -3864,6 +4043,20 @@ export declare const createApiClient: (baseUrl: string) => {
                         anchorAt: string;
                         totalRunsCount: number;
                         updatedAt: string;
+                        microsoftTeamsDelivery: {
+                            expiresAt: string;
+                            destination: {
+                                kind: "chat";
+                                chatId: string;
+                            } | {
+                                kind: "channel";
+                                teamId: string;
+                                channelId: string;
+                            };
+                            status: import('../../../../apps/belong-cloud/src/features/microsoft/microsoft.schemas').MicrosoftTeamsMandateStatus;
+                            allowExternalRecipients: boolean;
+                            maxMessagesPerRun: number;
+                        } | null;
                         taskScheduleId: import('node_modules/@belong/cloud/src/platform/ids').TaskScheduleSeriesId;
                         title: string;
                         status: "active" | "completed" | "paused" | "deleted";
@@ -4323,7 +4516,7 @@ export declare const createApiClient: (baseUrl: string) => {
                             };
                         };
                         output: {
-                            status: "active" | "completed";
+                            status: "active" | "completed" | "needs_attention";
                             nextRunAt: string | null;
                         };
                         outputFormat: "json";
@@ -5005,6 +5198,15 @@ export declare const createApiClient: (baseUrl: string) => {
                     };
                     outputFormat: "json";
                     status: 503;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 400;
                 } | {
                     input: {};
                     output: {
@@ -5019,6 +5221,17 @@ export declare const createApiClient: (baseUrl: string) => {
                             preview: boolean;
                         } | {
                             availability: "available";
+                            setupKind: "oauth_account";
+                            id: string;
+                            name: string;
+                            description: string;
+                            iconKey: string;
+                            category: string;
+                            featured: boolean;
+                            preview: boolean;
+                        } | {
+                            availability: "available";
+                            setupKind: "remote_mcp";
                             serverUrl: string;
                             serverUrlMode: "fixed" | "user_provided";
                             transport: "streamable_http" | "sse";
@@ -5550,6 +5763,167 @@ export declare const createApiClient: (baseUrl: string) => {
             };
         };
     };
+} & {
+    v1: {
+        "account-connectors": import('hono/client').ClientRequest<string, "/v1/account-connectors", {
+            $get: {
+                input: {};
+                output: {
+                    connectors: {
+                        catalogEntryId: string;
+                        status: "error" | "needs_auth" | "connected" | "disconnected";
+                        account: {
+                            displayName: string;
+                            principal: string;
+                        } | null;
+                        capabilities: {
+                            id: string;
+                            label: string;
+                            status: "error" | "needs_auth" | "ready" | "needs_admin_consent" | "disabled";
+                        }[];
+                        actions: {
+                            id: string;
+                            kind: "authorization" | "disconnect";
+                            label: "disconnect" | "connect" | "reconnect" | "grant_admin_consent";
+                            tone: "primary" | "destructive" | "secondary";
+                            requiresConfirmation: boolean;
+                        }[];
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        "account-connectors": {
+            ":catalogEntryId": {
+                actions: {
+                    ":actionId": import('hono/client').ClientRequest<string, "/v1/account-connectors/:catalogEntryId/actions/:actionId", {
+                        $post: {
+                            input: {
+                                json: {
+                                    returnPath: string;
+                                };
+                            } & {
+                                param: {
+                                    catalogEntryId: string;
+                                } & {
+                                    actionId: string;
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: string;
+                                    requiredScope: string;
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 403;
+                        } | {
+                            input: {
+                                json: {
+                                    returnPath: string;
+                                };
+                            } & {
+                                param: {
+                                    catalogEntryId: string;
+                                } & {
+                                    actionId: string;
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: string;
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 400;
+                        } | {
+                            input: {
+                                json: {
+                                    returnPath: string;
+                                };
+                            } & {
+                                param: {
+                                    catalogEntryId: string;
+                                } & {
+                                    actionId: string;
+                                };
+                            };
+                            output: {
+                                readonly kind: "authorization";
+                                readonly authorizationUrl: string;
+                                readonly completion: "action_unavailable";
+                            } | {
+                                readonly kind: "completed";
+                            };
+                            outputFormat: "json";
+                            status: 200;
+                        } | {
+                            input: {
+                                json: {
+                                    returnPath: string;
+                                };
+                            } & {
+                                param: {
+                                    catalogEntryId: string;
+                                } & {
+                                    actionId: string;
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: string;
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 404;
+                        } | {
+                            input: {
+                                json: {
+                                    returnPath: string;
+                                };
+                            } & {
+                                param: {
+                                    catalogEntryId: string;
+                                } & {
+                                    actionId: string;
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: string;
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 409;
+                        } | {
+                            input: {
+                                json: {
+                                    returnPath: string;
+                                };
+                            } & {
+                                param: {
+                                    catalogEntryId: string;
+                                } & {
+                                    actionId: string;
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: string;
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 503;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
 } & {
     v1: {
         "connector-oauth": {
@@ -5563,6 +5937,21 @@ export declare const createApiClient: (baseUrl: string) => {
             }>;
         };
     };
+} & {
+    v1: {
+        microsoft: {
+            oauth: {
+                callback: import('hono/client').ClientRequest<string, "/v1/microsoft/oauth/callback", {
+                    $get: {
+                        input: {};
+                        output: {};
+                        outputFormat: string;
+                        status: import('hono/utils/http-status').StatusCode;
+                    };
+                }>;
+            };
+        };
+    };
 } & {
     v1: {
         admin: {

package/dist/api/connectors.d.ts

@@ -85,6 +85,7 @@ export type ConnectorCatalogEntry = (ConnectorCatalogEntryBase & {
     readonly availability: "coming_soon";
 }) | (ConnectorCatalogEntryBase & {
     readonly availability: "available";
+    readonly setupKind: "remote_mcp";
     readonly serverUrl: string;
     readonly serverUrlMode?: "fixed" | "user_provided";
     readonly transport: ConnectorTransport;
@@ -93,10 +94,21 @@ export type ConnectorCatalogEntry = (ConnectorCatalogEntryBase & {
     readonly oauthAuthorizationParams: Readonly<Record<string, string>> | null;
     readonly oauthAppCredentialsRequired: boolean;
     readonly documentationUrl: string;
+}) | (ConnectorCatalogEntryBase & {
+    readonly availability: "available";
+    readonly setupKind: "oauth_account";
 });
 export type AvailableConnectorCatalogEntry = Extract<ConnectorCatalogEntry, {
     readonly availability: "available";
 }>;
+export type AvailableRemoteConnectorCatalogEntry = Extract<ConnectorCatalogEntry, {
+    readonly availability: "available";
+    readonly setupKind: "remote_mcp";
+}>;
+export type AvailableAccountConnectorCatalogEntry = Extract<ConnectorCatalogEntry, {
+    readonly availability: "available";
+    readonly setupKind: "oauth_account";
+}>;
 /**
  * The credential a CREATE sends.
  *

package/dist/api/query-keys.d.ts

@@ -38,4 +38,5 @@ export declare const queryKeys: {
     connectors: readonly ["belong", "connectors"];
     connectorList: readonly ["belong", "connectors", "list"];
     connectorCatalog: readonly ["belong", "connectors", "catalog"];
+    accountConnectors: readonly ["belong", "account-connectors"];
 };

package/dist/api/questions.d.ts

@@ -0,0 +1,41 @@
+import { ChoiceAnswer, ChoiceState } from '../stream/belong-data-parts.ts';
+export type AnswerQuestionBody = {
+    readonly answers: Readonly<Record<string, ChoiceAnswer>>;
+} | {
+    readonly reply: string;
+} | {
+    readonly dismissed: true;
+};
+/** The turn a late answer started — `sessions.postMessage`'s ids + the posted text. */
+export type QuestionContinuation = {
+    readonly messageId: string;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly text: string;
+};
+/**
+ * `already_resolved` is the 409 with the row of record. `rejected` is any
+ * other non-2xx (`status` is the HTTP status; `type` the backend's typed
+ * error — `question_not_found`, `not_owner`, `invalid_answer` — when the body
+ * carried one). `unreachable` means the request never reached the server
+ * (network reject / CORS mask).
+ */
+export type AnswerQuestionResult = {
+    readonly ok: true;
+    readonly continuation?: QuestionContinuation;
+} | {
+    readonly ok: false;
+    readonly reason: "already_resolved";
+    readonly questionStatus: ChoiceState;
+    readonly answers?: Readonly<Record<string, ChoiceAnswer>>;
+    readonly reply?: string;
+} | {
+    readonly ok: false;
+    readonly reason: "unreachable";
+} | {
+    readonly ok: false;
+    readonly reason: "rejected";
+    readonly status: number;
+    readonly type?: string;
+};
+export declare const answerQuestionRequest: (apiBaseUrl: string, questionRequestId: string, body: AnswerQuestionBody) => Promise<AnswerQuestionResult>;

package/dist/api/task-schedules.d.ts

@@ -169,7 +169,7 @@ declare const taskScheduleListItemSchema: z.ZodObject<{
     createdAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export type TaskScheduleListItem = z.infer<typeof taskScheduleListItemSchema>;
-declare const taskScheduleDetailSchema: z.ZodObject<{
+export declare const taskScheduleDetailSchema: z.ZodObject<{
     taskScheduleId: z.ZodUUID;
     title: z.ZodString;
     status: z.ZodEnum<{
@@ -237,6 +237,24 @@ declare const taskScheduleDetailSchema: z.ZodObject<{
         templatePath: z.ZodString;
         recipients: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
     }, z.core.$strip>], "kind">>;
+    microsoftTeamsDelivery: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"chat">;
+            chatId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"channel">;
+            teamId: z.ZodString;
+            channelId: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        status: z.ZodEnum<{
+            active: "active";
+            suspended: "suspended";
+            revoked: "revoked";
+        }>;
+        allowExternalRecipients: z.ZodBoolean;
+        maxMessagesPerRun: z.ZodNumber;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type TaskScheduleDetail = z.infer<typeof taskScheduleDetailSchema>;
 declare const taskScheduleRunSchema: z.ZodObject<{
@@ -328,6 +346,20 @@ export declare const useTaskSchedule: (taskScheduleId: string | null) => import(
         templatePath: string;
         recipients?: string[] | undefined;
     };
+    microsoftTeamsDelivery: {
+        destination: {
+            kind: "chat";
+            chatId: string;
+        } | {
+            kind: "channel";
+            teamId: string;
+            channelId: string;
+        };
+        status: "active" | "suspended" | "revoked";
+        allowExternalRecipients: boolean;
+        maxMessagesPerRun: number;
+        expiresAt: string;
+    } | null;
 }>, Error>;
 export declare const useTaskScheduleRuns: (taskScheduleId: string | null) => import('@tanstack/react-query').UseInfiniteQueryResult<{
     taskScheduleRunId: string;

package/dist/component/{abnfDiagram-N423BO3Z-BHtc0bvC.js → abnfDiagram-N423BO3Z-DQQzuYZD.js}

@@ -1,6 +1,6 @@
-import { g as p, r as u, d as n } from "./chunk-6Q2QTUOP-o1oblyO-.js";
-import { p as f } from "./chunk-JWPE2WC7-CRCYILZC.js";
-import { _ as a, l as o } from "./mermaid-GHXKKRXX-CvjBCI1T.js";
+import { g as p, r as u, d as n } from "./chunk-6Q2QTUOP-cjY3qI3C.js";
+import { p as f } from "./chunk-JWPE2WC7-C_FwRGti.js";
+import { _ as a, l as o } from "./mermaid-GHXKKRXX-BYmG2b26.js";
 import { M as c, b as g } from "./cynefin-VYW2F7L2-DAyxamLw.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -87,4 +87,4 @@ var b = g().RailroadAbnf.parser.LangiumParser, l = /* @__PURE__ */ a((e) => {
 export {
   T as diagram
 };
-//# sourceMappingURL=abnfDiagram-N423BO3Z-BHtc0bvC.js.map
+//# sourceMappingURL=abnfDiagram-N423BO3Z-DQQzuYZD.js.map