@nshiab/simple-data-analysis 5.21.1 → 6.0.1

package/esm/deps/jsr.io/@nshiab/journalism-ai/2.0.6/src/ai/askGeminiPool.js

@@ -0,0 +1,197 @@
+import askGemini from "./askGemini.js";
+import sleep from "./helpers/sleep.js";
+/**
+ * Processes multiple Gemini requests concurrently using a pool of workers. This function wraps {@link askGemini} and manages parallel execution, retries, progress logging, and error handling for batch operations.
+ *
+ * Each request in the array is processed by a worker from the pool. The pool size controls how many requests run simultaneously. Results and errors are returned separately, sorted by their original index, making it easy to match outputs back to inputs.
+ *
+ * **Caching**: each request uses {@link askGemini}'s default caching behavior, so
+ * responses are persisted in `.journalism-cache` by default. Set
+ * `options.cache: false` on an individual request to disable caching for it.
+ *
+ * @example
+ * ```ts
+ * // Basic usage: Process a batch of prompts with a pool of 5 concurrent workers.
+ * const { results, errors } = await askGeminiPool(
+ *   [
+ *     { prompt: "What is the capital of France?" },
+ *     { prompt: "What is the capital of Germany?" },
+ *     { prompt: "What is the capital of Italy?" },
+ *   ],
+ *   5,
+ * );
+ * for (const r of results) {
+ *   console.log(r.result.response);
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use an id to easily identify each request in the results.
+ * const { results, errors } = await askGeminiPool(
+ *   [
+ *     { id: "france", prompt: "What is the capital of France?" },
+ *     { id: "germany", prompt: "What is the capital of Germany?" },
+ *   ],
+ *   2,
+ * );
+ * for (const r of results) {
+ *   console.log(r.request.id, r.result.response);
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Enable progress logging and retries.
+ * const { results, errors } = await askGeminiPool(
+ *   [
+ *     { prompt: "Summarize this article.", options: { files: [{ path: "./article1.txt", type: "text" }], schemaJson: schema } },
+ *     { prompt: "Summarize this article.", options: { files: [{ path: "./article2.txt", type: "text" }], schemaJson: schema } },
+ *   ],
+ *   3,
+ *   {
+ *     logProgress: true,
+ *     retry: 2,
+ *   },
+ * );
+ * console.log(`${results.length} succeeded, ${errors.length} failed`);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use retryCheck to only retry on specific errors.
+ * const { results, errors } = await askGeminiPool(
+ *   [
+ *     { prompt: "Analyze this image.", options: { files: [{ path: "./photo.jpg", type: "image" }], schemaJson: schema } },
+ *   ],
+ *   1,
+ *   {
+ *     retry: 3,
+ *     retryCheck: (error) => {
+ *       // Only retry on rate limit errors
+ *       return error instanceof Error && error.message.includes("429");
+ *     },
+ *   },
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use schemaJson to enforce structured output with a specific schema.
+ * import * as z from "zod";
+ *
+ * const schema = z.toJSONSchema(
+ *   z.object({
+ *     people: z.array(z.object({
+ *       name: z.string(),
+ *       age: z.number(),
+ *       gender: z.enum(["man", "woman"]),
+ *     })),
+ *   }),
+ * );
+ *
+ * const { results, errors } = await askGeminiPool(
+ *   [
+ *     { prompt: "Give me 5 characters from Harry Potter.", options: { schemaJson: schema } },
+ *     { prompt: "Give me 5 characters from Lord of the Rings.", options: { schemaJson: schema } },
+ *   ],
+ *   2,
+ * );
+ * // Each result.response will conform to the specified schema
+ * for (const r of results) {
+ *   console.log(r.result.response); // { people: [{ name: "...", age: ..., gender: "..." }, ...] }
+ * }
+ * ```
+ *
+ * @param requests - An array of request objects to process.
+ *   @param requests[].id - An optional identifier for the request, useful for matching results back to inputs.
+ *   @param requests[].prompt - The primary text input for the AI model.
+ *   @param requests[].processResponse - An optional function that transforms or validates the response inside the retry loop. If it throws, the request is retried according to `poolOptions`.
+ *   @param requests[].options - Options passed to {@link askGemini} for each individual request. Caching defaults to `true`; set `cache: false` to disable it for that request. See {@link askGemini} for the full list of available options.
+ * @param poolSize - The number of concurrent workers processing requests.
+ * @param poolOptions - Configuration for the pool execution.
+ *   @param poolOptions.logProgress - If `true`, logs progress to the console after each completed or failed request. Defaults to `false`.
+ *   @param poolOptions.retry - The maximum number of retry attempts for a failed request. Defaults to `0` (no retries).
+ *   @param poolOptions.retryCheck - A function that receives the error and returns whether the request should be retried. If not provided, all failed requests are retried up to the `retry` limit.
+ *   @param poolOptions.minRequestDurationMs - A minimum duration in milliseconds for each request. If a request completes faster, the worker will wait before picking up the next one. Useful for rate limiting.
+ * @returns A Promise that resolves to an object with `results` (successful responses with their index and request) and `errors` (failed requests with their index, request, and error), both sorted by original index.
+ *
+ * @category AI
+ */
+export default function askGeminiPool(requests, poolSize, poolOptions = {}) {
+    return runAskGeminiPool(requests, poolSize, poolOptions, askGemini);
+}
+/** Runs the Gemini worker pool with an injectable executor for deterministic testing. */
+export async function runAskGeminiPool(requests, poolSize, poolOptions, executeRequest) {
+    const maxRetries = poolOptions.retry ?? 0;
+    const results = [];
+    const errors = [];
+    const queue = requests.map((req, index) => ({ req, index, attempt: 0 }));
+    let completed = 0;
+    let activeWorkers = 0;
+    // Worker function that continuously processes items from the queue
+    const worker = async () => {
+        while (queue.length > 0) {
+            const item = queue.shift();
+            if (!item)
+                break;
+            const { req, index, attempt } = item;
+            activeWorkers++;
+            const requestStart = Date.now();
+            try {
+                const result = await executeRequest(req.prompt, {
+                    ...req.options,
+                    processResponse: req.processResponse,
+                });
+                results.push({ index, request: req, result });
+                completed++;
+                activeWorkers--;
+                if (poolOptions.logProgress) {
+                    const durationMs = Date.now() - requestStart;
+                    const durationSec = (durationMs / 1000).toFixed(2);
+                    const outstanding = requests.length - completed;
+                    console.log(`[askGeminiPool] Request ${index} processed | Duration: ${durationSec}s | Outstanding: ${outstanding} | Active: ${activeWorkers}`);
+                }
+            }
+            catch (error) {
+                activeWorkers--;
+                // Retry logic
+                if (poolOptions.retryCheck
+                    ? (await poolOptions.retryCheck(error)) && attempt < maxRetries
+                    : attempt < maxRetries) {
+                    // Re-queue the request with incremented attempt count
+                    queue.push({ req, index, attempt: attempt + 1 });
+                    if (poolOptions.logProgress) {
+                        const durationMs = Date.now() - requestStart;
+                        const durationSec = (durationMs / 1000).toFixed(2);
+                        console.log(`[askGeminiPool] Request ${index} failed (attempt ${attempt + 1}/${maxRetries + 1}) | Duration: ${durationSec}s | Retrying...`);
+                    }
+                }
+                else {
+                    // Max retries exceeded, store the error
+                    errors.push({ index, request: req, error });
+                    completed++;
+                    if (poolOptions.logProgress) {
+                        const durationMs = Date.now() - requestStart;
+                        const durationSec = (durationMs / 1000).toFixed(2);
+                        const outstanding = requests.length - completed;
+                        console.log(`[askGeminiPool] Request ${index} failed after ${maxRetries + 1} attempts | Duration: ${durationSec}s | Outstanding: ${outstanding} | Active: ${activeWorkers}`);
+                    }
+                }
+            }
+            // Enforce minimum request duration if specified
+            if (poolOptions.minRequestDurationMs) {
+                await sleep(poolOptions.minRequestDurationMs, requestStart);
+            }
+        }
+    };
+    // Start a pool of workers
+    const numWorkers = Math.min(poolSize, requests.length);
+    const workers = Array.from({ length: numWorkers }, () => worker());
+    // Wait for all workers to complete
+    await Promise.all(workers);
+    return {
+        results: results.sort((a, b) => a.index - b.index),
+        errors: errors.sort((a, b) => a.index - b.index),
+    };
+}

