agor-live 0.3.7

package/dist/core/types/index.d.ts

@@ -0,0 +1,214 @@
+export { PermissionDecision, PermissionRequest } from '../permissions/index.js';
+export { a as AgenticTool, A as AgenticToolName } from '../agentic-tool-B_gFNpk5.js';
+export { f as Board, b as BoardEntityObject, e as BoardObject, B as BoardObjectType, C as ClaudeCodePermissionMode, a as CodexPermissionMode, r as CreateMCPServerInput, J as JSONSchema, o as MCPCapabilities, t as MCPConfigFile, m as MCPPrompt, l as MCPResource, i as MCPScope, p as MCPServer, q as MCPServerFilters, M as MCPServerID, u as MCPServersConfig, j as MCPSource, s as MCPTestResult, k as MCPTool, h as MCPTransport, P as PermissionMode, n as PromptArgument, x as Session, S as SessionMCPServer, v as SessionStatus, g as TeamID, T as TextBoardObject, U as UpdateMCPServerInput, d as ZoneBoardObject, c as ZoneTrigger, Z as ZoneTriggerBehavior, w as getDefaultPermissionMode } from '../session-wAzjHatv.js';
+export { B as BoardComment, b as BoardCommentCreate, c as BoardCommentPatch, a as CommentAttachmentType, C as CommentReaction, R as ReactionSummary, g as getCommentAttachmentType, f as groupReactions, d as isReply, e as isResolvable, i as isThreadRoot } from '../board-comment-gC_-twPx.js';
+export { b as ContextFileDetail, a as ContextFileListItem, C as ContextFilePath, d as Report, R as ReportPath, c as ReportTemplate, e as Task, T as TaskStatus } from '../task-DuIfiUbW.js';
+export { a as AuthenticatedParams, A as AuthenticatedUser, b as AuthenticationResult, B as BaseService, C as CreateHookContext, H as HookContext, Q as QueryParams, S as ServiceWithEvents } from '../feathers-BzHEPnpl.js';
+import { B as BoardID } from '../id-DMqyogFB.js';
+export { A as AgenticToolID, C as CommentID, I as IDPrefix, M as MessageID, a as SessionID, S as ShortID, T as TaskID, U as UUID, b as UserID, W as WorktreeID } from '../id-DMqyogFB.js';
+export { C as ContentBlock, d as Message, e as MessageCreate, M as MessageRole, a as MessageType, c as PermissionRequestContent, P as PermissionScope, b as PermissionStatus, T as ToolUse } from '../message-DvBzHu7V.js';
+import { a as User } from '../user-BmL3kFol.js';
+export { C as CreateUserInput, b as UpdateUserInput, U as UserRole } from '../user-BmL3kFol.js';
+export { a as Repo, e as RepoEnvironmentConfig, R as RepoSlug, c as Worktree, b as WorktreeConfig, d as WorktreeEnvironmentInstance, W as WorktreeName } from '../repo-CnvJ0B6-.js';
+export { Id, NullableId, Paginated, Params, Service, ServiceMethods } from '@feathersjs/feathers';
+
+/**
+ * Cursor position event (client → server)
+ */
+interface CursorMoveEvent {
+    boardId: BoardID;
+    x: number;
+    y: number;
+    timestamp: number;
+}
+/**
+ * Cursor position broadcast (server → clients)
+ */
+interface CursorMovedEvent {
+    userId: string;
+    boardId: BoardID;
+    x: number;
+    y: number;
+    timestamp: number;
+}
+/**
+ * Cursor leave event (user navigates away from board)
+ */
+interface CursorLeaveEvent {
+    boardId: BoardID;
+}
+/**
+ * Remote cursor state for rendering
+ */
+interface RemoteCursor {
+    userId: string;
+    user: User;
+    x: number;
+    y: number;
+    timestamp: number;
+}
+/**
+ * Active user for facepile display
+ */
+interface ActiveUser {
+    user: User;
+    lastSeen: number;
+    cursor?: {
+        x: number;
+        y: number;
+    };
+}
+
+type SessionViewMode = 'collapsed' | 'expanded' | 'drawer';
+
+/**
+ * Generic Utility Types
+ *
+ * Reusable type utilities for common patterns across Agor.
+ */
+/**
+ * Input type for creating an entity
+ *
+ * Omits auto-generated fields (timestamps) and optionally allows ID for bulk operations.
+ *
+ * @template T - Entity type
+ * @template OmitKeys - Additional keys to omit (e.g., 'user_id' if auto-assigned)
+ *
+ * @example
+ * ```ts
+ * type CreateSessionInput = CreateInput<Session, 'session_id'>;
+ * // Omits: session_id, created_at, last_updated
+ * ```
+ */
+type CreateInput<T, OmitKeys extends keyof T = never> = Omit<T, 'created_at' | 'last_updated' | 'updated_at' | OmitKeys> & {
+    [K in Extract<keyof T, `${string}_id`>]?: T[K];
+};
+/**
+ * Input type for updating an entity
+ *
+ * All fields optional except auto-generated ones.
+ *
+ * @template T - Entity type
+ * @template OmitKeys - Additional keys to omit (e.g., immutable fields)
+ *
+ * @example
+ * ```ts
+ * type UpdateSessionInput = UpdateInput<Session, 'session_id' | 'created_at'>;
+ * // All fields optional except session_id and created_at
+ * ```
+ */
+type UpdateInput<T, OmitKeys extends keyof T = never> = Partial<Omit<T, 'created_at' | 'last_updated' | 'updated_at' | OmitKeys>>;
+/**
+ * Paginated result wrapper
+ *
+ * Standard pagination format used by FeathersJS.
+ *
+ * @template T - Entity type
+ *
+ * @example
+ * ```ts
+ * const result: PaginatedResult<Session> = {
+ *   total: 100,
+ *   limit: 10,
+ *   skip: 0,
+ *   data: sessions
+ * };
+ * ```
+ */
+interface PaginatedResult<T> {
+    /** Total number of matching entities */
+    total: number;
+    /** Maximum results per page */
+    limit: number;
+    /** Number of results skipped */
+    skip: number;
+    /** Array of entities for this page */
+    data: T[];
+}
+/**
+ * Flatten nested object for database storage
+ *
+ * Converts nested objects to dot notation for indexed columns.
+ *
+ * @template T - Object type
+ *
+ * @example
+ * ```ts
+ * type GitState = { ref: string; base_sha: string; };
+ * type Flat = FlattenObject<GitState>;
+ * // Result: { 'git_state.ref': string; 'git_state.base_sha': string; }
+ * ```
+ */
+type FlattenObject<T extends Record<string, unknown>> = {
+    [K in keyof T as T[K] extends Record<string, unknown> ? `${string & K}.${string & keyof T[K]}` : K]: T[K] extends Record<string, unknown> ? T[K][keyof T[K]] : T[K];
+};
+/**
+ * Check if value is non-null and non-undefined
+ *
+ * Useful for filtering arrays and narrowing types.
+ *
+ * @param value - Value to check
+ * @returns True if value is defined (not null or undefined)
+ *
+ * @example
+ * ```ts
+ * const ids = [id1, undefined, id2, null].filter(isDefined);
+ * // Result: [id1, id2] with type string[]
+ * ```
+ */
+declare function isDefined<T>(value: T | null | undefined): value is T;
+/**
+ * Check if value is a non-empty string
+ *
+ * @param value - Value to check
+ * @returns True if value is a non-empty string
+ *
+ * @example
+ * ```ts
+ * const names = ['', 'Alice', '  ', 'Bob'].filter(isNonEmptyString);
+ * // Result: ['Alice', 'Bob']
+ * ```
+ */
+declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Make specific keys required
+ *
+ * @template T - Object type
+ * @template K - Keys to make required
+ *
+ * @example
+ * ```ts
+ * type SessionWithTitle = RequireKeys<Session, 'title'>;
+ * // Session with title required instead of optional
+ * ```
+ */
+type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
+/**
+ * Make specific keys optional
+ *
+ * @template T - Object type
+ * @template K - Keys to make optional
+ *
+ * @example
+ * ```ts
+ * type PartialSession = PartialKeys<Session, 'description' | 'title'>;
+ * // Session with description and title optional
+ * ```
+ */
+type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Make all properties and nested properties readonly
+ *
+ * @template T - Object type
+ *
+ * @example
+ * ```ts
+ * type ImmutableSession = DeepReadonly<Session>;
+ * // All fields and nested fields are readonly
+ * ```
+ */
+type DeepReadonly<T> = {
+    readonly [K in keyof T]: T[K] extends Record<string, unknown> ? DeepReadonly<T[K]> : T[K];
+};
+
+export { type ActiveUser, BoardID, type CreateInput, type CursorLeaveEvent, type CursorMoveEvent, type CursorMovedEvent, type DeepReadonly, type FlattenObject, type PaginatedResult, type PartialKeys, type RemoteCursor, type RequireKeys, type SessionViewMode, type UpdateInput, User, isDefined, isNonEmptyString };

