@meistrari/chat-nuxt 3.10.0 → 3.11.1

package/dist/runtime/messages/composables/use-direct-stream.d.ts

@@ -0,0 +1,41 @@
+import type { SendMessageResponse } from '../../types/schemas/chat/messages.js';
+export type DirectStreamActivity = 'idle' | 'connected' | 'active';
+export type SseFrame = {
+    event?: string;
+    data: string;
+};
+export type MessagePartsEvent = {
+    kind: 'message-parts';
+    runId: string;
+    deltaSeq: number;
+    parentToolUseId?: string | null;
+    event: Record<string, unknown>;
+};
+export type MessagePartsAccumulator = {
+    runId: string | null;
+    lastDeltaSeq: number;
+    textByIndex: Record<number, string>;
+    thinkingByIndex: Record<number, string>;
+};
+export declare function parseSseFrames(source: string): {
+    frames: SseFrame[];
+    rest: string;
+};
+export declare function createMessagePartsAccumulator(runId?: string | null): MessagePartsAccumulator;
+export declare function applyMessagePartsEvent(accumulator: MessagePartsAccumulator, input: MessagePartsEvent): {
+    text: string;
+    thinking: string;
+    changed: boolean;
+};
+export declare function useDirectStream(options?: {
+    onResult?: () => void;
+    onDisconnect?: () => void;
+}): {
+    activity: any;
+    streamingText: any;
+    streamingThinking: any;
+    activeRunId: any;
+    connectMessage: (url: string, init: RequestInit, onAccepted: (response: SendMessageResponse) => void) => Promise<SendMessageResponse>;
+    beginMessage: () => void;
+    disconnect: (reset?: boolean) => void;
+};

package/dist/runtime/messages/composables/use-direct-stream.js

