@meistrari/chat-nuxt 4.10.0-rc.2 → 4.10.0-rc.21

package/dist/runtime/types/schemas/chat/ui-language.d.ts

@@ -1,14 +1,31 @@
 import { z } from 'zod';
 export declare const uiLanguageIds: readonly ["openui"];
-export declare const uiLanguageSchema: z.ZodEnum<{
-    openui: "openui";
+export declare const uiProfileIds: readonly ["web", "slack"];
+export declare const uiProfileSchema: z.ZodEnum<{
+    web: "web";
+    slack: "slack";
 }>;
+export type UiProfile = z.infer<typeof uiProfileSchema>;
+/** What a turn asks the agent for: the widget language and the catalogue profile of the surface that renders the answer. */
+export declare const uiLanguageSchema: z.ZodObject<{
+    id: z.ZodEnum<{
+        openui: "openui";
+    }>;
+    profile: z.ZodEnum<{
+        web: "web";
+        slack: "slack";
+    }>;
+}, z.core.$strip>;
 export type UiLanguage = z.infer<typeof uiLanguageSchema>;
 /** Set on the assistant message when the turn asked the agent for widgets; the library version arrives with the result. */
 export declare const uiLanguageStampSchema: z.ZodObject<{
     id: z.ZodEnum<{
         openui: "openui";
     }>;
+    profile: z.ZodEnum<{
+        web: "web";
+        slack: "slack";
+    }>;
     libraryVersion: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type UiLanguageStamp = z.infer<typeof uiLanguageStampSchema>;

package/dist/runtime/types/schemas/chat/ui-language.js

@@ -1,8 +1,13 @@
 import { z } from 'zod';
 export const uiLanguageIds = ['openui'];
-export const uiLanguageSchema = z.enum(uiLanguageIds);
+export const uiProfileIds = ['web', 'slack'];
+export const uiProfileSchema = z.enum(uiProfileIds);
+/** What a turn asks the agent for: the widget language and the catalogue profile of the surface that renders the answer. */
+export const uiLanguageSchema = z.object({
+    id: z.enum(uiLanguageIds),
+    profile: uiProfileSchema,
+});
 /** Set on the assistant message when the turn asked the agent for widgets; the library version arrives with the result. */
-export const uiLanguageStampSchema = z.object({
-    id: uiLanguageSchema,
+export const uiLanguageStampSchema = uiLanguageSchema.extend({
     libraryVersion: z.string().min(1).optional(),
 });

package/dist/runtime/types/schemas/chat/v3.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 /**
  * Chat API v3 (`/v3/chat`): the conversational surface over agent-api v5 events-v1.
- * The chat-api owns the conversation; agent-api owns the session and its history.
+ * The chat-api owns the thread; agent-api owns the session and its history.
  */
 export declare const CHAT_V3_CONTRACT_VERSION = "events-v1";
-/** Where the agent of the request stands in the v5 catalog. */
+/** Where the agent of the request stands in agent-api, where the agent lives. */
 export declare const chatV3AgentStatusSchema: z.ZodEnum<{
     ready: "ready";
     not_requested: "not_requested";
@@ -53,3 +53,161 @@ export declare const chatV3ConfigurationSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type ChatV3Configuration = z.infer<typeof chatV3ConfigurationSchema>;
+export declare const CHAT_V3_TITLE_CHARS = 200;
+export declare const CHAT_V3_CREATION_KEY_CHARS = 128;
+export declare const CHAT_V3_THREAD_PAGE: {
+    readonly default: 30;
+    readonly max: 100;
+};
+/** A thread as the chat owns it: access and title here, history in the agent-api session. */
+export declare const chatV3ThreadSchema: z.ZodObject<{
+    threadId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    title: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ChatV3Thread = z.infer<typeof chatV3ThreadSchema>;
+/** The session behind a thread, read live from agent-api; `null` when agent-api no longer has it. */
+export declare const chatV3SessionSummarySchema: z.ZodNullable<z.ZodObject<{
+    status: z.ZodString;
+    harness: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    reasoningEffort: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>>;
+export declare const chatV3ThreadDetailSchema: z.ZodObject<{
+    threadId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    title: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    session: z.ZodNullable<z.ZodObject<{
+        status: z.ZodString;
+        harness: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        reasoningEffort: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChatV3ThreadDetail = z.infer<typeof chatV3ThreadDetailSchema>;
+/** Creation also opens the agent-api session; send an `Idempotency-Key` header to retry safely. */
+export declare const chatV3CreateThreadSchema: z.ZodObject<{
+    agentId: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ChatV3CreateThread = z.infer<typeof chatV3CreateThreadSchema>;
+export declare const chatV3UpdateThreadSchema: z.ZodObject<{
+    title: z.ZodString;
+}, z.core.$strict>;
+export type ChatV3UpdateThread = z.infer<typeof chatV3UpdateThreadSchema>;
+export declare const chatV3ThreadListQuerySchema: z.ZodObject<{
+    agentId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    before: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type ChatV3ThreadListQuery = z.infer<typeof chatV3ThreadListQuerySchema>;
+export declare const chatV3ThreadListSchema: z.ZodObject<{
+    threads: z.ZodArray<z.ZodObject<{
+        threadId: z.ZodString;
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        title: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ChatV3ThreadList = z.infer<typeof chatV3ThreadListSchema>;
+export declare const CHAT_V3_MESSAGE_PAGE: {
+    readonly default: 30;
+    readonly max: 100;
+};
+/** A message's text; above the inline limit agent-api keeps it in Vault and the event points at it. */
+export declare const chatV3SendMessageSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>;
+export type ChatV3SendMessage = z.infer<typeof chatV3SendMessageSchema>;
+/** Cancels the running turn; the turnId comes from the message that started it. */
+export declare const chatV3CancelTurnSchema: z.ZodObject<{
+    turnId: z.ZodString;
+}, z.core.$strict>;
+export type ChatV3CancelTurn = z.infer<typeof chatV3CancelTurnSchema>;
+/** The answer of every write: agent-api admitted the user event. `messageId` is its v5 eventId. */
+export declare const chatV3MessageReceiptSchema: z.ZodObject<{
+    messageId: z.ZodString;
+    turnId: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+}, z.core.$strip>;
+export type ChatV3MessageReceipt = z.infer<typeof chatV3MessageReceiptSchema>;
+export declare const chatV3MessageStatusSchema: z.ZodEnum<{
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    queued: "queued";
+    uncertain: "uncertain";
+}>;
+export type ChatV3MessageStatus = z.infer<typeof chatV3MessageStatusSchema>;
+/**
+ * One message of the user and the agent's reply to it, rebuilt from the session's events on
+ * every read. `text` is `null` while it is only in Vault (`textInVault`); `reply` is the
+ * canonical text the agent stored so far, without the live drafts.
+ */
+export declare const chatV3MessageSchema: z.ZodObject<{
+    messageId: z.ZodString;
+    turnId: z.ZodNullable<z.ZodString>;
+    mode: z.ZodEnum<{
+        queue: "queue";
+        steer: "steer";
+        answer: "answer";
+    }>;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        queued: "queued";
+        uncertain: "uncertain";
+    }>;
+    text: z.ZodNullable<z.ZodString>;
+    textInVault: z.ZodBoolean;
+    reply: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ChatV3Message = z.infer<typeof chatV3MessageSchema>;
+export declare const chatV3MessageListQuerySchema: z.ZodObject<{
+    before: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type ChatV3MessageListQuery = z.infer<typeof chatV3MessageListQuerySchema>;
+/**
+ * The latest messages, oldest first. `eventCursor` is the last event the page was built from:
+ * open the event stream with it as `Last-Event-ID` and nothing falls between the two.
+ */
+export declare const chatV3MessageListSchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        messageId: z.ZodString;
+        turnId: z.ZodNullable<z.ZodString>;
+        mode: z.ZodEnum<{
+            queue: "queue";
+            steer: "steer";
+            answer: "answer";
+        }>;
+        status: z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            queued: "queued";
+            uncertain: "uncertain";
+        }>;
+        text: z.ZodNullable<z.ZodString>;
+        textInVault: z.ZodBoolean;
+        reply: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    eventCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ChatV3MessageList = z.infer<typeof chatV3MessageListSchema>;

package/dist/runtime/types/schemas/chat/v3.js

@@ -1,15 +1,15 @@
 import { z } from 'zod';
-import { v5HarnessSchema } from '../integrations/agent-events';
+import { v5EventIdSchema, v5HarnessSchema, v5Limits, v5TurnIdSchema } from '../integrations/agent-events';
 /**
  * Chat API v3 (`/v3/chat`): the conversational surface over agent-api v5 events-v1.
- * The chat-api owns the conversation; agent-api owns the session and its history.
+ * The chat-api owns the thread; agent-api owns the session and its history.
  */
 export const CHAT_V3_CONTRACT_VERSION = 'events-v1';
-/** Where the agent of the request stands in the v5 catalog. */
+/** Where the agent of the request stands in agent-api, where the agent lives. */
 export const chatV3AgentStatusSchema = z.enum([
-    /** No `telaAgentId` on the request: nothing to resolve yet. */
+    /** No `agentId` on the request: nothing to look up yet. */
     'not_requested',
-    /** Tela knows the agent, but the v5 catalog does not: Tela has to create it there. */
+    /** agent-api has no such agent in the caller's workspace. */
     'not_in_catalog',
     /** In the catalog without a publication: `POST /v5/agents/snapshots` first. */
     'not_published',
@@ -35,3 +35,89 @@ export const chatV3ConfigurationSchema = z.object({
         eventsPerRequest: z.number().int().positive(),
     }),
 });
+export const CHAT_V3_TITLE_CHARS = 200;
+export const CHAT_V3_CREATION_KEY_CHARS = 128;
+export const CHAT_V3_THREAD_PAGE = { default: 30, max: 100 };
+/**
+ * The agent's id in agent-api, the only one the chat uses. Lowercased, as agent-api and Postgres
+ * write uuids, so the same agent always compares equal.
+ */
+const agentIdSchema = z.string().uuid().transform(id => id.toLowerCase());
+/** A thread as the chat owns it: access and title here, history in the agent-api session. */
+export const chatV3ThreadSchema = z.object({
+    threadId: z.string().uuid(),
+    agentId: z.string().uuid(),
+    sessionId: z.string().uuid(),
+    title: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+/** The session behind a thread, read live from agent-api; `null` when agent-api no longer has it. */
+export const chatV3SessionSummarySchema = z.object({
+    status: z.string(),
+    harness: z.string(),
+    model: z.string().nullable(),
+    reasoningEffort: z.string().nullable(),
+}).nullable();
+export const chatV3ThreadDetailSchema = chatV3ThreadSchema.extend({ session: chatV3SessionSummarySchema });
+/** Creation also opens the agent-api session; send an `Idempotency-Key` header to retry safely. */
+export const chatV3CreateThreadSchema = z.object({
+    agentId: agentIdSchema,
+    title: z.string().trim().max(CHAT_V3_TITLE_CHARS).optional(),
+}).strict();
+export const chatV3UpdateThreadSchema = z.object({
+    title: z.string().trim().max(CHAT_V3_TITLE_CHARS),
+}).strict();
+export const chatV3ThreadListQuerySchema = z.object({
+    agentId: agentIdSchema.optional(),
+    /** Exclusive cursor: the last `threadId` of the previous page. */
+    before: z.string().uuid().optional(),
+    limit: z.coerce.number().int().min(1).max(CHAT_V3_THREAD_PAGE.max).default(CHAT_V3_THREAD_PAGE.default),
+}).strict();
+export const chatV3ThreadListSchema = z.object({
+    threads: z.array(chatV3ThreadSchema),
+    nextCursor: z.string().uuid().nullable(),
+});
+export const CHAT_V3_MESSAGE_PAGE = { default: 30, max: 100 };
+/** A message's text; above the inline limit agent-api keeps it in Vault and the event points at it. */
+export const chatV3SendMessageSchema = z.object({
+    text: z.string().min(1).max(v5Limits.messageTextChars),
+}).strict();
+/** Cancels the running turn; the turnId comes from the message that started it. */
+export const chatV3CancelTurnSchema = z.object({ turnId: v5TurnIdSchema }).strict();
+/** The answer of every write: agent-api admitted the user event. `messageId` is its v5 eventId. */
+export const chatV3MessageReceiptSchema = z.object({
+    messageId: v5EventIdSchema,
+    turnId: v5TurnIdSchema.nullable(),
+    status: z.string(),
+});
+export const chatV3MessageStatusSchema = z.enum(['queued', 'running', 'completed', 'failed', 'cancelled', 'uncertain']);
+/**
+ * One message of the user and the agent's reply to it, rebuilt from the session's events on
+ * every read. `text` is `null` while it is only in Vault (`textInVault`); `reply` is the
+ * canonical text the agent stored so far, without the live drafts.
+ */
+export const chatV3MessageSchema = z.object({
+    messageId: v5EventIdSchema,
+    turnId: v5TurnIdSchema.nullable(),
+    mode: z.enum(['queue', 'steer', 'answer']),
+    status: chatV3MessageStatusSchema,
+    text: z.string().nullable(),
+    textInVault: z.boolean(),
+    reply: z.string(),
+    createdAt: z.string(),
+});
+export const chatV3MessageListQuerySchema = z.object({
+    /** Exclusive cursor: the `nextCursor` of the previous page, which reads older messages. */
+    before: v5EventIdSchema.optional(),
+    limit: z.coerce.number().int().min(1).max(CHAT_V3_MESSAGE_PAGE.max).default(CHAT_V3_MESSAGE_PAGE.default),
+}).strict();
+/**
+ * The latest messages, oldest first. `eventCursor` is the last event the page was built from:
+ * open the event stream with it as `Last-Event-ID` and nothing falls between the two.
+ */
+export const chatV3MessageListSchema = z.object({
+    messages: z.array(chatV3MessageSchema),
+    nextCursor: v5EventIdSchema.nullable(),
+    eventCursor: v5EventIdSchema.nullable(),
+});

package/dist/runtime/types/schemas/integrations/slack-apps.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export type SlackOutcome<T> = {
+    kind: 'ok';
+    value: T;
+} | {
+    kind: 'rejected';
+    error: string;
+} | {
+    kind: 'rate_limited';
+    retryAfter: number;
+} | {
+    kind: 'unknown';
+    appId?: string;
+};
+export interface CreatedApp {
+    appId: string;
+    credentials: {
+        clientId: string;
+        clientSecret: string;
+        signingSecret: string;
+    };
+}
+export interface RotatedConfigToken {
+    token: string;
+    refreshToken: string;
+    teamId: string;
+    userId: string;
+    exp: number;
+}
+export declare const slackAppIdSchema: z.ZodString;
+export declare const slackApiResponseSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    app_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const slackCreatedAppResponseSchema: z.ZodObject<{
+    app_id: z.ZodString;
+    credentials: z.ZodObject<{
+        client_id: z.ZodString;
+        client_secret: z.ZodString;
+        signing_secret: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const slackExportedManifestResponseSchema: z.ZodObject<{
+    manifest: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const slackRotatedConfigTokenResponseSchema: z.ZodObject<{
+    token: z.ZodString;
+    refresh_token: z.ZodString;
+    team_id: z.ZodString;
+    user_id: z.ZodString;
+    exp: z.ZodNumber;
+}, z.core.$strip>;

package/dist/runtime/types/schemas/integrations/slack-apps.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const slackAppIdSchema = z.string().regex(/^A[A-Z0-9]+$/).max(100);
+export const slackApiResponseSchema = z.object({ ok: z.boolean(), error: z.string().max(200).optional(), app_id: slackAppIdSchema.optional() }).passthrough();
+export const slackCreatedAppResponseSchema = z.object({ app_id: slackAppIdSchema, credentials: z.object({ client_id: z.string().regex(/^\d+\.\d+$/).max(100), client_secret: z.string().min(1).max(2000), signing_secret: z.string().min(1).max(2000) }) });
+export const slackExportedManifestResponseSchema = z.object({ manifest: z.record(z.string(), z.unknown()) });
+export const slackRotatedConfigTokenResponseSchema = z.object({ token: z.string().regex(/^xoxe\.xoxp-[\w-]+$/).max(4000), refresh_token: z.string().regex(/^xoxe-[\w-]+$/).max(4000), team_id: z.string().regex(/^T[A-Z0-9]+$/).max(100), user_id: z.string().regex(/^U[A-Z0-9]+$/).max(100), exp: z.number().int().positive() });

package/dist/runtime/types/schemas/integrations/slack-identity.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const slackIdTokenHeaderSchema: z.ZodObject<{
+    alg: z.ZodString;
+}, z.core.$strip>;
+export declare const slackIdTokenClaimsSchema: z.ZodObject<{
+    iss: z.ZodLiteral<"https://slack.com">;
+    sub: z.ZodString;
+    aud: z.ZodString;
+    exp: z.ZodNumber;
+    nonce: z.ZodString;
+    'https://slack.com/team_id': z.ZodString;
+    'https://slack.com/user_id': z.ZodString;
+}, z.core.$strip>;
+export declare const slackOpenIdTokenSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    access_token: z.ZodString;
+    id_token: z.ZodString;
+}, z.core.$strip>;
+export declare const slackUserInfoSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    sub: z.ZodString;
+    'https://slack.com/user_id': z.ZodString;
+    'https://slack.com/team_id': z.ZodString;
+    'https://slack.com/team_name': z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/runtime/types/schemas/integrations/slack-identity.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+const slackUserId = z.string().regex(/^[UW][A-Z0-9]{1,99}$/);
+const slackTeamId = z.string().regex(/^T[A-Z0-9]{1,99}$/);
+export const slackIdTokenHeaderSchema = z.object({ alg: z.string().min(1).max(20) });
+export const slackIdTokenClaimsSchema = z.object({
+    'iss': z.literal('https://slack.com'),
+    'sub': slackUserId,
+    'aud': z.string(),
+    'exp': z.number(),
+    'nonce': z.string(),
+    'https://slack.com/team_id': slackTeamId,
+    'https://slack.com/user_id': slackUserId,
+});
+export const slackOpenIdTokenSchema = z.object({ ok: z.literal(true), access_token: z.string().min(1).max(4096), id_token: z.string().min(1).max(16_384) });
+// openid.connect.userInfo documents the workspace name; the ID token does not.
+export const slackUserInfoSchema = z.object({
+    'ok': z.literal(true),
+    'sub': z.string(),
+    'https://slack.com/user_id': z.string(),
+    'https://slack.com/team_id': z.string(),
+    'https://slack.com/team_name': z.string().min(1).optional(),
+    'name': z.string().min(1).optional(),
+});

package/dist/runtime/types/schemas/integrations/tela-agent-api.d.ts

@@ -221,6 +221,16 @@ export declare const telaAgentSessionResultSchema: z.ZodObject<{
     content: z.ZodOptional<z.ZodString>;
     structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    uiLanguage: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodEnum<{
+            openui: "openui";
+        }>;
+        profile: z.ZodEnum<{
+            web: "web";
+            slack: "slack";
+        }>;
+        libraryVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
 }, z.core.$catchall<z.ZodUnknown>>;
 export declare const telaAgentDirectStreamSchema: z.ZodObject<{
     url: z.ZodString;
@@ -270,6 +280,16 @@ export declare const telaAgentSessionSchema: z.ZodObject<{
         content: z.ZodOptional<z.ZodString>;
         structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        uiLanguage: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodEnum<{
+                openui: "openui";
+            }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
+            libraryVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
     }, z.core.$catchall<z.ZodUnknown>>>;
     error: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodNumber>;
@@ -364,6 +384,16 @@ export declare const telaAgentV4SessionResultEventSchema: z.ZodObject<{
         content: z.ZodOptional<z.ZodString>;
         structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        uiLanguage: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodEnum<{
+                openui: "openui";
+            }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
+            libraryVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
     }, z.core.$catchall<z.ZodUnknown>>;
     nextCursor: z.ZodNullable<z.ZodNumber>;
     createdAt: z.ZodNumber;
@@ -431,6 +461,16 @@ export declare const telaAgentV4SessionStreamEventSchema: z.ZodDiscriminatedUnio
         content: z.ZodOptional<z.ZodString>;
         structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        uiLanguage: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodEnum<{
+                openui: "openui";
+            }>;
+            profile: z.ZodEnum<{
+                web: "web";
+                slack: "slack";
+            }>;
+            libraryVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
     }, z.core.$catchall<z.ZodUnknown>>;
     nextCursor: z.ZodNullable<z.ZodNumber>;
     createdAt: z.ZodNumber;

package/dist/runtime/types/schemas/integrations/tela-agent-api.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { chatModelSchema } from '../chat/models';
+import { uiLanguageStampSchema } from '../chat/ui-language';
 export const telaAgentAttachmentSchema = z.object({
     vaultRef: z.string().startsWith('vault://'),
     filename: z.string().min(1).max(255),
@@ -122,6 +123,8 @@ export const telaAgentSessionResultSchema = z.object({
     content: z.string().optional(),
     structuredContent: z.record(z.string(), z.unknown()).optional(),
     childEventIds: z.array(z.string()).optional(),
+    // The stamp only informs: one the chat-api cannot read never fails the turn.
+    uiLanguage: uiLanguageStampSchema.nullable().optional().catch(null),
 }).catchall(z.unknown());
 export const telaAgentDirectStreamSchema = z.object({
     url: z.string().url(),

package/dist/runtime/types/schemas/integrations/tela-api.d.ts

@@ -56,3 +56,14 @@ export declare const telaWorkstationSchema: z.ZodObject<{
     updatedAt: z.ZodString;
 }, z.core.$catchall<z.ZodUnknown>>;
 export type TelaWorkstation = z.infer<typeof telaWorkstationSchema>;
+export declare const telaAgentCatalogEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    isMultiturn: z.ZodNullable<z.ZodBoolean>;
+    inputSchema: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+}, z.core.$strip>;
+export type TelaAgentCatalogEntry = z.infer<typeof telaAgentCatalogEntrySchema>;

package/dist/runtime/types/schemas/integrations/tela-api.js

@@ -41,3 +41,11 @@ export const telaWorkstationSchema = z.object({
     createdAt: z.string(),
     updatedAt: z.string(),
 }).catchall(z.unknown());
+export const telaAgentCatalogEntrySchema = z.object({
+    id: z.string().min(1),
+    workspaceId: z.string().min(1),
+    title: z.string(),
+    description: z.string().nullable(),
+    isMultiturn: z.boolean().nullable(),
+    inputSchema: z.array(z.object({ required: z.boolean().optional() }).catchall(z.unknown())).nullable(),
+});

package/dist/runtime/types/schemas/integrations/tela-auth.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const organizationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const identitySchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    organization: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const tokensSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    organization: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+}, z.core.$strip>;
+export declare const deviceSchema: z.ZodObject<{
+    device_code: z.ZodString;
+    user_code: z.ZodString;
+    verification_uri: z.ZodURL;
+    verification_uri_complete: z.ZodURL;
+    expires_in: z.ZodNumber;
+    interval: z.ZodNumber;
+}, z.core.$strip>;
+export type AuthTokens = z.infer<typeof tokensSchema>;
+export type DeviceAuthorization = z.infer<typeof deviceSchema>;

package/dist/runtime/types/schemas/integrations/tela-auth.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export const organizationSchema = z.object({ id: z.string().min(1), name: z.string() });
+export const identitySchema = z.object({ user: z.object({ id: z.string().min(1), name: z.string().max(300).optional(), email: z.string().max(320).optional() }), organization: organizationSchema });
+export const tokensSchema = identitySchema.extend({ accessToken: z.string().min(1), refreshToken: z.string().min(1) });
+export const deviceSchema = z.object({
+    device_code: z.string().min(1),
+    user_code: z.string().min(1),
+    verification_uri: z.url(),
+    verification_uri_complete: z.url(),
+    expires_in: z.number().int().positive(),
+    interval: z.number().int().positive(),
+});