package/dist/core/types/index.js

@@ -0,0 +1,112 @@
+// src/types/board-comment.ts
+var CommentAttachmentType = {
+  MESSAGE: "message",
+  TASK: "task",
+  SESSION_SPATIAL: "session-spatial",
+  SESSION: "session",
+  WORKTREE: "worktree",
+  BOARD_SPATIAL: "board-spatial",
+  BOARD: "board"
+};
+function getCommentAttachmentType(comment) {
+  if (comment.message_id) return CommentAttachmentType.MESSAGE;
+  if (comment.task_id) return CommentAttachmentType.TASK;
+  if (comment.session_id && comment.position?.relative)
+    return CommentAttachmentType.SESSION_SPATIAL;
+  if (comment.session_id) return CommentAttachmentType.SESSION;
+  if (comment.worktree_id) return CommentAttachmentType.WORKTREE;
+  if (comment.position?.absolute) return CommentAttachmentType.BOARD_SPATIAL;
+  return CommentAttachmentType.BOARD;
+}
+function isThreadRoot(comment) {
+  return !comment.parent_comment_id;
+}
+function isReply(comment) {
+  return !!comment.parent_comment_id;
+}
+function isResolvable(comment) {
+  return isThreadRoot(comment);
+}
+function groupReactions(reactions) {
+  const grouped = {};
+  for (const { emoji, user_id } of reactions) {
+    if (!grouped[emoji]) {
+      grouped[emoji] = [];
+    }
+    grouped[emoji].push(user_id);
+  }
+  return grouped;
+}
+
+// src/types/message.ts
+var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
+  MessageRole2["USER"] = "user";
+  MessageRole2["ASSISTANT"] = "assistant";
+  MessageRole2["SYSTEM"] = "system";
+  return MessageRole2;
+})(MessageRole || {});
+var PermissionScope = /* @__PURE__ */ ((PermissionScope2) => {
+  PermissionScope2["ONCE"] = "once";
+  PermissionScope2["SESSION"] = "session";
+  PermissionScope2["PROJECT"] = "project";
+  return PermissionScope2;
+})(PermissionScope || {});
+var PermissionStatus = /* @__PURE__ */ ((PermissionStatus2) => {
+  PermissionStatus2["PENDING"] = "pending";
+  PermissionStatus2["APPROVED"] = "approved";
+  PermissionStatus2["DENIED"] = "denied";
+  return PermissionStatus2;
+})(PermissionStatus || {});
+
+// src/types/session.ts
+var SessionStatus = {
+  IDLE: "idle",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed"
+};
+function getDefaultPermissionMode(agenticTool) {
+  switch (agenticTool) {
+    case "codex":
+      return "auto";
+    default:
+      return "acceptEdits";
+  }
+}
+
+// src/types/task.ts
+var TaskStatus = {
+  CREATED: "created",
+  RUNNING: "running",
+  STOPPING: "stopping",
+  // Stop requested, waiting for SDK to halt
+  AWAITING_PERMISSION: "awaiting_permission",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  STOPPED: "stopped"
+  // User-requested stop (distinct from failed)
+};
+
+// src/types/utils.ts
+function isDefined(value) {
+  return value !== null && value !== void 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+export {
+  CommentAttachmentType,
+  MessageRole,
+  PermissionScope,
+  PermissionStatus,
+  SessionStatus,
+  TaskStatus,
+  getCommentAttachmentType,
+  getDefaultPermissionMode,
+  groupReactions,
+  isDefined,
+  isNonEmptyString,
+  isReply,
+  isResolvable,
+  isThreadRoot
+};

package/dist/core/user-BmL3kFol.d.ts

@@ -0,0 +1,50 @@
+import { b as UserID } from './id-DMqyogFB.js';
+
+/**
+ * User role types
+ * - owner: Full system access, can manage all users and settings
+ * - admin: Can manage most resources, cannot modify owner
+ * - member: Standard user access, can create and manage own sessions
+ * - viewer: Read-only access
+ */
+type UserRole = 'owner' | 'admin' | 'member' | 'viewer';
+/**
+ * User type - Authentication and authorization
+ */
+interface User {
+    user_id: UserID;
+    email: string;
+    name?: string;
+    emoji?: string;
+    role: UserRole;
+    avatar?: string;
+    preferences?: Record<string, unknown>;
+    onboarding_completed: boolean;
+    created_at: Date;
+    updated_at?: Date;
+}
+/**
+ * Create user input (password required, not stored in User type)
+ */
+interface CreateUserInput {
+    email: string;
+    password: string;
+    name?: string;
+    emoji?: string;
+    role?: UserRole;
+}
+/**
+ * Update user input
+ */
+interface UpdateUserInput {
+    email?: string;
+    password?: string;
+    name?: string;
+    emoji?: string;
+    role?: UserRole;
+    avatar?: string;
+    preferences?: Record<string, unknown>;
+    onboarding_completed?: boolean;
+}
+
+export type { CreateUserInput as C, UserRole as U, User as a, UpdateUserInput as b };

package/dist/core/user-eUuKj7yM.d.cts

@@ -0,0 +1,50 @@
+import { b as UserID } from './id-DMqyogFB.cjs';
+
+/**
+ * User role types
+ * - owner: Full system access, can manage all users and settings
+ * - admin: Can manage most resources, cannot modify owner
+ * - member: Standard user access, can create and manage own sessions
+ * - viewer: Read-only access
+ */
+type UserRole = 'owner' | 'admin' | 'member' | 'viewer';
+/**
+ * User type - Authentication and authorization
+ */
+interface User {
+    user_id: UserID;
+    email: string;
+    name?: string;
+    emoji?: string;
+    role: UserRole;
+    avatar?: string;
+    preferences?: Record<string, unknown>;
+    onboarding_completed: boolean;
+    created_at: Date;
+    updated_at?: Date;
+}
+/**
+ * Create user input (password required, not stored in User type)
+ */
+interface CreateUserInput {
+    email: string;
+    password: string;
+    name?: string;
+    emoji?: string;
+    role?: UserRole;
+}
+/**
+ * Update user input
+ */
+interface UpdateUserInput {
+    email?: string;
+    password?: string;
+    name?: string;
+    emoji?: string;
+    role?: UserRole;
+    avatar?: string;
+    preferences?: Record<string, unknown>;
+    onboarding_completed?: boolean;
+}
+
+export type { CreateUserInput as C, UserRole as U, User as a, UpdateUserInput as b };

package/dist/core/utils/pricing.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/pricing.ts
+var pricing_exports = {};
+__export(pricing_exports, {
+  calculateTokenCost: () => calculateTokenCost,
+  formatCost: () => formatCost,
+  formatTokenCount: () => formatTokenCount
+});
+module.exports = __toCommonJS(pricing_exports);
+var PRICING = {
+  "claude-code": {
+    // Claude Sonnet 4.5 pricing
+    input: 3,
+    // $3 per 1M input tokens
+    output: 15,
+    // $15 per 1M output tokens
+    cache_read: 0.3,
+    // $0.30 per 1M cache read tokens
+    cache_creation: 3.75
+    // $3.75 per 1M cache creation tokens
+  },
+  cursor: {
+    // Cursor uses Claude Sonnet 4.5 (same pricing as claude-code)
+    input: 3,
+    // $3 per 1M input tokens
+    output: 15,
+    // $15 per 1M output tokens
+    cache_read: 0.3,
+    // $0.30 per 1M cache read tokens
+    cache_creation: 3.75
+    // $3.75 per 1M cache creation tokens
+  },
+  codex: {
+    // OpenAI GPT-4 Turbo pricing (estimate for Codex)
+    input: 10,
+    // $10 per 1M input tokens
+    output: 30
+    // $30 per 1M output tokens
+  },
+  gemini: {
+    // Gemini 2.0 Flash pricing
+    input: 0.075,
+    // $0.075 per 1M input tokens (much cheaper!)
+    output: 0.3
+    // $0.30 per 1M output tokens
+  }
+};
+function calculateTokenCost(usage, agent) {
+  const pricing = PRICING[agent];
+  if (!pricing) {
+    console.warn(`No pricing data for agent: ${agent}`);
+    return 0;
+  }
+  let cost = 0;
+  if (usage.input_tokens) {
+    cost += usage.input_tokens / 1e6 * pricing.input;
+  }
+  if (usage.output_tokens) {
+    cost += usage.output_tokens / 1e6 * pricing.output;
+  }
+  if (usage.cache_read_tokens && pricing.cache_read) {
+    cost += usage.cache_read_tokens / 1e6 * pricing.cache_read;
+  }
+  if (usage.cache_creation_tokens && pricing.cache_creation) {
+    cost += usage.cache_creation_tokens / 1e6 * pricing.cache_creation;
+  }
+  return cost;
+}
+function formatCost(costUsd) {
+  if (costUsd === 0) return "$0.00";
+  if (costUsd < 0.01) {
+    return `$${costUsd.toFixed(4)}`;
+  }
+  return `$${costUsd.toFixed(2)}`;
+}
+function formatTokenCount(tokens) {
+  return tokens.toLocaleString();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateTokenCost,
+  formatCost,
+  formatTokenCount
+});

