ak-gemini 1.0.11 → 1.0.12

package/README.md

@@ -11,6 +11,8 @@ Use this to power LLM-driven data pipelines, JSON mapping, or any automated AI t
 * **Declarative Few-shot Examples:** Seed transformations using example mappings, with support for custom keys (`PROMPT`, `ANSWER`, `CONTEXT`, or your own)
 * **Automatic Validation & Repair:** Validate outputs with your own async function; auto-repair failed payloads with LLM feedback loop (exponential backoff, fully configurable)
 * **Token Counting & Safety:** Preview the *exact* Gemini token consumption for any operation—including all examples, instructions, and your input—before sending, so you can avoid window errors and manage costs.
+* **Conversation Management:** Clear conversation history while preserving examples, or send stateless one-off messages that don't affect history
+* **Response Metadata:** Access actual model version and token counts from API responses for billing verification and debugging
 * **Strong TypeScript/JSDoc Typings:** All public APIs fully typed (see `/types`)
 * **Minimal API Surface:** Dead simple, no ceremony—init, seed, transform, validate.
 * **Robust Logging:** Pluggable logger for all steps, easy debugging
@@ -106,6 +108,25 @@ console.log(validPayload);
 
 ---
 
+### 5. **Conversation Management**
+
+Manage chat history to control costs and isolate requests:
+
+```js
+// Clear conversation history while preserving seeded examples
+await transformer.clearConversation();
+
+// Send a stateless message that doesn't affect chat history
+const result = await transformer.message({ query: "one-off question" }, { stateless: true });
+
+// Check actual model and token usage from last API call
+console.log(transformer.lastResponseMetadata);
+// → { modelVersion: 'gemini-2.5-flash-001', requestedModel: 'gemini-2.5-flash',
+//    promptTokens: 150, responseTokens: 42, totalTokens: 192, timestamp: 1703... }
+```
+
+---
+
 ## API
 
 ### Constructor
@@ -142,10 +163,14 @@ Initializes Gemini chat session (idempotent).
 Seeds the model with example transformations (uses keys from constructor).
 You can omit `examples` to use the `examplesFile` (if provided).
 
-#### `await transformer.message(sourcePayload)`
+#### `await transformer.message(sourcePayload, options?)`
 
 Transforms input JSON to output JSON using the seeded examples and system instructions. Throws if estimated token window would be exceeded.
 
+**Options:**
+- `stateless: true` — Send a one-off message without affecting chat history (uses `generateContent` instead of chat)
+- `labels: {}` — Per-message billing labels
+
 #### `await transformer.estimateTokenUsage(sourcePayload)`
 
 Returns `{ totalTokens, breakdown }` for the *full request* that would be sent to Gemini (system instructions + all examples + your sourcePayload as the new prompt).
@@ -168,6 +193,31 @@ Resets the Gemini chat session, clearing all history/examples.
 
 Returns the current chat history (for debugging).
 
+#### `await transformer.clearConversation()`
+
+Clears conversation history while preserving seeded examples. Useful for starting fresh user sessions without re-seeding.
+
+---
+
+### Properties
+
+#### `transformer.lastResponseMetadata`
+
+After each API call, contains metadata from the response:
+
+```js
+{
+  modelVersion: string | null,  // Actual model version that responded (e.g., 'gemini-2.5-flash-001')
+  requestedModel: string,       // Model you requested (e.g., 'gemini-2.5-flash')
+  promptTokens: number,         // Tokens in the prompt
+  responseTokens: number,       // Tokens in the response
+  totalTokens: number,          // Total tokens used
+  timestamp: number             // When response was received
+}
+```
+
+Useful for verifying billing, debugging model behavior, and tracking token usage.
+
 ---
 
 ## Examples

package/index.cjs

@@ -82,7 +82,7 @@ var DEFAULT_THINKING_CONFIG = {
   thinkingBudget: 0,
   thinkingLevel: import_genai.ThinkingLevel.MINIMAL
 };