package/esm/deps/jsr.io/@nshiab/journalism-ai/2.0.6/src/ai/askOllama.d.ts

@@ -0,0 +1,123 @@
+/** The detailed response shape returned by {@link askOllama}. */
+export type OllamaDetailedResponse<TResponse = unknown> = {
+    response: TResponse;
+    fromCache: boolean;
+    prompt: string;
+    systemPrompt: string | null;
+    thinkingLevel: boolean | "low" | "medium" | "high" | null;
+    contextWindow: number | null;
+    temperature: number;
+    files: {
+        path: string;
+        type: "image" | "text";
+    }[];
+    promptTokenCount: number;
+    outputTokenCount: number;
+    totalTokens: number;
+    tokensPerSecond: number;
+    durationMs: number;
+    model: string;
+    thoughts: string | null;
+};
+/** Configuration accepted by {@link askOllama}. */
+export type AskOllamaOptions<TResponse = unknown> = {
+    systemPrompt?: string;
+    model?: string;
+    ollama?: unknown;
+    files?: {
+        path: string;
+        type: "image" | "text";
+    }[];
+    schemaJson?: unknown;
+    cache?: boolean;
+    contextWindow?: number;
+    thinkingLevel?: boolean | "low" | "medium" | "high";
+    temperature?: number;
+    ollamaParameters?: unknown;
+    processResponse?: (response: unknown) => TResponse | Promise<TResponse>;
+};
+/**
+ * Interacts with a local Ollama model to perform a wide range of tasks.
+ *
+ * Ollama must be running on the machine. Set the `AI_MODEL` environment
+ * variable or pass `model` directly.
+ *
+ * Pass a custom `Ollama` instance via the `ollama` option to target a
+ * non-default host.
+ *
+ * **File handling**: pass local files via `files: [{ path, type }]`. Only `"image"`
+ * and `"text"` types are supported for now.
+ *
+ * **Caching**: responses are persisted in `.journalism-cache` by default. Set
+ * `cache: false` to disable caching.
+ *
+ * Temperature defaults to 0 for deterministic responses.
+ *
+ * @example
+ * ```ts
+ * // Assumes AI_MODEL is set in environment variables.
+ * const result = await askOllama("What is the capital of France?");
+ * console.log(result.response); // "Paris"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use a custom Ollama instance.
+ * import { Ollama } from "ollama";
+ * const client = new Ollama({ host: "http://127.0.0.1:11434" });
+ * const result = await askOllama("What is the capital of France?", { ollama: client });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Analyse a local image.
+ * const result = await askOllama("Describe this image.", {
+ *   files: [{ path: "./photo.jpg", type: "image" }],
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Structured JSON output.
+ * import * as z from "zod";
+ * const schema = z.toJSONSchema(z.object({ country: z.string(), capital: z.string() }));
+ * const result = await askOllama(
+ *   "What is the capital of France?",
+ *   { schemaJson: schema },
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Enable thinking / reasoning.
+ * const result = await askOllama(
+ *   "What is 17 * 23?",
+ *   { thinkingLevel: "low" },
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Access token usage directly from the response.
+ * const result = await askOllama("What is the capital of France?");
+ * console.log(result.response); // "Paris"
+ * console.log(`${result.totalTokens} tokens in ${result.durationMs}ms`);
+ * ```
+ *
+ * @param prompt - The primary text prompt.
+ * @param options.model - Model name; defaults to `AI_MODEL` env var.
+ * @param options.ollama - Custom `Ollama` instance targeting a specific host.
+ * @param options.systemPrompt - Optional system prompt.
+ * @param options.files - Files to send alongside the prompt. Only `"image"` and `"text"` types are supported (local paths only; no GCS, audio, video, or PDF). Text files are sent as separate user messages after the prompt; images are sent as attachments to the prompt message.
+ * @param options.schemaJson - JSON schema for structured output.
+ * @param options.cache - Cache the response in `.journalism-cache`. Defaults to `true`.
+ * @param options.contextWindow - Override the model's context window size.
+ * @param options.thinkingLevel - Enables reasoning. Pass `true` for models that only support on/off, or `"low"`, `"medium"`, or `"high"` for granular control.
+ * @param options.temperature - Sampling temperature (default 0).
+ * @param options.ollamaParameters - Extra params merged into `client.chat`.
+ * @param options.processResponse - Transform or validate the response before it is returned. If it rejects a cached response, that cache entry is removed so a retry can generate a fresh response.
+ *
+ * @category AI
+ */
+export default function askOllama<TResponse = unknown>(prompt: string, options?: AskOllamaOptions<TResponse>): Promise<OllamaDetailedResponse<TResponse>>;
+//# sourceMappingURL=askOllama.d.ts.map