package/dist/core/utils/pricing.d.cts

@@ -0,0 +1,43 @@
+import { A as AgenticToolName } from '../agentic-tool-DsyX8diw.cjs';
+import '../id-DMqyogFB.cjs';
+
+/**
+ * Token pricing and cost calculation utilities
+ *
+ * Pricing as of January 2025 (subject to change)
+ */
+
+/**
+ * Token usage data from LLM API responses
+ */
+interface TokenUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    cache_read_tokens?: number;
+    cache_creation_tokens?: number;
+}
+/**
+ * Calculate estimated cost in USD for a given token usage
+ *
+ * @param usage - Token usage data from LLM API response
+ * @param agent - Agentic tool name (determines pricing)
+ * @returns Estimated cost in USD (e.g., 0.0234)
+ */
+declare function calculateTokenCost(usage: TokenUsage, agent: AgenticToolName): number;
+/**
+ * Format cost as USD string with appropriate precision
+ *
+ * @param costUsd - Cost in USD (e.g., 0.0234)
+ * @returns Formatted string (e.g., "$0.023")
+ */
+declare function formatCost(costUsd: number): string;
+/**
+ * Format token count with thousands separators
+ *
+ * @param tokens - Token count (e.g., 12345)
+ * @returns Formatted string (e.g., "12,345")
+ */
+declare function formatTokenCount(tokens: number): string;
+
+export { type TokenUsage, calculateTokenCost, formatCost, formatTokenCount };

