@meistrari/chat-nuxt 1.4.0 → 1.5.0

package/dist/runtime/server/utils/tela-agent-session.js

@@ -0,0 +1,350 @@
+import { createError } from "h3";
+import { jsonMarkdown } from "#chat-runtime/utils/markdown-nodes";
+const INTERRUPTED_GENERATION_TEXT = "_Gera\xE7\xE3o interrompida pelo usu\xE1rio_";
+const POSTGRES_NUL_BYTE = String.fromCharCode(0);
+const REASONING_TAG_PATTERN = /<reasoning>[\s\S]*?(?:<\/reasoning>|$)/g;
+const ANSWER_TAG_PATTERN = /<answer>([\s\S]*?)(?:<\/answer>|$)/;
+const MARKDOWN_HEADING_PATTERN = /(?:^|\r?\n)#{1,6}\s+\S.*$/gm;
+const BINARY_ARTIFACT_MARKERS = [
+  "%PDF-",
+  `PK${String.fromCharCode(3)}${String.fromCharCode(4)}`
+];
+function getVaultRef(file) {
+  return file.vaultReference?.trim() || (file.url.startsWith("vault://") ? file.url : null);
+}
+function requireVaultRef(file) {
+  const vaultRef = getVaultRef(file);
+  if (!vaultRef) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Tela agent attachments require vault-backed files"
+    });
+  }
+  return vaultRef;
+}
+export function toTelaAgentInputSchema(files, inputVariables) {
+  const fileInputVariables = (inputVariables ?? []).filter((input) => input.type === "file" && input.name.trim());
+  if (fileInputVariables.length !== 1)
+    return [];
+  const inputName = fileInputVariables[0].name;
+  return (files ?? []).map((file) => {
+    return {
+      type: "file",
+      name: inputName,
+      vaultRef: requireVaultRef(file),
+      filename: file.name.slice(0, 255)
+    };
+  });
+}
+export function toTelaAgentAttachments(files) {
+  return (files ?? []).map((file) => ({
+    vaultRef: requireVaultRef(file),
+    filename: file.name.slice(0, 255)
+  }));
+}
+export function getTelaAgentStepSyncId(step) {
+  return step.eventId ?? step.id;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function sanitizeText(value) {
+  return value.replaceAll(POSTGRES_NUL_BYTE, "");
+}
+function sanitizeUnknown(value) {
+  if (typeof value === "string")
+    return sanitizeText(value);
+  if (Array.isArray(value))
+    return value.map((item) => sanitizeUnknown(item));
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, sanitizeUnknown(item)])
+    );
+  }
+  return value;
+}
+function sanitizeRecord(value) {
+  return sanitizeUnknown(value);
+}
+function decodeUriSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function extractMissingVaultFileName(error) {
+  const messageMatch = /\bFile\s+(.+?)\s+not found in workspace\b/i.exec(error);
+  const messageFileName = messageMatch?.[1]?.trim();
+  if (messageFileName)
+    return sanitizeText(messageFileName);
+  const urlMatch = /\/files\/([^:\s?#]+).*?\b404\s+Not Found\b/is.exec(error);
+  const urlFileName = urlMatch?.[1]?.trim();
+  if (urlFileName)
+    return sanitizeText(decodeUriSegment(urlFileName));
+  return null;
+}
+function formatTelaAgentFailureMessage(error) {
+  const sanitizedError = sanitizeText(error ?? "Agent execution failed");
+  const missingVaultFileName = extractMissingVaultFileName(sanitizedError);
+  if (missingVaultFileName) {
+    return `Erro: O arquivo ${JSON.stringify(missingVaultFileName)} n\xE3o foi encontrado neste workspace. Envie o arquivo novamente ou confira se a refer\xEAncia do Vault pertence ao workspace atual.`;
+  }
+  return `Error: ${sanitizedError}`;
+}
+function extractTaggedAnswer(value) {
+  const match = value.match(ANSWER_TAG_PATTERN);
+  return match?.[1]?.trim() || null;
+}
+function stripTaggedReasoning(value) {
+  return value.replace(REASONING_TAG_PATTERN, "").trim();
+}
+function findBinaryArtifactStart(value) {
+  let index = -1;
+  for (const marker of BINARY_ARTIFACT_MARKERS) {
+    let searchStart = 0;
+    while (searchStart < value.length) {
+      const markerIndex = value.indexOf(marker, searchStart);
+      if (markerIndex === -1)
+        break;
+      if (markerIndex === 0 || value[markerIndex - 1] === "\n") {
+        index = index === -1 ? markerIndex : Math.min(index, markerIndex);
+        break;
+      }
+      searchStart = markerIndex + marker.length;
+    }
+  }
+  return index;
+}
+function stripBinaryArtifactContent(value) {
+  const index = findBinaryArtifactStart(value);
+  if (index === -1)
+    return value;
+  return value.slice(0, index).trimEnd();
+}
+function looksLikeGeneratedArtifactScript(value) {
+  const trimmed = value.trim();
+  if (!trimmed)
+    return false;
+  const hasScriptShape = /^#!\/usr\/bin\/env\s+\S+/m.test(trimmed) || /(?:^|\n)# -\*- coding:/.test(trimmed) || /(?:^|\n)from\s+\S+\s+import\s+\S+/.test(trimmed) || /(?:^|\n)import\s+\S+/.test(trimmed) || /(?:^|\n)(?:class|def)\s+\w+/.test(trimmed);
+  const hasGeneratedFileSignal = /vault:\/\/|\.output\s*\(|open\s*\([^)]*,\s*['"][wa]/.test(trimmed);
+  return hasScriptShape && hasGeneratedFileSignal;
+}
+function findGeneratedArtifactMarkdownStart(value) {
+  for (const match of value.matchAll(MARKDOWN_HEADING_PATTERN)) {
+    if (match.index === void 0)
+      continue;
+    const headingOffset = match[0].match(/^[\r\n]+/)?.[0].length ?? 0;
+    const markdownStart = match.index + headingOffset;
+    const heading = value.slice(markdownStart, match.index + match[0].length).trim();
+    if (/^#{1,6}\s+-\*-/.test(heading))
+      continue;
+    if (looksLikeGeneratedArtifactScript(value.slice(0, markdownStart)))
+      return markdownStart;
+  }
+  return -1;
+}
+function stripGeneratedArtifactScriptPrefix(value) {
+  const markdownStart = findGeneratedArtifactMarkdownStart(value);
+  if (markdownStart === -1)
+    return value;
+  return value.slice(markdownStart).trimStart();
+}
+function normalizeTelaAgentResultContent(value) {
+  const sanitized = sanitizeText(value);
+  const taggedAnswer = extractTaggedAnswer(sanitized);
+  let normalized = taggedAnswer ?? sanitized;
+  let changed = taggedAnswer !== null;
+  const withoutTaggedReasoning = stripTaggedReasoning(normalized);
+  changed ||= withoutTaggedReasoning !== normalized;
+  normalized = withoutTaggedReasoning;
+  const withoutBinaryArtifacts = stripBinaryArtifactContent(normalized);
+  changed ||= withoutBinaryArtifacts !== normalized;
+  normalized = withoutBinaryArtifacts;
+  const withoutGeneratedScript = stripGeneratedArtifactScriptPrefix(normalized);
+  changed ||= withoutGeneratedScript !== normalized;
+  normalized = withoutGeneratedScript;
+  const withoutTrailingBinaryArtifacts = stripBinaryArtifactContent(normalized);
+  changed ||= withoutTrailingBinaryArtifacts !== normalized;
+  normalized = withoutTrailingBinaryArtifacts;
+  return changed ? normalized.trim() : normalized;
+}
+function getStringProperty(record, key) {
+  const value = record[key];
+  if (typeof value !== "string")
+    return null;
+  const sanitized = sanitizeText(value);
+  return sanitized.trim() ? sanitized : null;
+}
+function getContentPartText(part) {
+  return getStringProperty(part, "text") ?? getStringProperty(part, "thinking");
+}
+function normalizeToolResultContent(content) {
+  if (typeof content === "string")
+    return sanitizeText(content);
+  if (Array.isArray(content))
+    return sanitizeUnknown(content);
+  return "";
+}
+function normalizeMessageContentPart(part) {
+  if (!isRecord(part))
+    return null;
+  const type = getStringProperty(part, "type");
+  if (!type)
+    return null;
+  if (type === "text" || type === "thinking" || type === "reasoning") {
+    const text2 = getContentPartText(part);
+    return text2 ? { type: "text", text: text2 } : null;
+  }
+  if (type === "tool_use") {
+    const id = getStringProperty(part, "id");
+    const name = getStringProperty(part, "name");
+    if (!id || !name)
+      return null;
+    return {
+      type: "tool_use",
+      id,
+      name,
+      input: isRecord(part.input) ? sanitizeRecord(part.input) : {}
+    };
+  }
+  if (type === "tool_result") {
+    const toolUseId = getStringProperty(part, "tool_use_id");
+    if (!toolUseId)
+      return null;
+    return {
+      type: "tool_result",
+      tool_use_id: toolUseId,
+      content: normalizeToolResultContent(part.content),
+      ...typeof part.is_error === "boolean" ? { is_error: part.is_error } : {}
+    };
+  }
+  const text = getContentPartText(part);
+  return text ? { type: "text", text } : null;
+}
+function normalizeStepMessageContent(step) {
+  const record = step;
+  const message = record.message;
+  if (isRecord(message) && Array.isArray(message.content)) {
+    return message.content.map((part) => normalizeMessageContentPart(part)).filter((part) => Boolean(part));
+  }
+  const text = getStepText(step);
+  return text ? [{ type: "text", text }] : [];
+}
+function getStepText(step) {
+  const record = step;
+  const directText = getStringProperty(record, "content") ?? getStringProperty(record, "text") ?? getStringProperty(record, "output");
+  if (directText)
+    return directText;
+  const message = record.message;
+  if (typeof message === "string" && message.trim())
+    return message;
+  if (isRecord(message) && Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (!isRecord(part))
+        continue;
+      const text = getContentPartText(part);
+      if (text)
+        return text;
+    }
+  }
+  return null;
+}
+export function normalizeTelaAgentReasoningStep(sessionId, step) {
+  const content = normalizeStepMessageContent(step);
+  if (content.length === 0)
+    return null;
+  const record = step;
+  const message = isRecord(record.message) ? record.message : null;
+  const sourceType = getStringProperty(record, "type");
+  const type = sourceType === "user" ? "user" : "assistant";
+  const role = message ? getStringProperty(message, "role") : null;
+  const timestamp = typeof record.timestamp === "number" ? record.timestamp : Date.now();
+  const timeElapsed = typeof record.timeElapsed === "number" ? record.timeElapsed : 0;
+  const parentToolUseId = getStringProperty(record, "parent_tool_use_id");
+  return {
+    type,
+    uuid: getTelaAgentStepSyncId(step),
+    message: {
+      role: role ?? (type === "user" ? "user" : "assistant"),
+      content
+    },
+    timestamp,
+    session_id: sessionId,
+    timeElapsed,
+    parent_tool_use_id: parentToolUseId
+  };
+}
+export function getNewTelaAgentSteps(session, lastSyncedStepId) {
+  if (!lastSyncedStepId)
+    return session.steps;
+  const lastSyncedIndex = session.steps.findIndex((step) => getTelaAgentStepSyncId(step) === lastSyncedStepId);
+  return session.steps.slice(lastSyncedIndex + 1);
+}
+export function extractTelaAgentAssistantContent(session, steps = session.steps) {
+  const structuredContent = session.result?.structuredContent;
+  if (structuredContent)
+    return sanitizeText(jsonMarkdown(structuredContent));
+  if (session.result?.content)
+    return normalizeTelaAgentResultContent(session.result.content);
+  for (let i = steps.length - 1; i >= 0; i--) {
+    const text = getStepText(steps[i]);
+    if (text)
+      return text;
+  }
+  return "";
+}
+export function mapTelaAgentSessionToMessageUpdate(session, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const newSteps = getNewTelaAgentSteps(session, options.lastSyncedStepId);
+  const reasoningData = newSteps.map((step) => normalizeTelaAgentReasoningStep(session.sessionId, step)).filter((step) => Boolean(step));
+  const accumulatedReasoningData = [
+    ...options.existingReasoningData ?? [],
+    ...reasoningData
+  ];
+  const lastStep = newSteps.at(-1);
+  const update = {};
+  if (reasoningData.length > 0)
+    update.reasoningData = accumulatedReasoningData;
+  if (reasoningData.length > 0 && lastStep)
+    update.externalUuid = getTelaAgentStepSyncId(lastStep);
+  if (!options.pendingMessageTtft && options.userMessageCreatedAt && reasoningData.length > 0) {
+    update.ttft = String(now.getTime() - options.userMessageCreatedAt.getTime());
+  }
+  if (session.status === "completed" || session.status === "waiting_messages") {
+    update.content = extractTelaAgentAssistantContent(session);
+    update.status = "completed";
+    update.updatedAt = now;
+  } else if (session.status === "failed") {
+    update.content = formatTelaAgentFailureMessage(session.error);
+    update.status = "failed";
+    update.updatedAt = now;
+  } else if (session.status === "cancelled") {
+    update.content = INTERRUPTED_GENERATION_TEXT;
+    update.status = "completed";
+    update.updatedAt = now;
+  }
+  return update;
+}
+export function mapTelaAgentUsage(session) {
+  const usage = session.result?.usage;
+  if (!usage)
+    return null;
+  return {
+    promptTokens: usage.promptTokens ?? 0,
+    completionTokens: usage.completionTokens ?? 0,
+    totalTokens: usage.totalTokens ?? 0,
+    promptCost: String(usage.promptCost ?? 0),
+    completionCost: String(usage.completionCost ?? 0),
+    totalCost: String(usage.totalCost ?? 0),
+    durationMs: usage.duration ?? null,
+    turns: usage.turns ?? null,
+    model: null,
+    cacheReadInputTokens: null,
+    cacheCreationInputTokens: null,
+    modelUsage: null,
+    durationApiMs: null,
+    webSearchRequests: null,
+    webFetchRequests: null
+  };
+}

package/dist/runtime/types/embed.d.ts

@@ -0,0 +1,29 @@
+import type { Component, DeepReadonly } from 'vue';
+import type { WorkspaceSettings } from './workspace-settings-data.js';
+import type { TelaAgentExecutionInput } from './tela-agent.js';
+import type { ChatLoadingMessageMode } from '../utils/chat-loading-messages.js';
+import type { ChatActor, ChatFeatureConfig } from '../utils/tela-chat.js';
+export type ChatEmbedSharedProps = {
+    conversationId?: string | null;
+    initialConversationId?: string | null;
+    hideSidebar?: boolean;
+    loadingMessages?: readonly string[] | null;
+    loadingMessagesMode?: ChatLoadingMessageMode | null;
+    customComponents?: Record<string, Component>;
+    customHtmlTags?: readonly string[];
+};
+export type DefaultChatEmbedProps = ChatEmbedSharedProps & {
+    telaAgentId?: undefined;
+    telaAgentInputs?: undefined;
+    workspaceSettings?: DeepReadonly<WorkspaceSettings> | WorkspaceSettings | null;
+    user?: ChatActor | null;
+    features?: Partial<ChatFeatureConfig>;
+};
+export type TelaAgentChatEmbedProps = ChatEmbedSharedProps & {
+    telaAgentId: string;
+    telaAgentInputs?: DeepReadonly<TelaAgentExecutionInput[]> | null;
+    workspaceSettings?: never;
+    user?: never;
+    features?: Partial<ChatFeatureConfig>;
+};
+export type MeistrariChatEmbedProps = DefaultChatEmbedProps | TelaAgentChatEmbedProps;

package/dist/runtime/types/tela-agent.d.ts

@@ -0,0 +1,243 @@
+import { z } from 'zod';
+export declare const telaAgentAttachmentSchema: z.ZodObject<{
+    vaultRef: z.ZodString;
+    filename: z.ZodString;
+}, z.core.$strip>;
+export declare const telaAgentInputVariableSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        text: "text";
+        file: "file";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentInputVariable = z.infer<typeof telaAgentInputVariableSchema>;
+export declare const telaAgentFileInputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    name: z.ZodString;
+    vaultRef: z.ZodString;
+    filename: z.ZodString;
+    metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const telaAgentTextInputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    name: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const telaAgentExecutionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    name: z.ZodString;
+    vaultRef: z.ZodString;
+    filename: z.ZodString;
+    metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    name: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>], "type">;
+export type TelaAgentExecutionInput = z.infer<typeof telaAgentExecutionInputSchema>;
+export declare const telaAgentRunPayloadSchema: z.ZodObject<{
+    message: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        name: z.ZodString;
+        vaultRef: z.ZodString;
+        filename: z.ZodString;
+        metadata: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        vaultRef: z.ZodString;
+        filename: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentRunPayload = z.infer<typeof telaAgentRunPayloadSchema>;
+export declare const telaAgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    inputSchema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            text: "text";
+            file: "file";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodUnknown>>>>>, z.ZodTransform<{
+        [x: string]: unknown;
+        name: string;
+        type: "text" | "file";
+        id?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | null | undefined;
+    }[], {
+        [x: string]: unknown;
+        name: string;
+        type: "text" | "file";
+        id?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | null | undefined;
+    }[] | null | undefined>>;
+    isMultiturn: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgent = z.infer<typeof telaAgentSchema>;
+export declare const telaAgentRunResponseSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentRunResponse = z.infer<typeof telaAgentRunResponseSchema>;
+export declare const telaAgentSessionStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    waiting_messages: "waiting_messages";
+    cancelled: "cancelled";
+}>;
+export type TelaAgentSessionStatus = z.infer<typeof telaAgentSessionStatusSchema>;
+export declare const telaAgentStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    eventId: z.ZodOptional<z.ZodString>;
+    inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cacheCreationInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    calculatedCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentStep = z.infer<typeof telaAgentStepSchema>;
+export declare const telaAgentUsageSchema: z.ZodObject<{
+    duration: z.ZodOptional<z.ZodNumber>;
+    turns: z.ZodOptional<z.ZodNumber>;
+    completionTokens: z.ZodOptional<z.ZodNumber>;
+    promptTokens: z.ZodOptional<z.ZodNumber>;
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+    completionCost: z.ZodOptional<z.ZodNumber>;
+    promptCost: z.ZodOptional<z.ZodNumber>;
+    totalCost: z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentSessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        waiting_messages: "waiting_messages";
+        cancelled: "cancelled";
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        eventId: z.ZodOptional<z.ZodString>;
+        inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cacheCreationInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        calculatedCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    nextCursor: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    result: z.ZodOptional<z.ZodObject<{
+        usage: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodOptional<z.ZodNumber>;
+            turns: z.ZodOptional<z.ZodNumber>;
+            completionTokens: z.ZodOptional<z.ZodNumber>;
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            completionCost: z.ZodOptional<z.ZodNumber>;
+            promptCost: z.ZodOptional<z.ZodNumber>;
+            totalCost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        content: z.ZodOptional<z.ZodString>;
+        structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type TelaAgentSession = z.infer<typeof telaAgentSessionSchema>;
+export declare const telaAgentRunApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        inputSchema: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                text: "text";
+                file: "file";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$catchall<z.ZodUnknown>>>>>, z.ZodTransform<{
+            [x: string]: unknown;
+            name: string;
+            type: "text" | "file";
+            id?: string | undefined;
+            required?: boolean | undefined;
+            description?: string | null | undefined;
+        }[], {
+            [x: string]: unknown;
+            name: string;
+            type: "text" | "file";
+            id?: string | undefined;
+            required?: boolean | undefined;
+            description?: string | null | undefined;
+        }[] | null | undefined>>;
+        isMultiturn: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentSessionApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        sessionId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            waiting_messages: "waiting_messages";
+            cancelled: "cancelled";
+        }>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            eventId: z.ZodOptional<z.ZodString>;
+            inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cacheCreationInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            calculatedCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        nextCursor: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        result: z.ZodOptional<z.ZodObject<{
+            usage: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodOptional<z.ZodNumber>;
+                turns: z.ZodOptional<z.ZodNumber>;
+                completionTokens: z.ZodOptional<z.ZodNumber>;
+                promptTokens: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+                completionCost: z.ZodOptional<z.ZodNumber>;
+                promptCost: z.ZodOptional<z.ZodNumber>;
+                totalCost: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+            content: z.ZodOptional<z.ZodString>;
+            structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            childEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+        error: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodNumber>;
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const telaAgentEndSessionApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$catchall<z.ZodUnknown>>;