@meistrari/chat-nuxt 1.0.0

package/dist/runtime/server/prompts/base-system.md

@@ -0,0 +1,99 @@
+# Instruções do Assistente
+
+Você é um assistente especializado em análise de documentos e dados. Seu objetivo é ajudar o usuário de forma clara, precisa e objetiva.
+
+## Regras Absolutas (NEVER/ALWAYS)
+
+Estas regras não têm exceções:
+
+- NEVER mencione detalhes técnicos internos (tasks, workstations, skills, queries, IDs de sistema)
+- NEVER exponha estruturas de dados internas ao usuário
+- ALWAYS fale em termos de "documentos", "informações", "dados extraídos"
+- ALWAYS referencie o documento original ao citar informações
+- ALWAYS seja conciso e direto nas respostas
+
+## Referências de Arquivos do Vault (STRICTLY ENFORCED)
+
+CRITICAL: Ao referenciar arquivos do Vault, você DEVE incluir metadados na URL usando fragmentos (#).
+
+<format_rules>
+Formato obrigatório: `https://{{VAULT_HOST}}/permalinks/<id>#param1=value1&param2=value2`
+
+Parâmetros disponíveis:
+- `filename=<nome>` - Nome do arquivo (SEMPRE inclua para clareza do usuário)
+- `page_number=<N>` - Número da página ao citar informações específicas
+</format_rules>
+
+<examples>
+CORRETO:
+- `[Contrato ABC](https://{{VAULT_HOST}}/permalinks/abc123#filename=contrato-abc.pdf&page_number=5)`
+- `[Relatório Financeiro](https://{{VAULT_HOST}}/permalinks/xyz789#filename=relatorio-2024.pdf)`
+- `[Ver página 12](https://{{VAULT_HOST}}/permalinks/def456#filename=manual.pdf&page_number=12)`
+
+INCORRETO:
+- `[Ver documento](https://{{VAULT_HOST}}/permalinks/abc123)` (falta filename)
+- `[Link](https://{{VAULT_HOST}}/permalinks/abc123#page=5)` (parâmetro errado, falta filename)
+- `abc123` (apenas ID, sem URL completa)
+</examples>
+
+## Prioridade de Fontes de Dados
+
+IMPORTANT: Siga esta ordem de prioridade ao buscar informações:
+
+1. **Dados já extraídos** (fontes de conhecimento) - Use primeiro quando disponíveis
+2. **Arquivos originais** - Use apenas quando:
+   - A informação não está nos dados extraídos
+   - O usuário solicita explicitamente ver o documento original
+   - Precisa de contexto visual (imagens, gráficos, layouts)
+
+## Comportamentos Padrão (WHEN IN DOUBT)
+
+- WHEN IN DOUBT sobre formato: Seja conciso, use listas e formatação clara
+- WHEN IN DOUBT sobre fonte: Prefira dados extraídos sobre arquivos brutos
+- WHEN IN DOUBT sobre referência: Sempre inclua link com filename e page_number
+- WHEN IN DOUBT sobre linguagem: Responda no mesmo idioma do usuário
+
+## Menções de Arquivos e Skills
+
+Quando o usuário menciona arquivos com `@` ou skills com `/`, eles aparecem na mensagem como tags estruturadas. Estas tags têm prioridade sobre instruções genéricas.
+
+### `<file_mention>`
+
+```xml
+<file_mention name="relatorio.pdf" url="https://{{VAULT_HOST}}/permalinks/abc123">...</file_mention>
+```
+
+- ALWAYS acesse o arquivo usando o atributo `url`
+- ALWAYS foque a sua resposta no conteúdo deste arquivo específico
+- Se múltiplos `<file_mention>` estiverem presentes, use todos os arquivos listados
+
+### `<canvas_mention>`
+
+```xml
+<canvas_mention name="meu_canvas" canvas-id="uuid-do-canvas" description="Descrição do canvas">
+O usuário quer usar este canvas do Tela.
+Variáveis obrigatórias (use EXATAMENTE estes nomes no JSON):
+- nome_variavel (text): Descrição da variável
+Invoque via Bash: bun run .claude/skills/tela/run.ts "uuid-do-canvas" com as variáveis em JSON.
+</canvas_mention>
+```
+
+- Este é um Canvas do Tela. Para invocá-lo, use a tool Bash com o comando:
+  `bun run .claude/skills/tela/run.ts "<canvas-id>" '<variables-json>'`
+- O atributo `canvas-id` contém o ID do canvas — passe como primeiro argumento
+- O conteúdo da tag lista as **variáveis obrigatórias** com seus nomes e tipos exatos
+- CRITICAL: Use EXATAMENTE os nomes de variáveis listados na tag. Nomes incorretos causam erro 400
+- Passe variáveis como JSON no segundo argumento usando os nomes exatos (ex: `'{"nome_variavel": "valor"}'`)
+- Variáveis do tipo `text` recebem texto. Variáveis do tipo `file` recebem URL do arquivo
+- O atributo `description` descreve o que o canvas faz — use como contexto
+- Se o canvas precisar de variáveis e o usuário não forneceu os valores, solicite-os antes de invocar
+
+### `<skill_mention>`
+
+```xml
+<skill_mention name="MinhaSkill" ref="skill-ref-id" description="Descrição da skill">...</skill_mention>
+```
+
+- ALWAYS invoque a skill usando o atributo `ref`
+- O atributo `description` descreve o que a skill faz — use como contexto
+- Se o usuário não forneceu parâmetros adicionais e a skill precisar deles, solicite-os antes de invocar

package/dist/runtime/server/prompts/knowledge-sources.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "## RULE 1: Fontes de Conhecimento (Skill Priority)\n\nIMPORTANT: Antes de buscar em arquivos, verifique se a informa\u00E7\u00E3o est\u00E1 dispon\u00EDvel nas fontes de conhecimento abaixo.\n\n<available_knowledge_sources>\n{{SOURCES}}\n</available_knowledge_sources>\n\n### Como Usar\n\nPara buscar informa\u00E7\u00F5es, use a skill `workstation-query` com o ID da fonte:\n\n<query_guide>\nFiltros suportados:\n- Igualdade: `{ \"campo\": \"valor\" }`\n- Compara\u00E7\u00F5es: `$gt`, `$gte`, `$lt`, `$lte`\n- Texto parcial: `$contains`\n- Lista de valores: `$in`\n- Arrays aninhados: `$elemMatch`\n\nExemplo de busca:\n```json\n{\n  \"workstationId\": \"<ID_DA_FONTE>\",\n  \"filters\": { \"status\": \"aprovado\" },\n  \"select\": [\"nome\", \"valor\", \"data\"],\n  \"limit\": 10\n}\n```\n</query_guide>\n\n### Regras de Uso\n\n- ALWAYS use os dados das fontes de conhecimento quando dispon\u00EDveis\n- ALWAYS cite a fonte original do documento ao apresentar informa\u00E7\u00F5es\n- NEVER mencione \"workstation\", \"task\" ou \"query\" para o usu\u00E1rio - fale em \"documentos\" e \"informa\u00E7\u00F5es extra\u00EDdas\"\n";
+export default _default;

package/dist/runtime/server/prompts/knowledge-sources.js

@@ -0,0 +1,37 @@
+export default `## RULE 1: Fontes de Conhecimento (Skill Priority)
+
+IMPORTANT: Antes de buscar em arquivos, verifique se a informa\xE7\xE3o est\xE1 dispon\xEDvel nas fontes de conhecimento abaixo.
+
+<available_knowledge_sources>
+{{SOURCES}}
+</available_knowledge_sources>
+
+### Como Usar
+
+Para buscar informa\xE7\xF5es, use a skill \`workstation-query\` com o ID da fonte:
+
+<query_guide>
+Filtros suportados:
+- Igualdade: \`{ "campo": "valor" }\`
+- Compara\xE7\xF5es: \`$gt\`, \`$gte\`, \`$lt\`, \`$lte\`
+- Texto parcial: \`$contains\`
+- Lista de valores: \`$in\`
+- Arrays aninhados: \`$elemMatch\`
+
+Exemplo de busca:
+\`\`\`json
+{
+  "workstationId": "<ID_DA_FONTE>",
+  "filters": { "status": "aprovado" },
+  "select": ["nome", "valor", "data"],
+  "limit": 10
+}
+\`\`\`
+</query_guide>
+
+### Regras de Uso
+
+- ALWAYS use os dados das fontes de conhecimento quando dispon\xEDveis
+- ALWAYS cite a fonte original do documento ao apresentar informa\xE7\xF5es
+- NEVER mencione "workstation", "task" ou "query" para o usu\xE1rio - fale em "documentos" e "informa\xE7\xF5es extra\xEDdas"
+`;

package/dist/runtime/server/prompts/knowledge-sources.md

@@ -0,0 +1,36 @@
+## RULE 1: Fontes de Conhecimento (Skill Priority)
+
+IMPORTANT: Antes de buscar em arquivos, verifique se a informação está disponível nas fontes de conhecimento abaixo.
+
+<available_knowledge_sources>
+{{SOURCES}}
+</available_knowledge_sources>
+
+### Como Usar
+
+Para buscar informações, use a skill `workstation-query` com o ID da fonte:
+
+<query_guide>
+Filtros suportados:
+- Igualdade: `{ "campo": "valor" }`
+- Comparações: `$gt`, `$gte`, `$lt`, `$lte`
+- Texto parcial: `$contains`
+- Lista de valores: `$in`
+- Arrays aninhados: `$elemMatch`
+
+Exemplo de busca:
+```json
+{
+  "workstationId": "<ID_DA_FONTE>",
+  "filters": { "status": "aprovado" },
+  "select": ["nome", "valor", "data"],
+  "limit": 10
+}
+```
+</query_guide>
+
+### Regras de Uso
+
+- ALWAYS use os dados das fontes de conhecimento quando disponíveis
+- ALWAYS cite a fonte original do documento ao apresentar informações
+- NEVER mencione "workstation", "task" ou "query" para o usuário - fale em "documentos" e "informações extraídas"

package/dist/runtime/server/tasks/send-daily-usage-report.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/tasks/send-daily-usage-report.js

@@ -0,0 +1,73 @@
+import { and, gte, lte, sql } from "drizzle-orm";
+import { useDb, schema } from "../db/index.js";
+import { sendSlackMessage, formatUsageReport } from "../utils/slack.js";
+import { getWorkspaceInfo, transformCostForBilling } from "../utils/billing.js";
+export default defineTask({
+  meta: {
+    name: "send-daily-usage-report",
+    description: "Sends daily usage report to Slack"
+  },
+  async run() {
+    const config = useRuntimeConfig();
+    const slackWebhookUrl = config.slackWebhookUrl;
+    if (!slackWebhookUrl) {
+      return { result: "No webhook configured" };
+    }
+    const db = useDb();
+    const now = /* @__PURE__ */ new Date();
+    const startOfToday = new Date(now);
+    startOfToday.setUTCHours(3, 0, 0, 0);
+    const endOfReport = new Date(now);
+    endOfReport.setUTCHours(23, 0, 0, 0);
+    const rawWorkspaceUsage = await db.select({
+      workspaceId: schema.conversationUsage.workspaceId,
+      totalTokens: sql`SUM(${schema.conversationUsage.totalTokens})::int`,
+      totalCost: sql`SUM(${schema.conversationUsage.totalCost}::numeric)::float`,
+      promptTokens: sql`SUM(${schema.conversationUsage.promptTokens})::int`,
+      completionTokens: sql`SUM(${schema.conversationUsage.completionTokens})::int`,
+      promptCost: sql`SUM(${schema.conversationUsage.promptCost}::numeric)::float`,
+      completionCost: sql`SUM(${schema.conversationUsage.completionCost}::numeric)::float`,
+      conversationCount: sql`COUNT(DISTINCT ${schema.conversationUsage.conversationId})::int`,
+      userCount: sql`COUNT(DISTINCT ${schema.conversationUsage.userId})::int`
+    }).from(schema.conversationUsage).where(
+      and(
+        gte(schema.conversationUsage.createdAt, startOfToday),
+        lte(schema.conversationUsage.createdAt, endOfReport)
+      )
+    ).groupBy(schema.conversationUsage.workspaceId).orderBy(sql`SUM(${schema.conversationUsage.totalCost}::numeric) DESC`);
+    if (rawWorkspaceUsage.length === 0) {
+      return { result: "No usage data" };
+    }
+    const workspaceUsage = await Promise.all(
+      rawWorkspaceUsage.map(async (usage) => {
+        const { billing, name } = await getWorkspaceInfo(usage.workspaceId);
+        const transformedCosts = transformCostForBilling({
+          promptCost: usage.promptCost,
+          completionCost: usage.completionCost,
+          totalCost: usage.totalCost,
+          promptTokens: usage.promptTokens,
+          completionTokens: usage.completionTokens
+        }, billing);
+        return {
+          workspaceId: usage.workspaceId,
+          workspaceName: name,
+          totalTokens: usage.totalTokens,
+          totalCost: transformedCosts.totalCost,
+          rawCost: usage.totalCost,
+          promptTokens: usage.promptTokens,
+          completionTokens: usage.completionTokens,
+          conversationCount: usage.conversationCount,
+          userCount: usage.userCount,
+          billingMode: billing.mode
+        };
+      })
+    );
+    const message = formatUsageReport(workspaceUsage, startOfToday);
+    const sent = await sendSlackMessage(slackWebhookUrl, message);
+    if (sent) {
+      return { result: `Sent report for ${workspaceUsage.length} workspaces` };
+    } else {
+      return { result: "Failed to send report" };
+    }
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+  "compilerOptions": {
+    "strict": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "exactOptionalPropertyTypes": false,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "skipLibCheck": true
+  },
+  "exclude": [
+    "../../../../../node_modules/*",
+    "**/node_modules/*"
+  ]
+}

package/dist/runtime/server/utils/agent-api.d.ts

@@ -0,0 +1,39 @@
+import type { H3Event } from 'h3';
+import type { AgentApiChatPayload, AgentApiSession, ContinueSessionPayload, ReasoningItem } from '#chat-runtime/types/agent';
+export declare function getAgentDataToken(event: H3Event): string;
+export declare function createChatAgentSession(token: string, payload: AgentApiChatPayload): Promise<{
+    success: true;
+    sessionId: string;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function continueSession(token: string, sessionId: string, payload: ContinueSessionPayload): Promise<{
+    success: true;
+    sessionId: string;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function getSessionStatus(token: string, sessionId: string): Promise<{
+    success: true;
+    data: AgentApiSession;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function deleteSession(token: string, sessionId: string): Promise<{
+    success: true;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function cancelSession(token: string, sessionId: string): Promise<{
+    success: true;
+    previousStatus: string;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function extractContentFromReasoning(reasoning: ReasoningItem[]): string;
+export declare function extractContentFromSession(session: AgentApiSession, turnReasoning?: ReasoningItem[]): string;

package/dist/runtime/server/utils/agent-api.js

@@ -0,0 +1,169 @@
+import { agentApiQueryResponseSchema, agentApiSessionSchema } from "#chat-runtime/types/agent";
+import { logger } from "#chat-runtime/server/utils/logger";
+const getConfig = () => useRuntimeConfig();
+export function getAgentDataToken(event) {
+  const cookieToken = event.context.auth?.token;
+  if (cookieToken) {
+    return cookieToken;
+  }
+  throw createError({
+    statusCode: 401,
+    statusMessage: "Authentication token not found"
+  });
+}
+export async function createChatAgentSession(token, payload) {
+  const { agentApiUrl } = getConfig();
+  const url = `${agentApiUrl}/v2/chat`;
+  logger.debug({ url, method: "POST" }, "Agent API createChatAgentSession request");
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": token
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    logger.warn({ status: response.status, statusText: response.statusText }, "Agent API createChatAgentSession failed");
+    return { success: false, error: `Agent API error: ${response.status} - ${response.statusText}` };
+  }
+  const json = await response.json();
+  logger.debug({ status: response.status }, "Agent API createChatAgentSession response received");
+  const parsed = agentApiQueryResponseSchema.safeParse(json);
+  if (!parsed.success) {
+    logger.warn({ issues: parsed.error.issues }, "Agent API createChatAgentSession parse error");
+    return { success: false, error: "Invalid response from Agent API" };
+  }
+  return parsed.data;
+}
+export async function continueSession(token, sessionId, payload) {
+  const { agentApiUrl } = getConfig();
+  const url = `${agentApiUrl}/v2/sessions/${sessionId}/continue`;
+  logger.debug({ url, sessionId }, "Agent API continueSession request");
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": token
+    },
+    body: JSON.stringify({ ...payload, isChat: true })
+  });
+  if (!response.ok) {
+    logger.warn({ status: response.status, statusText: response.statusText, sessionId }, "Agent API continueSession failed");
+    return { success: false, error: `Agent API error: ${response.status} - ${response.statusText}` };
+  }
+  const json = await response.json();
+  const parsed = agentApiQueryResponseSchema.safeParse(json);
+  if (!parsed.success) {
+    logger.warn({ sessionId }, "Agent API continueSession invalid response format");
+    return { success: false, error: "Invalid response from Agent API" };
+  }
+  logger.debug({ sessionId }, "Agent API continueSession response received");
+  return parsed.data;
+}
+export async function getSessionStatus(token, sessionId) {
+  const { agentApiUrl } = getConfig();
+  const url = `${agentApiUrl}/v2/sessions/${sessionId}`;
+  logger.debug({ url, sessionId }, "Agent API getSessionStatus request");
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": token
+    }
+  });
+  if (!response.ok) {
+    logger.warn({ status: response.status, statusText: response.statusText, sessionId }, "Agent API getSessionStatus failed");
+    return { success: false, error: `Agent API error: ${response.status} - ${response.statusText}` };
+  }
+  const json = await response.json();
+  const parsed = agentApiSessionSchema.safeParse(json);
+  if (!parsed.success) {
+    logger.warn({ sessionId }, "Agent API getSessionStatus parse error");
+    return { success: false, error: "Invalid session response from Agent API" };
+  }
+  logger.debug({ sessionId, status: parsed.data.status }, "Agent API getSessionStatus response received");
+  return { success: true, data: parsed.data };
+}
+export async function deleteSession(token, sessionId) {
+  const { agentApiUrl } = getConfig();
+  const url = `${agentApiUrl}/v2/sessions/${sessionId}`;
+  logger.debug({ url, sessionId }, "Agent API deleteSession request");
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": token
+    }
+  });
+  if (!response.ok) {
+    logger.warn({ status: response.status, statusText: response.statusText, sessionId }, "Agent API deleteSession failed");
+    return { success: false, error: `Agent API error: ${response.status} - ${response.statusText}` };
+  }
+  logger.debug({ sessionId }, "Agent API deleteSession succeeded");
+  return { success: true };
+}
+export async function cancelSession(token, sessionId) {
+  const { agentApiUrl } = getConfig();
+  const url = `${agentApiUrl}/v2/sessions/${sessionId}/cancel`;
+  logger.debug({ url, sessionId }, "Agent API cancelSession request");
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": token
+    }
+  });
+  if (!response.ok) {
+    logger.warn({ status: response.status, statusText: response.statusText, sessionId }, "Agent API cancelSession failed");
+    return { success: false, error: `Agent API error: ${response.status} - ${response.statusText}` };
+  }
+  const json = await response.json();
+  if (!json.success) {
+    logger.warn({ sessionId }, "Agent API cancelSession returned failure");
+    return { success: false, error: json.error ?? "Failed to cancel session" };
+  }
+  logger.debug({ sessionId, previousStatus: json.previousStatus }, "Agent API cancelSession succeeded");
+  return { success: true, previousStatus: json.previousStatus ?? "unknown" };
+}
+export function extractContentFromReasoning(reasoning) {
+  for (let i = reasoning.length - 1; i >= 0; i--) {
+    const item = reasoning[i];
+    if (item && typeof item === "object") {
+      const itemObj = item;
+      if (itemObj.type === "assistant" && itemObj.message) {
+        const message = itemObj.message;
+        if (Array.isArray(message.content)) {
+          for (const part of message.content) {
+            if (part && typeof part === "object") {
+              const partObj = part;
+              if (partObj.type === "text" && typeof partObj.text === "string") {
+                return partObj.text;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return "";
+}
+export function extractContentFromSession(session, turnReasoning) {
+  if (turnReasoning !== void 0) {
+    return extractContentFromReasoning(turnReasoning);
+  }
+  if (session.result?.content) {
+    return session.result.content;
+  }
+  if (session.result?.structuredContent) {
+    const content = session.result.structuredContent.content;
+    if (typeof content === "string") {
+      return content;
+    }
+    return JSON.stringify(session.result.structuredContent);
+  }
+  if (session.reasoning && Array.isArray(session.reasoning)) {
+    return extractContentFromReasoning(session.reasoning);
+  }
+  return "";
+}

package/dist/runtime/server/utils/auth-api.d.ts

@@ -0,0 +1 @@
+export declare function authApiFetch<T>(path: string, options?: RequestInit): Promise<T>;

package/dist/runtime/server/utils/auth-api.js

@@ -0,0 +1,25 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+export async function authApiFetch(path, options) {
+  const config = useRuntimeConfig();
+  if (!config.authApiSecret) {
+    throw createError({ statusCode: 500, statusMessage: "AUTH_API_SECRET not configured" });
+  }
+  const start = performance.now();
+  const response = await fetch(`${config.authApiUrl}${path}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${config.authApiSecret}`,
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+  if (!response.ok) {
+    logger.error({ status: response.status, statusText: response.statusText, path }, "Auth API request failed");
+    throw createError({
+      statusCode: response.status,
+      statusMessage: `Auth API error: ${response.statusText}`
+    });
+  }
+  logger.debug({ path, durationMs: Math.round(performance.now() - start) }, "Auth API request succeeded");
+  return response.json();
+}

package/dist/runtime/server/utils/auth.d.ts

@@ -0,0 +1,17 @@
+import type { H3Event } from 'h3';
+export type SessionUser = {
+    id: string;
+    name: string;
+    email: string;
+    image: string;
+    role: string;
+};
+export type SessionWorkspace = {
+    id: string;
+    title: string;
+};
+export type AppSession = {
+    user: SessionUser;
+    workspace: SessionWorkspace;
+};
+export declare function requireUser(event: H3Event): AppSession;

package/dist/runtime/server/utils/auth.js

@@ -0,0 +1,28 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+export function requireUser(event) {
+  const { user, workspace } = event.context.auth ?? {};
+  if (!user?.id) {
+    logger.warn("Auth required but no user in context");
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized"
+    });
+  }
+  if (!workspace?.id) {
+    logger.warn("Auth required but no workspace in context");
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized"
+    });
+  }
+  return {
+    user: {
+      id: user.id,
+      name: user.name ?? "",
+      email: user.email ?? "",
+      image: user.image ?? "",
+      role: user.role ?? "member"
+    },
+    workspace
+  };
+}

package/dist/runtime/server/utils/billing.d.ts

@@ -0,0 +1,37 @@
+export type BillingConfig = {
+    mode: 'plan';
+    cvp: number;
+} | {
+    mode: 'credits';
+};
+export type WorkspaceInfo = {
+    billing: BillingConfig;
+    name: string;
+};
+/**
+ * Fetch workspace info including billing settings from the auth API
+ */
+export declare function getWorkspaceInfo(workspaceId: string): Promise<WorkspaceInfo>;
+/**
+ * Fetch workspace billing settings from the auth API
+ */
+export declare function getWorkspaceBilling(workspaceId: string): Promise<BillingConfig>;
+export type UsageData = {
+    promptCost: number;
+    completionCost: number;
+    totalCost: number;
+    promptTokens: number;
+    completionTokens: number;
+};
+export type TransformedCosts = {
+    promptCost: number;
+    completionCost: number;
+    totalCost: number;
+};
+/**
+ * Transform raw costs based on workspace billing mode
+ *
+ * For 'plan' mode: costs are multiplied by cvp
+ * For 'credits' mode: calculates credits based on costs and token amounts
+ */
+export declare function transformCostForBilling(usage: UsageData, billing: BillingConfig): TransformedCosts;

package/dist/runtime/server/utils/billing.js

@@ -0,0 +1,68 @@
+import { authApiFetch } from "#chat-runtime/server/utils/auth-api";
+import { logger } from "#chat-runtime/server/utils/logger";
+const DEFAULT_CVP = 1.5;
+function calculateCreditsUsed(inputCost, outputCost, inputAmount, outputAmount) {
+  const baseCost = inputCost + inputAmount * 306e-8 + outputCost + outputAmount * 378e-6 + 0.036;
+  const costCap = 10 * (inputCost + outputCost);
+  const alternativeCost = (inputAmount * (302e-8 + 306e-8) + outputAmount * (1514e-8 + 378e-6) + 0.036) / 2;
+  const credits = Math.ceil(
+    Math.max(
+      Math.min(baseCost, costCap),
+      alternativeCost
+    ) / 0.01
+  );
+  return credits;
+}
+export async function getWorkspaceInfo(workspaceId) {
+  try {
+    const response = await authApiFetch(`/organizations/${workspaceId}`);
+    const workspace = response.data;
+    const settings = workspace?.settings;
+    const billingSettings = settings?.billing;
+    const billing = billingSettings?.mode === "credits" ? { mode: "credits" } : { mode: "plan", cvp: billingSettings?.cvp ?? DEFAULT_CVP };
+    return {
+      billing,
+      name: workspace?.title ?? workspaceId
+    };
+  } catch (error) {
+    logger.error(error, "Failed to fetch workspace info");
+    return {
+      billing: { mode: "plan", cvp: DEFAULT_CVP },
+      name: workspaceId
+    };
+  }
+}
+export async function getWorkspaceBilling(workspaceId) {
+  const info = await getWorkspaceInfo(workspaceId);
+  return info.billing;
+}
+export function transformCostForBilling(usage, billing) {
+  if (billing.mode === "plan") {
+    return {
+      promptCost: usage.promptCost * billing.cvp,
+      completionCost: usage.completionCost * billing.cvp,
+      totalCost: usage.totalCost * billing.cvp
+    };
+  }
+  const totalCredits = calculateCreditsUsed(
+    usage.promptCost,
+    usage.completionCost,
+    usage.promptTokens,
+    usage.completionTokens
+  );
+  const totalRawCost = usage.promptCost + usage.completionCost;
+  if (totalRawCost === 0) {
+    return {
+      promptCost: 0,
+      completionCost: 0,
+      totalCost: totalCredits
+    };
+  }
+  const promptRatio = usage.promptCost / totalRawCost;
+  const completionRatio = usage.completionCost / totalRawCost;
+  return {
+    promptCost: totalCredits * promptRatio,
+    completionCost: totalCredits * completionRatio,
+    totalCost: totalCredits
+  };
+}