package/dist/core/utils/pricing.d.ts

@@ -0,0 +1,43 @@
+import { A as AgenticToolName } from '../agentic-tool-B_gFNpk5.js';
+import '../id-DMqyogFB.js';
+
+/**
+ * Token pricing and cost calculation utilities
+ *
+ * Pricing as of January 2025 (subject to change)
+ */
+
+/**
+ * Token usage data from LLM API responses
+ */
+interface TokenUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    cache_read_tokens?: number;
+    cache_creation_tokens?: number;
+}
+/**
+ * Calculate estimated cost in USD for a given token usage
+ *
+ * @param usage - Token usage data from LLM API response
+ * @param agent - Agentic tool name (determines pricing)
+ * @returns Estimated cost in USD (e.g., 0.0234)
+ */
+declare function calculateTokenCost(usage: TokenUsage, agent: AgenticToolName): number;
+/**
+ * Format cost as USD string with appropriate precision
+ *
+ * @param costUsd - Cost in USD (e.g., 0.0234)
+ * @returns Formatted string (e.g., "$0.023")
+ */
+declare function formatCost(costUsd: number): string;
+/**
+ * Format token count with thousands separators
+ *
+ * @param tokens - Token count (e.g., 12345)
+ * @returns Formatted string (e.g., "12,345")
+ */
+declare function formatTokenCount(tokens: number): string;
+
+export { type TokenUsage, calculateTokenCost, formatCost, formatTokenCount };

