@nshiab/simple-data-analysis 5.21.1 → 6.0.1

package/esm/deps/jsr.io/@nshiab/journalism-ai/1.2.23/src/ai/askAIPool.d.ts

@@ -1,199 +0,0 @@
-/** A single request object for {@link askAIPool}, wrapping a prompt and its options. */
-export type askAIRequest = {
-    id?: string;
-    prompt: string;
-    options?: {
-        systemPrompt?: string;
-        model?: string;
-        temperature?: number;
-        apiKey?: string;
-        vertex?: boolean;
-        project?: string;
-        location?: string;
-        ollama?: boolean | any;
-        webSearch?: boolean;
-        HTMLFrom?: string | string[];
-        /** @deprecated Use the `image` option instead. */
-        screenshotFrom?: string | string[];
-        image?: string | string[];
-        video?: string | string[];
-        audio?: string | string[];
-        pdf?: string | string[];
-        text?: string | string[];
-        returnJson?: boolean;
-        parseJson?: boolean;
-        schemaJson?: unknown;
-        verbose?: boolean;
-        cache?: boolean;
-        test?: ((response: unknown) => void) | ((response: unknown) => void)[];
-        clean?: (response: unknown) => unknown;
-        contextWindow?: number;
-        thinkingLevel?: "minimal" | "low" | "medium" | "high";
-        thinkingBudget?: number;
-        includeThoughts?: boolean;
-        geminiParameters?: any;
-        ollamaParameters?: any;
-    };
-};
-/**
- * Processes multiple AI requests concurrently using a pool of workers. This function wraps {@link askAI} 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.
- *
- * @example
- * ```ts
- * // Basic usage: Process a batch of prompts with a pool of 5 concurrent workers.
- * const { results, errors } = await askAIPool(
- *   [
- *     { 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);
- * }
- * ```
- *
- * @example
- * ```ts
- * // Use an id to easily identify each request in the results.
- * const { results, errors } = await askAIPool(
- *   [
- *     { 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);
- * }
- * ```
- *
- * @example
- * ```ts
- * // Enable progress logging and retries.
- * const { results, errors } = await askAIPool(
- *   [
- *     { prompt: "Summarize this article.", options: { text: "./article1.txt", returnJson: true } },
- *     { prompt: "Summarize this article.", options: { text: "./article2.txt", returnJson: true } },
- *   ],
- *   3,
- *   {
- *     logProgress: true,
- *     retry: 2,
- *   },
- * );
- * console.log(`${results.length} succeeded, ${errors.length} failed`);
- * ```
- *
- * @example
- * ```ts
- * // Track cumulative metrics and enforce a minimum request duration to respect rate limits.
- * const metrics = {
- *   totalCost: 0,
- *   totalInputTokens: 0,
- *   totalOutputTokens: 0,
- *   totalRequests: 0,
- * };
- * const { results } = await askAIPool(
- *   [
- *     { prompt: "What is 2+2?" },
- *     { prompt: "What is 3+3?" },
- *   ],
- *   2,
- *   {
- *     minRequestDurationMs: 1000,
- *     metrics,
- *   },
- * );
- * console.log("Total cost:", metrics.totalCost);
- * console.log("Total requests:", metrics.totalRequests);
- * ```
- *
- * @example
- * ```ts
- * // Use retryCheck to only retry on specific errors.
- * const { results, errors } = await askAIPool(
- *   [
- *     { prompt: "Analyze this image.", options: { image: "./photo.jpg", returnJson: true } },
- *   ],
- *   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 askAIPool(
- *   [
- *     { 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 will conform to the specified schema
- * for (const r of results) {
- *   console.log(r.result); // { 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[].options - Options passed to {@link askAI} for each individual request. See {@link askAI} 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.
- *   @param poolOptions.metrics - An object to track cumulative metrics across all requests in the pool. Pass an object with `totalCost`, `totalInputTokens`, `totalOutputTokens`, and `totalRequests` properties (all initialized to 0).
- * @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 askAIPool(requests: askAIRequest[], poolSize: number, poolOptions?: {
-    logProgress?: boolean;
-    retry?: number;
-    retryCheck?: (error: unknown) => Promise<boolean> | boolean;
-    minRequestDurationMs?: number;
-    metrics?: {
-        totalCost: number;
-        totalInputTokens: number;
-        totalOutputTokens: number;
-        totalRequests: number;
-    };
-}): Promise<{
-    results: {
-        index: number;
-        request: askAIRequest;
-        result: unknown;
-    }[];
-    errors: Array<{
-        index: number;
-        request: askAIRequest;
-        error: unknown;
-    }>;
-}>;
-//# sourceMappingURL=askAIPool.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"askAIPool.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-ai/1.2.23/src/ai/askAIPool.ts"],"names":[],"mappings":"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"}

package/esm/deps/jsr.io/@nshiab/journalism-ai/1.2.23/src/ai/askAIPool.js

@@ -1,229 +0,0 @@
-import askAI from "./askAI.js";
-import sleep from "./helpers/sleep.js";
-import { formatNumber } from "../../../../journalism-format/1.1.9/src/index.js";
-/**
- * Processes multiple AI requests concurrently using a pool of workers. This function wraps {@link askAI} 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.
- *
- * @example
- * ```ts
- * // Basic usage: Process a batch of prompts with a pool of 5 concurrent workers.
- * const { results, errors } = await askAIPool(
- *   [
- *     { 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);
- * }
- * ```
- *
- * @example
- * ```ts
- * // Use an id to easily identify each request in the results.
- * const { results, errors } = await askAIPool(
- *   [
- *     { 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);
- * }
- * ```
- *
- * @example
- * ```ts
- * // Enable progress logging and retries.
- * const { results, errors } = await askAIPool(
- *   [
- *     { prompt: "Summarize this article.", options: { text: "./article1.txt", returnJson: true } },
- *     { prompt: "Summarize this article.", options: { text: "./article2.txt", returnJson: true } },
- *   ],
- *   3,
- *   {
- *     logProgress: true,
- *     retry: 2,
- *   },
- * );
- * console.log(`${results.length} succeeded, ${errors.length} failed`);
- * ```
- *
- * @example
- * ```ts
- * // Track cumulative metrics and enforce a minimum request duration to respect rate limits.
- * const metrics = {
- *   totalCost: 0,
- *   totalInputTokens: 0,
- *   totalOutputTokens: 0,
- *   totalRequests: 0,
- * };
- * const { results } = await askAIPool(
- *   [
- *     { prompt: "What is 2+2?" },
- *     { prompt: "What is 3+3?" },
- *   ],
- *   2,
- *   {
- *     minRequestDurationMs: 1000,
- *     metrics,
- *   },
- * );
- * console.log("Total cost:", metrics.totalCost);
- * console.log("Total requests:", metrics.totalRequests);
- * ```
- *
- * @example
- * ```ts
- * // Use retryCheck to only retry on specific errors.
- * const { results, errors } = await askAIPool(
- *   [
- *     { prompt: "Analyze this image.", options: { image: "./photo.jpg", returnJson: true } },
- *   ],
- *   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 askAIPool(
- *   [
- *     { 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 will conform to the specified schema
- * for (const r of results) {
- *   console.log(r.result); // { 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[].options - Options passed to {@link askAI} for each individual request. See {@link askAI} 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.
- *   @param poolOptions.metrics - An object to track cumulative metrics across all requests in the pool. Pass an object with `totalCost`, `totalInputTokens`, `totalOutputTokens`, and `totalRequests` properties (all initialized to 0).
- * @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 async function askAIPool(requests, poolSize, poolOptions = {}) {
-    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 askAI(req.prompt, {
-                    ...req.options,
-                    metrics: poolOptions.metrics,
-                });
-                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;
-                    const metricsInfo = poolOptions.metrics
-                        ? ` | Cost so far: $${formatNumber(poolOptions.metrics.totalCost, {
-                            significantDigits: 6,
-                        })}`
-                        : "";
-                    console.log(`[askAIPool] Request ${index} processed | Duration: ${durationSec}s | Outstanding: ${outstanding} | Active: ${activeWorkers}${metricsInfo}`);
-                }
-            }
-            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);
-                        const metricsInfo = poolOptions.metrics
-                            ? ` | Cost so far: $${formatNumber(poolOptions.metrics.totalCost, {
-                                significantDigits: 6,
-                            })}`
-                            : "";
-                        console.log(`[askAIPool] Request ${index} failed (attempt ${attempt + 1}/${maxRetries + 1}) | Duration: ${durationSec}s | Retrying...${metricsInfo}`);
-                    }
-                }
-                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;
-                        const metricsInfo = poolOptions.metrics
-                            ? ` | Cost so far: $${formatNumber(poolOptions.metrics.totalCost, {
-                                significantDigits: 6,
-                            })}`
-                            : "";
-                        console.log(`[askAIPool] Request ${index} failed after ${maxRetries + 1} attempts | Duration: ${durationSec}s | Outstanding: ${outstanding} | Active: ${activeWorkers}${metricsInfo}`);
-                    }
-                }
-            }
-            // 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/1.2.23/src/ai/getEmbedding.d.ts

@@ -1,69 +0,0 @@
-/**
- * Generates a numerical embedding (vector representation) for a given text string. Embeddings are crucial for various natural language processing (NLP) tasks, including semantic search, text classification, clustering, and anomaly detection, as they allow text to be processed and compared mathematically.
- *
- * This function supports both Google's Gemini AI models and local models running with Ollama. It provides options for authentication, model selection, and caching to optimize performance and cost.
- *
- * **Authentication**:
- * Credentials and model information can be provided via environment variables (`AI_KEY`, `AI_PROJECT`, `AI_LOCATION`, `AI_EMBEDDINGS_MODEL`) or directly through the `options` object. Options take precedence over environment variables.
- *
- * **Local Models**:
- * To use a local model with Ollama, set the `OLLAMA` environment variable to `true` and ensure Ollama is running on your machine. You will also need to specify the model name using the `AI_EMBEDDINGS_MODEL` environment variable or the `model` option. If you want your Ollama instance to be used, you can pass an instance of the `Ollama` class as the `ollama` option.
- *
- * **Caching**:
- * To save resources and time, you can enable caching by setting `cache` to `true`. Responses will be stored in a local `.journalism-cache` directory. If the same request is made again, the cached response will be returned, avoiding redundant API calls. Remember to add `.journalism-cache` to your `.gitignore` file.
- *
- * @param text The input text string for which to generate the embedding.
- * @param options Configuration options for the embedding generation.
- * @param options.model The specific embedding model to use (e.g., 'text-embedding-004'). Defaults to the `AI_EMBEDDINGS_MODEL` environment variable.
- * @param options.apiKey Your API key for authentication with Google Gemini. Defaults to the `AI_KEY` environment variable.
- * @param options.vertex If `true`, uses Vertex AI for authentication. Defaults to `false`.
- * @param options.project Your Google Cloud project ID for Vertex AI. Defaults to the `AI_PROJECT` environment variable.
- * @param options.location The Google Cloud location for your Vertex AI project. Defaults to the `AI_LOCATION` environment variable.
- * @param options.cache If `true`, enables caching of the embedding response. Defaults to `false`.
- * @param options.ollama If `true`, uses Ollama for local embedding generation. Defaults to the `OLLAMA` environment variable. If you want your Ollama instance to be used, you can pass it here too.
- * @param options.verbose If `true`, logs additional information such as execution time and the truncated input text. Defaults to `false`.
- *   @param options.contextWindow - An option to specify the context window size for Ollama models. By default, Ollama sets this depending on the model, which can be lower than the actual maximum context window size of the model.
- *
- * @returns A promise that resolves to an an array of numbers representing the generated embedding.
- *
- * @example
- * ```ts
- * // Basic usage: Generate an embedding for a simple text.
- * const embedding = await getEmbedding("The quick brown fox jumps over the lazy dog.");
- * console.log(embedding); // [0.012, -0.034, ..., 0.056] (example output)
- * ```
- * @example
- * ```ts
- * // Generate an embedding with caching enabled.
- * const cachedEmbedding = await getEmbedding("Artificial intelligence is transforming industries.", { cache: true });
- * console.log(cachedEmbedding);
- * ```
- * @example
- * ```ts
- * // Generate an embedding using a specific model and API key.
- * const customEmbedding = await getEmbedding("Machine learning is a subset of AI.", {
- *   model: "another-embedding-model",
- *   apiKey: "your_custom_api_key"
- * });
- * console.log(customEmbedding);
- * ```
- * @example
- * ```ts
- * // Generate an embedding with verbose logging.
- * const verboseEmbedding = await getEmbedding("The quick brown fox jumps over the lazy dog.", { verbose: true });
- * console.log(verboseEmbedding);
- * ```
- * @category AI
- */
-export default function getEmbedding(text: string, options?: {
-    model?: string;
-    apiKey?: string;
-    vertex?: boolean;
-    project?: string;
-    location?: string;
-    cache?: boolean;
-    ollama?: boolean | any;
-    verbose?: boolean;
-    contextWindow?: number;
-}): Promise<number[]>;
-//# sourceMappingURL=getEmbedding.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getEmbedding.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-ai/1.2.23/src/ai/getEmbedding.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAA8B,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,MAAM,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAwHzB"}