@@ -0,0 +1,263 @@
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parseSseFrames(source) {
+  const frames = [];
+  let rest = source;
+  while (true) {
+    const boundary = /\r?\n\r?\n/.exec(rest);
+    if (!boundary || boundary.index === void 0)
+      break;
+    const rawFrame = rest.slice(0, boundary.index);
+    rest = rest.slice(boundary.index + boundary[0].length);
+    let event;
+    const data = [];
+    for (const line of rawFrame.split(/\r?\n/)) {
+      if (line.startsWith(":"))
+        continue;
+      const separator = line.indexOf(":");
+      const field = separator === -1 ? line : line.slice(0, separator);
+      const rawValue = separator === -1 ? "" : line.slice(separator + 1);
+      const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+      if (field === "event")
+        event = value;
+      else if (field === "data")
+        data.push(value);
+    }
+    if (data.length > 0)
+      frames.push({ ...event ? { event } : {}, data: data.join("\n") });
+  }
+  return { frames, rest };
+}
+export function createMessagePartsAccumulator(runId = null) {
+  return {
+    runId,
+    lastDeltaSeq: -1,
+    textByIndex: {},
+    thinkingByIndex: {}
+  };
+}
+function joinedBlocks(blocks) {
+  return Object.entries(blocks).sort(([left], [right]) => Number(left) - Number(right)).map(([, value]) => value).join("");
+}
+export function applyMessagePartsEvent(accumulator, input) {
+  if (accumulator.runId !== input.runId) {
+    accumulator.runId = input.runId;
+    accumulator.lastDeltaSeq = -1;
+    accumulator.textByIndex = {};
+    accumulator.thinkingByIndex = {};
+  }
+  if (input.deltaSeq <= accumulator.lastDeltaSeq) {
+    return {
+      text: joinedBlocks(accumulator.textByIndex),
+      thinking: joinedBlocks(accumulator.thinkingByIndex),
+      changed: false
+    };
+  }
+  accumulator.lastDeltaSeq = input.deltaSeq;
+  if (input.parentToolUseId) {
+    return {
+      text: joinedBlocks(accumulator.textByIndex),
+      thinking: joinedBlocks(accumulator.thinkingByIndex),
+      changed: false
+    };
+  }
+  const providerEvent = input.event;
+  if (providerEvent.type === "message_start") {
+    accumulator.textByIndex = {};
+    accumulator.thinkingByIndex = {};
+    return { text: "", thinking: "", changed: true };
+  }
+  const index = providerEvent.index;
+  if (typeof index !== "number" || !Number.isInteger(index)) {
+    return {
+      text: joinedBlocks(accumulator.textByIndex),
+      thinking: joinedBlocks(accumulator.thinkingByIndex),
+      changed: false
+    };
+  }
+  const contentBlock = isRecord(providerEvent.content_block) ? providerEvent.content_block : null;
+  const delta = isRecord(providerEvent.delta) ? providerEvent.delta : null;
+  let changed = false;
+  if (providerEvent.type === "content_block_start" && contentBlock?.type === "text" && typeof contentBlock.text === "string") {
+    accumulator.textByIndex[index] = contentBlock.text;
+    changed = true;
+  } else if (providerEvent.type === "content_block_start" && contentBlock?.type === "thinking" && typeof contentBlock.thinking === "string") {
+    accumulator.thinkingByIndex[index] = contentBlock.thinking;
+    changed = true;
+  } else if (providerEvent.type === "content_block_delta" && delta?.type === "text_delta" && typeof delta.text === "string") {
+    accumulator.textByIndex[index] = `${accumulator.textByIndex[index] ?? ""}${delta.text}`;
+    changed = true;
+  } else if (providerEvent.type === "content_block_delta" && delta?.type === "thinking_delta" && typeof delta.thinking === "string") {
+    accumulator.thinkingByIndex[index] = `${accumulator.thinkingByIndex[index] ?? ""}${delta.thinking}`;
+    changed = true;
+  }
+  return {
+    text: joinedBlocks(accumulator.textByIndex),
+    thinking: joinedBlocks(accumulator.thinkingByIndex),
+    changed
+  };
+}
+function reviveMessagePair(input) {
+  return {
+    userMessage: {
+      ...input.userMessage,
+      createdAt: new Date(input.userMessage.createdAt),
+      updatedAt: input.userMessage.updatedAt ? new Date(input.userMessage.updatedAt) : null
+    },
+    assistantMessage: {
+      ...input.assistantMessage,
+      createdAt: new Date(input.assistantMessage.createdAt),
+      updatedAt: input.assistantMessage.updatedAt ? new Date(input.assistantMessage.updatedAt) : null
+    }
+  };
+}
+export function useDirectStream(options = {}) {
+  const activity = ref("idle");
+  const streamingText = ref("");
+  const streamingThinking = ref("");
+  const activeRunId = ref(null);
+  let accumulator = createMessagePartsAccumulator();
+  let abortController = null;
+  function resetAccumulator(runId = null) {
+    accumulator = createMessagePartsAccumulator(runId);
+    activeRunId.value = runId;
+    streamingText.value = "";
+    streamingThinking.value = "";
+  }
+  function beginMessage() {
+    resetAccumulator(activeRunId.value);
+    activity.value = "idle";
+  }
+  function disconnect(reset = true) {
+    abortController?.abort();
+    abortController = null;
+    activity.value = "idle";
+    if (reset)
+      resetAccumulator();
+  }
+  async function connectMessage(url, init, onAccepted) {
+    if (import.meta.server)
+      throw new Error("Message streaming is unavailable during server rendering");
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    let response;
+    try {
+      response = await fetch(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      if (abortController === controller)
+        abortController = null;
+      throw error;
+    }
+    if (!response.ok) {
+      if (abortController === controller)
+        abortController = null;
+      throw new Error(`Message stream request failed with status ${response.status}`);
+    }
+    if (!response.body) {
+      if (abortController === controller)
+        abortController = null;
+      throw new Error("Message stream response has no body");
+    }
+    activity.value = "connected";
+    let resolveAccepted;
+    let rejectAccepted;
+    const acceptedPromise = new Promise((resolve, reject) => {
+      resolveAccepted = resolve;
+      rejectAccepted = reject;
+    });
+    let accepted = false;
+    let terminal = false;
+    void (async () => {
+      try {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffered = "";
+        while (!controller.signal.aborted) {
+          const { value, done } = await reader.read();
+          if (done)
+            break;
+          if (controller.signal.aborted)
+            break;
+          buffered += decoder.decode(value, { stream: true });
+          const parsed = parseSseFrames(buffered);
+          buffered = parsed.rest;
+          for (const frame of parsed.frames) {
+            if (controller.signal.aborted)
+              break;
+            if (frame.data === "[DONE]")
+              continue;
+            if (frame.event === "message-accepted") {
+              try {
+                const messagePair = reviveMessagePair(JSON.parse(frame.data));
+                accepted = true;
+                onAccepted(messagePair);
+                resolveAccepted(messagePair);
+              } catch (error) {
+                rejectAccepted(error);
+              }
+              continue;
+            }
+            let event;
+            try {
+              event = JSON.parse(frame.data);
+            } catch {
+              continue;
+            }
+            if (!isRecord(event) || typeof event.kind !== "string")
+              continue;
+            activity.value = "active";
+            if (event.kind === "result") {
+              terminal = true;
+              options.onResult?.();
+              continue;
+            }
+            if (event.kind === "error") {
+              if (event.recoverable !== true) {
+                terminal = true;
+                options.onResult?.();
+              }
+              continue;
+            }
+            if (event.kind === "status" && (event.status === "failed" || event.status === "cancelled")) {
+              terminal = true;
+              options.onResult?.();
+              continue;
+            }
+            if (event.kind !== "message-parts" || typeof event.runId !== "string" || typeof event.deltaSeq !== "number" || !Number.isInteger(event.deltaSeq) || event.deltaSeq < 0 || !isRecord(event.event)) {
+              continue;
+            }
+            const accumulated = applyMessagePartsEvent(accumulator, event);
+            activeRunId.value = accumulator.runId;
+            if (accumulated.changed) {
+              streamingText.value = accumulated.text;
+              streamingThinking.value = accumulated.thinking;
+            }
+          }
+        }
+        if (!accepted)
+          rejectAccepted(new Error("Message stream ended before acknowledgement"));
+      } catch (error) {
+        if (!accepted)
+          rejectAccepted(error);
+      } finally {
+        if (abortController === controller)
+          abortController = null;
+        if (accepted && !terminal && !controller.signal.aborted)
+          options.onDisconnect?.();
+      }
+    })();
+    return acceptedPromise;
+  }
+  onUnmounted(() => disconnect());
+  return {
+    activity: readonly(activity),
+    streamingText: readonly(streamingText),
+    streamingThinking: readonly(streamingThinking),
+    activeRunId: readonly(activeRunId),
+    connectMessage,
+    beginMessage,
+    disconnect
+  };
+}

package/dist/runtime/messages/reasoning.d.ts

@@ -15,3 +15,10 @@ export type ToolGroup = {
     toolResult?: ToolResult;
 };
 export type ReasoningStep = string | ToolGroup;
+/**
+ * A turn that is still working towards its first output has no reasoning of its
+ * own yet, so the preparing steps stand in. That makes the wait read as an agent
+ * which has started working rather than as a loading placeholder. Any real
+ * reasoning wins immediately — the stand-ins never compete with it.
+ */
+export declare function resolveDisplayedReasoning(reasoningData: ReasoningStep[] | null | undefined, preparingSteps?: readonly string[] | null): ReasoningStep[];

package/dist/runtime/messages/reasoning.js

@@ -0,0 +1,5 @@
+export function resolveDisplayedReasoning(reasoningData, preparingSteps) {
+  if (Array.isArray(reasoningData) && reasoningData.length > 0)
+    return reasoningData;
+  return preparingSteps?.length ? [...preparingSteps] : [];
+}

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

@@ -213,6 +213,7 @@ export declare const conversationWithMessagesSchema: z.ZodObject<{
 export type ConversationWithMessages = z.infer<typeof conversationWithMessagesSchema>;
 export declare const createConversationRequestSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        "claude-opus-5": "claude-opus-5";
         "claude-opus-4-8": "claude-opus-4-8";
         "claude-sonnet-5": "claude-sonnet-5";
         "claude-haiku-4-5": "claude-haiku-4-5";
@@ -249,6 +250,7 @@ export type ConversationAgentInputsResponse = z.infer<typeof conversationAgentIn
 export declare const updateConversationRequestSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        "claude-opus-5": "claude-opus-5";
         "claude-opus-4-8": "claude-opus-4-8";
         "claude-sonnet-5": "claude-sonnet-5";
         "claude-haiku-4-5": "claude-haiku-4-5";

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

@@ -30,6 +30,26 @@ export declare const messageOverviewResponseSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type MessageOverviewResponse = z.infer<typeof messageOverviewResponseSchema>;
+/**
+ * What the send looked like from the client's side, so first-token latency can
+ * be reported against what the user actually saw. Durations only, never
+ * timestamps — the browser's clock never has to agree with the server's.
+ */
+export declare const sendMessageClientTimingSchema: z.ZodObject<{
+    /**
+     * Elapsed from the user's send to this request. Non-zero whenever the client
+     * gate held the send behind conversation creation, a model change or a
+     * sandbox wake.
+     */
+    sinceSendMs: z.ZodNumber;
+    /**
+     * When the client's stand-in step lands, measured from the same send. A run
+     * that produces nothing before then has already shown the user an answer
+     * starting, whatever the run's own latency turns out to be.
+     */
+    standInOutputAtMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type SendMessageClientTiming = z.infer<typeof sendMessageClientTimingSchema>;
 export declare const sendMessageBodySchema: z.ZodObject<{
     content: z.ZodString;
     files: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -50,6 +70,21 @@ export declare const sendMessageBodySchema: z.ZodObject<{
         name: z.ZodString;
         content: z.ZodString;
     }, z.core.$strip>], "type">>>;
+    wakeSessionId: z.ZodOptional<z.ZodString>;
+    clientTiming: z.ZodOptional<z.ZodObject<{
+        /**
+         * Elapsed from the user's send to this request. Non-zero whenever the client
+         * gate held the send behind conversation creation, a model change or a
+         * sandbox wake.
+         */
+        sinceSendMs: z.ZodNumber;
+        /**
+         * When the client's stand-in step lands, measured from the same send. A run
+         * that produces nothing before then has already shown the user an answer
+         * starting, whatever the run's own latency turns out to be.
+         */
+        standInOutputAtMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type SendMessageBody = z.infer<typeof sendMessageBodySchema>;
 export declare const sendMessageResponseSchema: z.ZodObject<{
@@ -165,6 +200,10 @@ export declare const messagePollResponseSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type MessagePollResponse = z.infer<typeof messagePollResponseSchema>;
+export declare const retryMessageBodySchema: z.ZodObject<{
+    wakeSessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RetryMessageBody = z.infer<typeof retryMessageBodySchema>;
 export declare const cancelConversationResponseSchema: z.ZodObject<{
     success: z.ZodLiteral<true>;
     cancelled: z.ZodBoolean;

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

@@ -26,10 +26,31 @@ export const messageOverviewResponseSchema = z.strictObject({
         createdAt: z.date(),
     }).nullable(),
 });
+/**
+ * What the send looked like from the client's side, so first-token latency can
+ * be reported against what the user actually saw. Durations only, never
+ * timestamps — the browser's clock never has to agree with the server's.
+ */
+export const sendMessageClientTimingSchema = z.strictObject({
+    /**
+     * Elapsed from the user's send to this request. Non-zero whenever the client
+     * gate held the send behind conversation creation, a model change or a
+     * sandbox wake.
+     */
+    sinceSendMs: z.number().int().min(0).max(600_000),
+    /**
+     * When the client's stand-in step lands, measured from the same send. A run
+     * that produces nothing before then has already shown the user an answer
+     * starting, whatever the run's own latency turns out to be.
+     */
+    standInOutputAtMs: z.number().int().min(0).max(600_000).optional(),
+});
 export const sendMessageBodySchema = z.strictObject({
     content: z.string(),
     files: z.array(fileUploadInputSchema).optional(),
     agentInputs: z.array(telaAgentExecutionInputSchema).optional(),
+    wakeSessionId: z.string().uuid().optional(),
+    clientTiming: sendMessageClientTimingSchema.optional(),
 });
 export const sendMessageResponseSchema = z.object({
     userMessage: messageSchema,
@@ -39,6 +60,9 @@ export const messagePollResponseSchema = z.object({
     messages: z.array(messageSchema),
     newFiles: z.array(messageFileSchema).optional(),
 });
+export const retryMessageBodySchema = z.strictObject({
+    wakeSessionId: z.string().uuid().optional(),
+});
 export const cancelConversationResponseSchema = z.object({
     success: z.literal(true),
     cancelled: z.boolean(),

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

@@ -1,10 +1,11 @@
 import { z } from 'zod';
-export declare const chatModelIds: readonly ["claude-opus-4-8", "claude-sonnet-5", "claude-haiku-4-5"];
+export declare const chatModelIds: readonly ["claude-opus-5", "claude-opus-4-8", "claude-sonnet-5", "claude-haiku-4-5"];
 export declare const chatModelSchema: z.ZodEnum<{
+    "claude-opus-5": "claude-opus-5";
     "claude-opus-4-8": "claude-opus-4-8";
     "claude-sonnet-5": "claude-sonnet-5";
     "claude-haiku-4-5": "claude-haiku-4-5";
 }>;
 export type ChatModel = z.infer<typeof chatModelSchema>;
-export declare const defaultChatModel = "claude-opus-4-8";
+export declare const defaultChatModel = "claude-opus-5";
 export declare function isValidChatModel(value: unknown): value is ChatModel;

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

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 export const chatModelIds = [
+    'claude-opus-5',
     'claude-opus-4-8',
     'claude-sonnet-5',
     'claude-haiku-4-5',
 ];
 export const chatModelSchema = z.enum(chatModelIds);
-export const defaultChatModel = 'claude-opus-4-8';
+export const defaultChatModel = 'claude-opus-5';
 export function isValidChatModel(value) {
     return typeof value === 'string' && chatModelIds.includes(value);
 }

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

@@ -20,6 +20,16 @@ export type ChatModelOption = {
     tabs: readonly string[];
 };
 export declare const chatModelOptions: readonly [{
+    readonly value: "claude-opus-5";
+    readonly label: "Claude Opus 5";
+    readonly description: "Agente de ponta para trabalho complexo";
+    readonly provider: "Anthropic";
+    readonly cost: 5;
+    readonly maxInputTokens: 1000000;
+    readonly maxOutputTokens: 128000;
+    readonly isMultiModal: true;
+    readonly tabs: readonly ["all", "advanced", "multimodal"];
+}, {
     readonly value: "claude-opus-4-8";
     readonly label: "Claude 4.8 Opus";
     readonly description: "Agente de ponta para tarefas complexas";

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

@@ -6,6 +6,7 @@ export const conversationCreatorFilterOptions = [
 // Metadata follows the agent model catalog on the Tela platform
 // (packages/application/composables/model.ts), curated to the models this app offers.
 export const chatModelOptions = [
+    { value: 'claude-opus-5', label: 'Claude Opus 5', description: 'Agente de ponta para trabalho complexo', provider: 'Anthropic', cost: 5, maxInputTokens: 1_000_000, maxOutputTokens: 128_000, isMultiModal: true, tabs: ['all', 'advanced', 'multimodal'] },
     { value: 'claude-opus-4-8', label: 'Claude 4.8 Opus', description: 'Agente de ponta para tarefas complexas', provider: 'Anthropic', cost: 4, maxInputTokens: 1_000_000, maxOutputTokens: 128_000, isMultiModal: true, tabs: ['all', 'advanced', 'multimodal'] },
     { value: 'claude-sonnet-5', label: 'Claude Sonnet 5', description: 'Agente rápido e inteligente de nova geração', provider: 'Anthropic', cost: 4, maxInputTokens: 1_000_000, maxOutputTokens: 64_000, isMultiModal: true, tabs: ['all', 'advanced', 'multimodal'] },
     { value: 'claude-haiku-4-5', label: 'Claude 4.5 Haiku', description: 'Agente rápido e eficiente para tarefas simples', provider: 'Anthropic', cost: 3, maxInputTokens: 200_000, maxOutputTokens: 64_000, isMultiModal: true, tabs: ['all', 'cheap', 'multimodal'] },

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

@@ -71,6 +71,7 @@ export declare const telaAgentContextFileSchema: z.ZodObject<{
 export type TelaAgentContextFile = z.infer<typeof telaAgentContextFileSchema>;
 export declare const telaAgentSchema: z.ZodObject<{
     id: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
     organizationName: z.ZodOptional<z.ZodString>;
     repository: z.ZodOptional<z.ZodString>;
     publishedId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -185,6 +186,13 @@ export declare const telaAgentSessionResultSchema: z.ZodObject<{
     structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentDirectStreamSchema: z.ZodObject<{
+    url: z.ZodString;
+    token: z.ZodString;
+    expiresAt: z.ZodNumber;
+    runId: z.ZodString;
+}, z.core.$strip>;
+export type TelaAgentDirectStream = z.infer<typeof telaAgentDirectStreamSchema>;
 export declare const telaAgentSessionSchema: z.ZodObject<{
     sessionId: z.ZodString;
     status: z.ZodEnum<{
@@ -205,6 +213,12 @@ export declare const telaAgentSessionSchema: z.ZodObject<{
         calculatedCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$catchall<z.ZodUnknown>>>;
     nextCursor: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    directStream: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        token: z.ZodString;
+        expiresAt: z.ZodNumber;
+        runId: z.ZodString;
+    }, z.core.$strip>>;
     result: z.ZodOptional<z.ZodObject<{
         usage: z.ZodOptional<z.ZodObject<{
             duration: z.ZodOptional<z.ZodNumber>;
@@ -226,6 +240,25 @@ export declare const telaAgentSessionSchema: z.ZodObject<{
     updatedAt: z.ZodOptional<z.ZodNumber>;
 }, z.core.$catchall<z.ZodUnknown>>;
 export type TelaAgentSession = z.infer<typeof telaAgentSessionSchema>;
+export declare const telaAgentWakeRequestSchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodEnum<{
+        "claude-opus-5": "claude-opus-5";
+        "claude-opus-4-8": "claude-opus-4-8";
+        "claude-sonnet-5": "claude-sonnet-5";
+        "claude-haiku-4-5": "claude-haiku-4-5";
+    }>>;
+}, z.core.$strip>;
+export type TelaAgentWakeRequest = z.infer<typeof telaAgentWakeRequestSchema>;
+export declare const telaAgentWakeResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        waking: "waking";
+        ready: "ready";
+        unavailable: "unavailable";
+    }>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TelaAgentWakeResponse = z.infer<typeof telaAgentWakeResponseSchema>;
 export declare const telaAgentV4SessionStatusEventSchema: z.ZodObject<{
     kind: z.ZodLiteral<"status">;
     sessionId: z.ZodString;
@@ -370,6 +403,7 @@ export declare const telaAgentRunApiResponseSchema: z.ZodObject<{
 export declare const telaAgentApiResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
         id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
         organizationName: z.ZodOptional<z.ZodString>;
         repository: z.ZodOptional<z.ZodString>;
         publishedId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -413,6 +447,7 @@ export declare const telaAgentApiResponseSchema: z.ZodObject<{
 export declare const telaAgentResolveApiResponseSchema: z.ZodObject<{
     agent: z.ZodObject<{
         id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
         organizationName: z.ZodOptional<z.ZodString>;
         repository: z.ZodOptional<z.ZodString>;
         publishedId: z.ZodOptional<z.ZodNullable<z.ZodString>>;

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { chatModelSchema } from '../chat/models';
 export const telaAgentAttachmentSchema = z.object({
     vaultRef: z.string().startsWith('vault://'),
     filename: z.string().min(1).max(255),
@@ -43,6 +44,7 @@ export const telaAgentContextFileSchema = z.object({
 });
 export const telaAgentSchema = z.object({
     id: z.string(),
+    projectId: z.string().optional(),
     organizationName: z.string().optional(),
     repository: z.string().optional(),
     publishedId: z.string().nullable().optional(),
@@ -99,16 +101,31 @@ export const telaAgentSessionResultSchema = z.object({
     structuredContent: z.record(z.string(), z.unknown()).optional(),
     childEventIds: z.array(z.string()).optional(),
 }).catchall(z.unknown());
+export const telaAgentDirectStreamSchema = z.object({
+    url: z.string().url(),
+    token: z.string().min(1),
+    expiresAt: z.number(),
+    runId: z.string().min(1),
+});
 export const telaAgentSessionSchema = z.object({
     sessionId: z.string(),
     status: telaAgentSessionStatusSchema,
     steps: z.array(telaAgentStepSchema),
     nextCursor: z.number().nullable().optional(),
+    directStream: telaAgentDirectStreamSchema.optional(),
     result: telaAgentSessionResultSchema.optional(),
     error: z.string().optional(),
     createdAt: z.number().optional(),
     updatedAt: z.number().optional(),
 }).catchall(z.unknown());
+export const telaAgentWakeRequestSchema = z.object({
+    sessionId: z.string().uuid().optional(),
+    model: chatModelSchema.optional(),
+});
+export const telaAgentWakeResponseSchema = z.object({
+    status: z.enum(['waking', 'ready', 'unavailable']),
+    sessionId: z.string().optional(),
+});
 export const telaAgentV4SessionStatusEventSchema = z.object({
     kind: z.literal('status'),
     sessionId: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "3.10.0",
+  "version": "3.11.1",
   "type": "module",
   "exports": {
     ".": {