package/dist/core/utils/pricing.js

@@ -0,0 +1,75 @@
+// src/utils/pricing.ts
+var PRICING = {
+  "claude-code": {
+    // Claude Sonnet 4.5 pricing
+    input: 3,
+    // $3 per 1M input tokens
+    output: 15,
+    // $15 per 1M output tokens
+    cache_read: 0.3,
+    // $0.30 per 1M cache read tokens
+    cache_creation: 3.75
+    // $3.75 per 1M cache creation tokens
+  },
+  cursor: {
+    // Cursor uses Claude Sonnet 4.5 (same pricing as claude-code)
+    input: 3,
+    // $3 per 1M input tokens
+    output: 15,
+    // $15 per 1M output tokens
+    cache_read: 0.3,
+    // $0.30 per 1M cache read tokens
+    cache_creation: 3.75
+    // $3.75 per 1M cache creation tokens
+  },
+  codex: {
+    // OpenAI GPT-4 Turbo pricing (estimate for Codex)
+    input: 10,
+    // $10 per 1M input tokens
+    output: 30
+    // $30 per 1M output tokens
+  },
+  gemini: {
+    // Gemini 2.0 Flash pricing
+    input: 0.075,
+    // $0.075 per 1M input tokens (much cheaper!)
+    output: 0.3
+    // $0.30 per 1M output tokens
+  }
+};
+function calculateTokenCost(usage, agent) {
+  const pricing = PRICING[agent];
+  if (!pricing) {
+    console.warn(`No pricing data for agent: ${agent}`);
+    return 0;
+  }
+  let cost = 0;
+  if (usage.input_tokens) {
+    cost += usage.input_tokens / 1e6 * pricing.input;
+  }
+  if (usage.output_tokens) {
+    cost += usage.output_tokens / 1e6 * pricing.output;
+  }
+  if (usage.cache_read_tokens && pricing.cache_read) {
+    cost += usage.cache_read_tokens / 1e6 * pricing.cache_read;
+  }
+  if (usage.cache_creation_tokens && pricing.cache_creation) {
+    cost += usage.cache_creation_tokens / 1e6 * pricing.cache_creation;
+  }
+  return cost;
+}
+function formatCost(costUsd) {
+  if (costUsd === 0) return "$0.00";
+  if (costUsd < 0.01) {
+    return `$${costUsd.toFixed(4)}`;
+  }
+  return `$${costUsd.toFixed(2)}`;
+}
+function formatTokenCount(tokens) {
+  return tokens.toLocaleString();
+}
+export {
+  calculateTokenCost,
+  formatCost,
+  formatTokenCount
+};