package/esm/deps/jsr.io/@nshiab/journalism-ai/1.2.23/src/ai/getEmbedding.js

@@ -1,166 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import process from "node:process";
-import { GoogleGenAI } from "@google/genai";
-import ollama, { Ollama } from "ollama";
-import crypto from "node:crypto";
-import { prettyDuration } from "../../../../journalism-format/1.1.9/src/index.js";
-/**
- * Generates a numerical embedding (vector representation) for a given text string. Embeddings are crucial for various natural language processing (NLP) tasks, including semantic search, text classification, clustering, and anomaly detection, as they allow text to be processed and compared mathematically.
- *
- * This function supports both Google's Gemini AI models and local models running with Ollama. It provides options for authentication, model selection, and caching to optimize performance and cost.
- *
- * **Authentication**:
- * Credentials and model information can be provided via environment variables (`AI_KEY`, `AI_PROJECT`, `AI_LOCATION`, `AI_EMBEDDINGS_MODEL`) or directly through the `options` object. Options take precedence over environment variables.
- *
- * **Local Models**:
- * To use a local model with Ollama, set the `OLLAMA` environment variable to `true` and ensure Ollama is running on your machine. You will also need to specify the model name using the `AI_EMBEDDINGS_MODEL` environment variable or the `model` option. If you want your Ollama instance to be used, you can pass an instance of the `Ollama` class as the `ollama` option.
- *
- * **Caching**:
- * To save resources and time, you can enable caching by setting `cache` to `true`. Responses will be stored in a local `.journalism-cache` directory. If the same request is made again, the cached response will be returned, avoiding redundant API calls. Remember to add `.journalism-cache` to your `.gitignore` file.
- *
- * @param text The input text string for which to generate the embedding.
- * @param options Configuration options for the embedding generation.
- * @param options.model The specific embedding model to use (e.g., 'text-embedding-004'). Defaults to the `AI_EMBEDDINGS_MODEL` environment variable.
- * @param options.apiKey Your API key for authentication with Google Gemini. Defaults to the `AI_KEY` environment variable.
- * @param options.vertex If `true`, uses Vertex AI for authentication. Defaults to `false`.
- * @param options.project Your Google Cloud project ID for Vertex AI. Defaults to the `AI_PROJECT` environment variable.
- * @param options.location The Google Cloud location for your Vertex AI project. Defaults to the `AI_LOCATION` environment variable.
- * @param options.cache If `true`, enables caching of the embedding response. Defaults to `false`.
- * @param options.ollama If `true`, uses Ollama for local embedding generation. Defaults to the `OLLAMA` environment variable. If you want your Ollama instance to be used, you can pass it here too.
- * @param options.verbose If `true`, logs additional information such as execution time and the truncated input text. Defaults to `false`.
- *   @param options.contextWindow - An option to specify the context window size for Ollama models. By default, Ollama sets this depending on the model, which can be lower than the actual maximum context window size of the model.
- *
- * @returns A promise that resolves to an an array of numbers representing the generated embedding.
- *
- * @example
- * ```ts
- * // Basic usage: Generate an embedding for a simple text.
- * const embedding = await getEmbedding("The quick brown fox jumps over the lazy dog.");
- * console.log(embedding); // [0.012, -0.034, ..., 0.056] (example output)
- * ```
- * @example
- * ```ts
- * // Generate an embedding with caching enabled.
- * const cachedEmbedding = await getEmbedding("Artificial intelligence is transforming industries.", { cache: true });
- * console.log(cachedEmbedding);
- * ```
- * @example
- * ```ts
- * // Generate an embedding using a specific model and API key.
- * const customEmbedding = await getEmbedding("Machine learning is a subset of AI.", {
- *   model: "another-embedding-model",
- *   apiKey: "your_custom_api_key"
- * });
- * console.log(customEmbedding);
- * ```
- * @example
- * ```ts
- * // Generate an embedding with verbose logging.
- * const verboseEmbedding = await getEmbedding("The quick brown fox jumps over the lazy dog.", { verbose: true });
- * console.log(verboseEmbedding);
- * ```
- * @category AI
- */
-export default async function getEmbedding(text, options = {}) {
-    const start = Date.now();
-    let client;
-    const ollamaVar = options.ollama === true ||
-        options.ollama instanceof Ollama || process.env.OLLAMA;
-    if (ollamaVar) {
-        client = options.ollama instanceof Ollama ? options.ollama : ollama;
-    }
-    else if (options.vertex || options.apiKey || options.project || options.location) {
-        client = new GoogleGenAI({
-            apiKey: options.apiKey,
-            vertexai: options.vertex,
-            project: options.project,
-            location: options.location,
-        });
-    }
-    else if (process.env.AI_PROJECT && process.env.AI_LOCATION) {
-        client = new GoogleGenAI({
-            vertexai: true,
-            project: process.env.AI_PROJECT,
-            location: process.env.AI_LOCATION,
-        });
-    }
-    else if (process.env.AI_KEY) {
-        client = new GoogleGenAI({
-            apiKey: process.env.AI_KEY,
-        });
-    }
-    if (!client) {
-        throw new Error("No API key or project/location or Ollama found. Please set AI_KEY, AI_PROJECT, AI_LOCATION or OLLAMA in your environment variables or pass them as options.");
-    }
-    const model = options.model ?? process.env.AI_EMBEDDINGS_MODEL;
-    if (!model) {
-        throw new Error("Model not specified. Use the AI_EMBEDDINGS_MODEL environment variable or pass it as an option.");
-    }
-    if (options.verbose) {
-        console.log(`\nText for ${model}:`);
-        console.log(text.length > 50 ? `${text.slice(0, 50)}...` : text);
-    }
-    const params = {
-        text,
-        model,
-    };
-    let cacheFileJSON;
-    if (options.cache) {
-        const cachePath = "./.journalism-cache";
-        if (!existsSync(cachePath)) {
-            mkdirSync(cachePath);
-        }
-        const hash = crypto
-            .createHash("sha256")
-            .update(JSON.stringify(params))
-            .digest("hex");
-        cacheFileJSON = `${cachePath}/getEmbedding-${hash}.json`;
-        if (existsSync(cacheFileJSON)) {
-            const cachedResponse = JSON.parse(readFileSync(cacheFileJSON, "utf-8"));
-            if (options.verbose) {
-                console.log("\nReturning cached JSON response.");
-            }
-            return cachedResponse;
-        }
-        else {
-            if (options.verbose) {
-                console.log("\nCache missed. Generating new response...");
-            }
-        }
-    }
-    const response = client instanceof GoogleGenAI
-        ? await client.models.embedContent({ model, contents: text })
-        : await client.embed({
-            model,
-            input: text,
-            options: {
-                num_ctx: options.contextWindow,
-            },
-        });
-    let returnedResponse;
-    const rawResponse = response.embeddings;
-    if (!rawResponse) {
-        throw new Error("Invalid response from the API. Please check your model and input.");
-    }
-    if (Array.isArray(rawResponse[0]["values"])) {
-        returnedResponse = rawResponse[0]["values"];
-    }
-    else {
-        returnedResponse = rawResponse[0];
-    }
-    if (!Array.isArray(returnedResponse) || typeof returnedResponse[0] !== "number") {
-        throw new Error("Invalid response from the API. Please check your model and input.");
-    }
-    if (options.cache && cacheFileJSON) {
-        if (returnedResponse && Array.isArray(returnedResponse)) {
-            writeFileSync(cacheFileJSON, JSON.stringify(returnedResponse));
-            if (options.verbose) {
-                console.log("Response cached as JSON.");
-            }
-        }
-    }
-    if (options.verbose) {
-        console.log("Execution time:", prettyDuration(start));
-    }
-    return returnedResponse;
-}

package/esm/deps/jsr.io/@nshiab/journalism-ai/1.2.23/src/ai/helpers/sleep.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@nshiab/journalism-ai/1.2.23/src/ai/helpers/sleep.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAWf"}