-var DEFAULT_MAX_OUTPUT_TOKENS = 1e5;
+var DEFAULT_MAX_OUTPUT_TOKENS = 5e4;
 var THINKING_SUPPORTED_MODELS = [
   /^gemini-3-flash(-preview)?$/,
   /^gemini-3-pro(-preview|-image-preview)?$/,
@@ -120,6 +120,8 @@ var AITransformer = class {
     this.onlyJSON = true;
     this.asyncValidator = null;
     this.logLevel = "info";
+    this.lastResponseMetadata = null;
+    this.exampleCount = 0;
     AITransformFactory.call(this, options);
     this.init = initChat.bind(this);
     this.seed = seedWithExamples.bind(this);
@@ -136,6 +138,7 @@ var AITransformer = class {
     this.estimateTokenUsage = estimateTokenUsage.bind(this);
     this.updateSystemInstructions = updateSystemInstructions.bind(this);
     this.estimateCost = estimateCost.bind(this);
+    this.clearConversation = clearConversation.bind(this);
   }
 };
 var index_default = AITransformer;
@@ -366,6 +369,7 @@ ${contextText}
     },
     history: [...currentHistory, ...historyToAdd]
   });
+  this.exampleCount = currentHistory.length + historyToAdd.length;
   const newHistory = this.chat.getHistory();
   logger_default.debug(`Created new chat session with ${newHistory.length} examples.`);
   return newHistory;
@@ -383,6 +387,23 @@ async function rawMessage(sourcePayload, messageOptions = {}) {
       sendParams.config = { labels: mergedLabels };
     }
     const result = await this.chat.sendMessage(sendParams);