package/esm/deps/jsr.io/@nshiab/journalism-ai/2.0.6/src/ai/askOllama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"askOllama.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-ai/2.0.6/src/ai/askOllama.ts"],"names":[],"mappings":"AAoBA,iEAAiE;AACjE,MAAM,MAAM,sBAAsB,CAAC,SAAS,GAAG,OAAO,IAAI;IACxD,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,aAAa,EAAE,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,CAAC;IAC1D,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;KAAE,EAAE,CAAC;IAClD,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,gBAAgB,CAAC,SAAS,GAAG,OAAO,IAAI;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;KAAE,EAAE,CAAC;IACnD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACpD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACzE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,wBAA8B,SAAS,CAAC,SAAS,GAAG,OAAO,EACzD,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gBAAgB,CAAC,SAAS,CAAM,GACxC,OAAO,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC,CA8J5C"}

package/esm/deps/jsr.io/@nshiab/journalism-ai/2.0.6/src/ai/askOllama.js

@@ -0,0 +1,223 @@
+import { readFileSync } from "node:fs";
+import process from "node:process";
+import ollama, { Ollama } from "ollama";
+import { fromJSONSchema } from "zod";
+import { initCache, readAndProcessCache, writeCache } from "./helpers/cache.js";
+import { processResponse } from "./helpers/processResponse.js";
+function validateStructuredResponse(response, schemaJson) {
+    if (schemaJson === undefined) {
+        return response;
+    }
+    const schema = fromJSONSchema(schemaJson);
+    return schema.parse(response);
+}
+/**
+ * Interacts with a local Ollama model to perform a wide range of tasks.
+ *
+ * Ollama must be running on the machine. Set the `AI_MODEL` environment
+ * variable or pass `model` directly.
+ *
+ * Pass a custom `Ollama` instance via the `ollama` option to target a
+ * non-default host.
+ *
+ * **File handling**: pass local files via `files: [{ path, type }]`. Only `"image"`
+ * and `"text"` types are supported for now.
+ *
+ * **Caching**: responses are persisted in `.journalism-cache` by default. Set
+ * `cache: false` to disable caching.
+ *
+ * Temperature defaults to 0 for deterministic responses.
+ *
+ * @example
+ * ```ts
+ * // Assumes AI_MODEL is set in environment variables.
+ * const result = await askOllama("What is the capital of France?");
+ * console.log(result.response); // "Paris"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use a custom Ollama instance.
+ * import { Ollama } from "ollama";
+ * const client = new Ollama({ host: "http://127.0.0.1:11434" });
+ * const result = await askOllama("What is the capital of France?", { ollama: client });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Analyse a local image.
+ * const result = await askOllama("Describe this image.", {
+ *   files: [{ path: "./photo.jpg", type: "image" }],
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Structured JSON output.
+ * import * as z from "zod";
+ * const schema = z.toJSONSchema(z.object({ country: z.string(), capital: z.string() }));
+ * const result = await askOllama(
+ *   "What is the capital of France?",
+ *   { schemaJson: schema },
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Enable thinking / reasoning.
+ * const result = await askOllama(
+ *   "What is 17 * 23?",
+ *   { thinkingLevel: "low" },
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Access token usage directly from the response.
+ * const result = await askOllama("What is the capital of France?");
+ * console.log(result.response); // "Paris"
+ * console.log(`${result.totalTokens} tokens in ${result.durationMs}ms`);
+ * ```
+ *
+ * @param prompt - The primary text prompt.
+ * @param options.model - Model name; defaults to `AI_MODEL` env var.
+ * @param options.ollama - Custom `Ollama` instance targeting a specific host.
+ * @param options.systemPrompt - Optional system prompt.
+ * @param options.files - Files to send alongside the prompt. Only `"image"` and `"text"` types are supported (local paths only; no GCS, audio, video, or PDF). Text files are sent as separate user messages after the prompt; images are sent as attachments to the prompt message.
+ * @param options.schemaJson - JSON schema for structured output.
+ * @param options.cache - Cache the response in `.journalism-cache`. Defaults to `true`.
+ * @param options.contextWindow - Override the model's context window size.
+ * @param options.thinkingLevel - Enables reasoning. Pass `true` for models that only support on/off, or `"low"`, `"medium"`, or `"high"` for granular control.
+ * @param options.temperature - Sampling temperature (default 0).
+ * @param options.ollamaParameters - Extra params merged into `client.chat`.
+ * @param options.processResponse - Transform or validate the response before it is returned. If it rejects a cached response, that cache entry is removed so a retry can generate a fresh response.
+ *
+ * @category AI
+ */
+export default async function askOllama(prompt, options = {}) {
+    const start = Date.now();
+    const detailedData = {
+        response: undefined,
+        prompt: prompt,
+        systemPrompt: options.systemPrompt ?? null,
+        thinkingLevel: options.thinkingLevel ?? null,
+        contextWindow: options.contextWindow ?? null,
+        temperature: options.temperature ?? 0,
+        files: [],
+        fromCache: false,
+        model: "",
+        promptTokenCount: 0,
+        outputTokenCount: 0,
+        totalTokens: 0,
+        tokensPerSecond: 0,
+        durationMs: 0,
+        thoughts: null,
+    };
+    const client = options.ollama instanceof Ollama ? options.ollama : ollama;
+    const model = options.model ?? process.env.AI_MODEL;
+    if (!model) {
+        throw new Error("Model not specified. Use the AI_MODEL environment variable or pass it as an option.");
+    }
+    detailedData.model = model;
+    const hasSchema = options.schemaJson !== undefined;
+    const groundedPrompt = hasSchema
+        ? `${prompt}\n\nReturn JSON matching this schema exactly:\n${JSON.stringify(options.schemaJson)}`
+        : prompt;
+    // Build message
+    const message = {
+        role: "user",
+        content: groundedPrompt,
+    };
+    const fileMessages = [];
+    for (const { path, type } of options.files ?? []) {
+        if (type === "text") {
+            const textContent = readFileSync(path, { encoding: "utf-8" });
+            fileMessages.push({
+                role: "user",
+                content: `Content from ${path}:\n${textContent}`,
+            });
+        }
+        else if (type === "image") {
+            message.images = message.images ?? [];
+            message.images.push(readFileSync(path, { encoding: "base64" }));
+        }
+    }
+    detailedData.prompt = prompt;
+    detailedData.systemPrompt = options.systemPrompt ?? null;
+    detailedData.thinkingLevel = options.thinkingLevel ?? null;
+    detailedData.contextWindow = options.contextWindow ?? null;
+    detailedData.temperature = options.temperature ?? 0;
+    detailedData.files = options.files ?? [];
+    const format = hasSchema ? options.schemaJson : undefined;
+    const params = {
+        model,
+        messages: [
+            ...(options.systemPrompt
+                ? [{ role: "system", content: options.systemPrompt }]
+                : []),
+            message,
+            ...fileMessages,
+        ],
+        format,
+        temperature: options.temperature ?? 0,
+        contextWindow: options.contextWindow,
+        think: options.thinkingLevel,
+    };
+    // Cache check
+    const cacheFiles = (options.cache ?? true) ? initCache(params) : null;
+    if (cacheFiles) {
+        const processCachedResponse = hasSchema || options.processResponse
+            ? async (response) => {
+                const validatedResponse = validateStructuredResponse(response, options.schemaJson);
+                return options.processResponse
+                    ? await options.processResponse(validatedResponse)
+                    : validatedResponse;
+            }
+            : undefined;
+        const hit = await readAndProcessCache(cacheFiles.cacheFile, processCachedResponse);
+        if (hit !== null) {
+            return { ...hit, fromCache: true };
+        }
+    }
+    // API call
+    const result = await client.chat({
+        model,
+        messages: params.messages,
+        format: params.format,
+        options: {
+            temperature: params.temperature,
+            num_ctx: options.contextWindow,
+        },
+        think: params.think,
+        ...(options.ollamaParameters ?? {}),
+        stream: false,
+    });
+    const thoughts = result.message.thinking ?? null;
+    const returnedResponse = result.message.content ?? "";
+    // Post-process
+    const response = processResponse(returnedResponse, {
+        parseJson: hasSchema,
+    });
+    const validatedResponse = validateStructuredResponse(response, options.schemaJson);
+    detailedData.response = validatedResponse;
+    // Metrics
+    const promptTokenCount = result.prompt_eval_count ?? 0;
+    const outputTokenCount = result.eval_count ?? 0;
+    const totalTokens = promptTokenCount + outputTokenCount;
+    const durationMs = Date.now() - start;
+    const durationSeconds = durationMs / 1000;
+    const tokensPerSecond = totalTokens / durationSeconds;
+    detailedData.promptTokenCount = promptTokenCount;
+    detailedData.outputTokenCount = outputTokenCount;
+    detailedData.totalTokens = totalTokens;
+    detailedData.tokensPerSecond = tokensPerSecond;
+    detailedData.durationMs = durationMs;
+    detailedData.thoughts = thoughts;
+    const processedResponse = options.processResponse
+        ? await options.processResponse(validatedResponse)
+        : validatedResponse;
+    if (cacheFiles) {
+        writeCache(cacheFiles.cacheFile, detailedData);
+    }
+    return { ...detailedData, response: processedResponse };
+}