+    this.lastResponseMetadata = {
+      modelVersion: result.modelVersion || null,
+      requestedModel: this.modelName,
+      promptTokens: result.usageMetadata?.promptTokenCount || 0,
+      responseTokens: result.usageMetadata?.candidatesTokenCount || 0,
+      totalTokens: result.usageMetadata?.totalTokenCount || 0,
+      timestamp: Date.now()
+    };
+    if (result.usageMetadata && logger_default.level !== "silent") {
+      logger_default.debug(`API response metadata:`, {
+        modelVersion: result.modelVersion || "not-provided",
+        requestedModel: this.modelName,
+        promptTokens: result.usageMetadata.promptTokenCount,
+        responseTokens: result.usageMetadata.candidatesTokenCount,
+        totalTokens: result.usageMetadata.totalTokenCount
+      });
+    }
     const modelResponse = result.text;
     const extractedJSON = extractJSON(modelResponse);
     if (extractedJSON?.data) {
@@ -400,6 +421,9 @@ async function prepareAndValidateMessage(sourcePayload, options = {}, validatorF
   if (!this.chat) {
     throw new Error("Chat session not initialized. Please call init() first.");
   }
+  if (options.stateless) {
+    return await statelessMessage.call(this, sourcePayload, options, validatorFn);
+  }
   const maxRetries = options.maxRetries ?? this.maxRetries;
   const retryDelay = options.retryDelay ?? this.retryDelay;
   const enableGroundingForMessage = options.enableGrounding ?? this.enableGrounding;
@@ -491,6 +515,17 @@ Respond with JSON only \u2013 no comments or explanations.
   let result;
   try {
     result = await this.chat.sendMessage({ message: prompt });
+    this.lastResponseMetadata = {
+      modelVersion: result.modelVersion || null,
+      requestedModel: this.modelName,
+      promptTokens: result.usageMetadata?.promptTokenCount || 0,
+      responseTokens: result.usageMetadata?.candidatesTokenCount || 0,
+      totalTokens: result.usageMetadata?.totalTokenCount || 0,
+      timestamp: Date.now()
+    };
+    if (result.usageMetadata && logger_default.level !== "silent") {
+      logger_default.debug(`Rebuild response metadata - tokens used:`, result.usageMetadata.totalTokenCount);
+    }
   } catch (err) {
     throw new Error(`Gemini call failed while repairing payload: ${err.message}`);
   }
@@ -580,6 +615,68 @@ async function updateSystemInstructions(newInstructions) {
   logger_default.debug("Updating system instructions and reinitializing chat...");
   await this.init(true);
 }
+async function clearConversation() {
+  if (!this.chat) {
+    logger_default.warn("Cannot clear conversation: chat not initialized.");
+    return;
+  }
+  const history = this.chat.getHistory();
+  const exampleHistory = history.slice(0, this.exampleCount || 0);
+  this.chat = await this.genAIClient.chats.create({
+    model: this.modelName,
+    // @ts-ignore
+    config: {
+      ...this.chatConfig,
+      ...Object.keys(this.labels).length > 0 && { labels: this.labels }
+    },
+    history: exampleHistory
+  });
+  logger_default.debug(`Conversation cleared. Preserved ${exampleHistory.length} example items.`);
+}
+async function statelessMessage(sourcePayload, options = {}, validatorFn = null) {
+  if (!this.chat) {
+    throw new Error("Chat session not initialized. Please call init() first.");
+  }
+  const payloadStr = typeof sourcePayload === "string" ? sourcePayload : JSON.stringify(sourcePayload, null, 2);
+  const contents = [];
+  if (this.exampleCount > 0) {
+    const history = this.chat.getHistory();
+    const exampleHistory = history.slice(0, this.exampleCount);
+    contents.push(...exampleHistory);
+  }
+  contents.push({ role: "user", parts: [{ text: payloadStr }] });
+  const mergedLabels = { ...this.labels, ...options.labels || {} };
+  const result = await this.genAIClient.models.generateContent({
+    model: this.modelName,
+    contents,
+    config: {
+      ...this.chatConfig,
+      ...Object.keys(mergedLabels).length > 0 && { labels: mergedLabels }
+    }
+  });
+  this.lastResponseMetadata = {
+    modelVersion: result.modelVersion || null,
+    requestedModel: this.modelName,
+    promptTokens: result.usageMetadata?.promptTokenCount || 0,
+    responseTokens: result.usageMetadata?.candidatesTokenCount || 0,
+    totalTokens: result.usageMetadata?.totalTokenCount || 0,
+    timestamp: Date.now()
+  };
+  if (result.usageMetadata && logger_default.level !== "silent") {
+    logger_default.debug(`Stateless message metadata:`, {
+      modelVersion: result.modelVersion || "not-provided",
+      promptTokens: result.usageMetadata.promptTokenCount,
+      responseTokens: result.usageMetadata.candidatesTokenCount
+    });
+  }
+  const modelResponse = result.text;
+  const extractedJSON = extractJSON(modelResponse);
+  let transformedPayload = extractedJSON?.data ? extractedJSON.data : extractedJSON;
+  if (validatorFn) {
+    await validatorFn(transformedPayload);
+  }
+  return transformedPayload;
+}
 function attemptJSONRecovery(text, maxAttempts = 100) {
   if (!text || typeof text !== "string") return null;
   try {

package/index.js

@@ -57,7 +57,7 @@ const DEFAULT_THINKING_CONFIG = {
 	thinkingLevel: ThinkingLevel.MINIMAL
 };
 
-const DEFAULT_MAX_OUTPUT_TOKENS = 100000; // Default ceiling for output tokens
+const DEFAULT_MAX_OUTPUT_TOKENS = 50_000; // Default ceiling for output tokens
 
 // Models that support thinking features (as of Dec 2024)
 // Using regex patterns for more precise matching
@@ -112,6 +112,8 @@ class AITransformer {
 		this.onlyJSON = true; // always return JSON
 		this.asyncValidator = null; // for transformWithValidation
 		this.logLevel = 'info'; // default log level
+		this.lastResponseMetadata = null; // stores metadata from last API response
+		this.exampleCount = 0; // tracks number of example history items from seed()
 		AITransformFactory.call(this, options);
 
 		//external API
@@ -136,6 +138,7 @@ class AITransformer {
 		this.estimateTokenUsage = estimateTokenUsage.bind(this);
 		this.updateSystemInstructions = updateSystemInstructions.bind(this);
 		this.estimateCost = estimateCost.bind(this);
+		this.clearConversation = clearConversation.bind(this);
 	}
 }
 
@@ -467,6 +470,8 @@ async function seedWithExamples(examples) {
 		history: [...currentHistory, ...historyToAdd],
 	});
 
+	// Track example count for clearConversation() and stateless messages
+	this.exampleCount = currentHistory.length + historyToAdd.length;
 
 	const newHistory = this.chat.getHistory();
 	log.debug(`Created new chat session with ${newHistory.length} examples.`);
@@ -509,6 +514,27 @@ async function rawMessage(sourcePayload, messageOptions = {}) {
 		}
 
 		const result = await this.chat.sendMessage(sendParams);
+
+		// Capture and log response metadata for model verification and debugging
+		this.lastResponseMetadata = {
+			modelVersion: result.modelVersion || null,
+			requestedModel: this.modelName,
+			promptTokens: result.usageMetadata?.promptTokenCount || 0,
+			responseTokens: result.usageMetadata?.candidatesTokenCount || 0,
+			totalTokens: result.usageMetadata?.totalTokenCount || 0,
+			timestamp: Date.now()
+		};
+
+		if (result.usageMetadata && log.level !== 'silent') {
+			log.debug(`API response metadata:`, {
+				modelVersion: result.modelVersion || 'not-provided',
+				requestedModel: this.modelName,
+				promptTokens: result.usageMetadata.promptTokenCount,
+				responseTokens: result.usageMetadata.candidatesTokenCount,
+				totalTokens: result.usageMetadata.totalTokenCount
+			});
+		}
+
 		const modelResponse = result.text;
 		const extractedJSON = extractJSON(modelResponse); // Assuming extractJSON is defined
 
@@ -539,6 +565,12 @@ async function prepareAndValidateMessage(sourcePayload, options = {}, validatorF
 	if (!this.chat) {
 		throw new Error("Chat session not initialized. Please call init() first.");
 	}
+
+	// Handle stateless messages separately - they don't add to chat history
+	if (options.stateless) {
+		return await statelessMessage.call(this, sourcePayload, options, validatorFn);
+	}
+
 	const maxRetries = options.maxRetries ?? this.maxRetries;
 	const retryDelay = options.retryDelay ?? this.retryDelay;
 
@@ -656,6 +688,7 @@ async function prepareAndValidateMessage(sourcePayload, options = {}, validatorF
 
 /**
  * Rebuilds a payload based on server error feedback
+ * @this {ExportedAPI}
  * @param {Object} lastPayload - The payload that failed validation
  * @param {string} serverError - The error message from the server
  * @returns {Promise<Object>} - A new corrected payload
@@ -681,6 +714,20 @@ Respond with JSON only – no comments or explanations.
 	let result;
 	try {
 		result = await this.chat.sendMessage({ message: prompt });
+
+		// Capture and log response metadata for rebuild calls too
+		this.lastResponseMetadata = {
+			modelVersion: result.modelVersion || null,
+			requestedModel: this.modelName,
+			promptTokens: result.usageMetadata?.promptTokenCount || 0,
+			responseTokens: result.usageMetadata?.candidatesTokenCount || 0,
+			totalTokens: result.usageMetadata?.totalTokenCount || 0,
+			timestamp: Date.now()
+		};
+
+		if (result.usageMetadata && log.level !== 'silent') {
+			log.debug(`Rebuild response metadata - tokens used:`, result.usageMetadata.totalTokenCount);
+		}
 	} catch (err) {
 		throw new Error(`Gemini call failed while repairing payload: ${err.message}`);
 	}
@@ -833,6 +880,110 @@ async function updateSystemInstructions(newInstructions) {
 	await this.init(true); // Force reinitialize with new instructions
 }
 
+/**
+ * Clears conversation history while preserving seeded examples.
+ * Useful for starting a fresh conversation within the same session
+ * without losing the few-shot learning examples.
+ * @this {ExportedAPI}
+ * @returns {Promise<void>}
+ */
+async function clearConversation() {
+	if (!this.chat) {
+		log.warn("Cannot clear conversation: chat not initialized.");
+		return;
+	}
+
+	const history = this.chat.getHistory();
+	const exampleHistory = history.slice(0, this.exampleCount || 0);
+
+	this.chat = await this.genAIClient.chats.create({
+		model: this.modelName,
+		// @ts-ignore
+		config: {
+			...this.chatConfig,
+			...(Object.keys(this.labels).length > 0 && { labels: this.labels })
+		},
+		history: exampleHistory,
+	});
+
+	log.debug(`Conversation cleared. Preserved ${exampleHistory.length} example items.`);
+}
+
+/**
+ * Sends a one-off message using generateContent (not chat).
+ * Does NOT affect chat history - useful for isolated requests.
+ * @this {ExportedAPI}
+ * @param {Object|string} sourcePayload - The source payload.
+ * @param {Object} [options] - Options including labels.
+ * @param {AsyncValidatorFunction|null} [validatorFn] - Optional validator.
+ * @returns {Promise<Object>} - The transformed payload.
+ */
+async function statelessMessage(sourcePayload, options = {}, validatorFn = null) {
+	if (!this.chat) {
+		throw new Error("Chat session not initialized. Please call init() first.");
+	}
+
+	const payloadStr = typeof sourcePayload === 'string'
+		? sourcePayload
+		: JSON.stringify(sourcePayload, null, 2);
+
+	// Build contents including examples from current chat history
+	const contents = [];
+
+	// Include seeded examples if we have them
+	if (this.exampleCount > 0) {
+		const history = this.chat.getHistory();
+		const exampleHistory = history.slice(0, this.exampleCount);
+		contents.push(...exampleHistory);
+	}
+
+	// Add the user message
+	contents.push({ role: 'user', parts: [{ text: payloadStr }] });
+
+	// Merge labels
+	const mergedLabels = { ...this.labels, ...(options.labels || {}) };
+
+	// Use generateContent instead of chat.sendMessage
+	const result = await this.genAIClient.models.generateContent({
+		model: this.modelName,
+		contents: contents,
+		config: {
+			...this.chatConfig,
+			...(Object.keys(mergedLabels).length > 0 && { labels: mergedLabels })
+		}
+	});
+
+	// Capture and log response metadata
+	this.lastResponseMetadata = {
+		modelVersion: result.modelVersion || null,
+		requestedModel: this.modelName,
+		promptTokens: result.usageMetadata?.promptTokenCount || 0,
+		responseTokens: result.usageMetadata?.candidatesTokenCount || 0,
+		totalTokens: result.usageMetadata?.totalTokenCount || 0,
+		timestamp: Date.now()
+	};
+
+	if (result.usageMetadata && log.level !== 'silent') {
+		log.debug(`Stateless message metadata:`, {
+			modelVersion: result.modelVersion || 'not-provided',
+			promptTokens: result.usageMetadata.promptTokenCount,
+			responseTokens: result.usageMetadata.candidatesTokenCount
+		});
+	}
+
+	const modelResponse = result.text;
+	const extractedJSON = extractJSON(modelResponse);
+
+	let transformedPayload = extractedJSON?.data ? extractedJSON.data : extractedJSON;
+
+	// Validate if a validator is provided
+	if (validatorFn) {
+		await validatorFn(transformedPayload);
+	}
+
+	return transformedPayload;
+}
+
 
 /*
 ----

package/package.json

@@ -2,7 +2,7 @@
 	"name": "ak-gemini",
 	"author": "ak@mixpanel.com",
 	"description": "AK's Generative AI Helper for doing... transforms",
-	"version": "1.0.11",
+	"version": "1.0.12",
 	"main": "index.js",
 	"files": [
 		"index.js",

package/types.d.ts

@@ -31,6 +31,26 @@ export interface ChatConfig {
   [key: string]: any; // Additional properties for flexibility
 }
 
+/** Metadata from the last API response, useful for debugging and cost tracking */
+export interface ResponseMetadata {
+  modelVersion: string | null; // The actual model version that responded
+  requestedModel: string; // The model that was requested
+  promptTokens: number; // Number of tokens in the prompt
+  responseTokens: number; // Number of tokens in the response
+  totalTokens: number; // Total tokens used
+  timestamp: number; // Timestamp of when the response was received
+}
+
+/** Options for per-message configuration */
+export interface MessageOptions {
+  labels?: Record<string, string>; // Per-message billing labels
+  stateless?: boolean; // If true, send message without affecting chat history
+  maxRetries?: number; // Override max retries for this message
+  retryDelay?: number; // Override retry delay for this message
+  enableGrounding?: boolean; // Override grounding setting for this message
+  groundingConfig?: Record<string, any>; // Override grounding config for this message
+}
+
 export interface AITransformerContext {
   modelName?: string;
   systemInstructions?: string;
@@ -47,8 +67,8 @@ export interface AITransformerContext {
   maxRetries?: number;
   retryDelay?: number;
   init?: (force?: boolean) => Promise<void>; // Initialization function
-  seed?: () => Promise<void>; // Function to seed the transformer with examples  
-  message?: (payload: Record<string, unknown>) => Promise<Record<string, unknown>>; // Function to send messages to the model
+  seed?: () => Promise<void>; // Function to seed the transformer with examples
+  message?: (payload: Record<string, unknown>, opts?: MessageOptions, validatorFn?: AsyncValidatorFunction | null) => Promise<Record<string, unknown>>; // Function to send messages to the model
   rebuild?: (lastPayload: Record<string, unknown>, serverError: string) => Promise<Record<string, unknown>>; // Function to rebuild the transformer
   rawMessage?: (payload: Record<string, unknown> | string, messageOptions?: { labels?: Record<string, string> }) => Promise<Record<string, unknown>>; // Function to send raw messages to the model
   genAIClient?: GoogleGenAI; // Google GenAI client instance
@@ -57,7 +77,9 @@ export interface AITransformerContext {
   groundingConfig?: Record<string, any>; // Additional grounding configuration options
   labels?: Record<string, string>; // Custom labels for billing segmentation (keys: 1-63 chars lowercase, values: max 63 chars)
   estimateTokenUsage?: (nextPayload: Record<string, unknown> | string) => Promise<{ totalTokens: number; breakdown?: any }>;
-
+  lastResponseMetadata?: ResponseMetadata | null; // Metadata from the last API response
+  exampleCount?: number; // Number of example history items from seed()
+  clearConversation?: () => Promise<void>; // Clears conversation history while preserving examples
 }
 
 export interface TransformationExample {
@@ -92,7 +114,7 @@ export interface AITransformerOptions {
   systemInstructions?: string; // Custom system instructions for the model
   chatConfig?: ChatConfig; // Configuration object for the chat session
   thinkingConfig?: ThinkingConfig; // Thinking features configuration (defaults to thinkingBudget: 0, thinkingLevel: "MINIMAL")
-  maxOutputTokens?: number; // Maximum number of tokens that can be generated in the response (defaults to 100000)
+  maxOutputTokens?: number; // Maximum number of tokens that can be generated in the response (defaults to 50000)
   examplesFile?: string; // Path to JSON file containing transformation examples
   exampleData?: TransformationExample[]; // Inline examples to seed the transformer
   sourceKey?: string; // Key name for source data in examples (alias for promptKey)
@@ -150,14 +172,24 @@ export declare class AITransformer {
   enableGrounding: boolean;
   groundingConfig: Record<string, any>;
   labels: Record<string, string>;
-  
+  /** Metadata from the last API response (model version, token counts, etc.) */
+  lastResponseMetadata: ResponseMetadata | null;
+  /** Number of history items that are seeded examples (used by clearConversation) */
+  exampleCount: number;
+
   // Methods
   init(force?: boolean): Promise<void>;
   seed(examples?: TransformationExample[]): Promise<any>;
-  message(payload: Record<string, unknown>, opts?: object, validatorFn?: AsyncValidatorFunction | null): Promise<Record<string, unknown>>;
+  /**
+   * Send a message to the model.
+   * @param payload - The payload to transform
+   * @param opts - Options including { stateless: true } to send without affecting history
+   * @param validatorFn - Optional validator function
+   */
+  message(payload: Record<string, unknown>, opts?: MessageOptions, validatorFn?: AsyncValidatorFunction | null): Promise<Record<string, unknown>>;
   rawMessage(sourcePayload: Record<string, unknown> | string, messageOptions?: { labels?: Record<string, string> }): Promise<Record<string, unknown> | any>;
-  transformWithValidation(sourcePayload: Record<string, unknown>, validatorFn: AsyncValidatorFunction, options?: object): Promise<Record<string, unknown>>;
-  messageAndValidate(sourcePayload: Record<string, unknown>, validatorFn: AsyncValidatorFunction, options?: object): Promise<Record<string, unknown>>;
+  transformWithValidation(sourcePayload: Record<string, unknown>, validatorFn: AsyncValidatorFunction, options?: MessageOptions): Promise<Record<string, unknown>>;
+  messageAndValidate(sourcePayload: Record<string, unknown>, validatorFn: AsyncValidatorFunction, options?: MessageOptions): Promise<Record<string, unknown>>;
   rebuild(lastPayload: Record<string, unknown>, serverError: string): Promise<Record<string, unknown>>;
   reset(): Promise<void>;
   getHistory(): Array<any>;
@@ -171,6 +203,8 @@ export declare class AITransformer {
     estimatedInputCost: number;
     note: string;
   }>;
+  /** Clears conversation history while preserving seeded examples */
+  clearConversation(): Promise<void>;
 }
 
 // Default export