@germanescobar/anita 0.3.0

package/dist/models/openai.js

@@ -0,0 +1,330 @@
+import OpenAI from "openai";
+import { conversationItemsToMessages } from "../types/conversation.js";
+export class OpenAIProvider {
+    client;
+    model;
+    maxTokens;
+    openRouter;
+    constructor(model, options) {
+        this.client = new OpenAI({
+            apiKey: options?.apiKey ?? process.env.OPENAI_API_KEY ?? "not-needed",
+            baseURL: options?.baseURL,
+        });
+        this.model = model;
+        this.maxTokens = options?.maxTokens;
+        this.openRouter = options?.openRouter ?? false;
+    }
+    async chat(params) {
+        const messages = this.toOpenAIMessages(params.systemPrompt, conversationItemsToMessages(params.conversationItems));
+        const tools = params.tools.map((t) => this.toOpenAITool(t));
+        const request = this.withOpenRouterSessionId({
+            model: this.model,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+            max_tokens: this.maxTokens,
+        }, params);
+        const response = await this.client.chat.completions.create(request, {
+            signal: params.signal,
+        });
+        const choice = response.choices[0];
+        if (!choice) {
+            return { stopReason: "error", content: [{ type: "text", text: "No response from model" }] };
+        }
+        const content = this.fromOpenAIMessage(choice.message);
+        const stopReason = choice.finish_reason === "tool_calls" ? "tool_use" : "end_turn";
+        return {
+            stopReason,
+            content,
+            reasoning: this.extractReasoning(choice.message),
+            usage: response.usage
+                ? this.mapUsage(response.usage)
+                : undefined,
+        };
+    }
+    async *streamChat(params) {
+        const messages = this.toOpenAIMessages(params.systemPrompt, conversationItemsToMessages(params.conversationItems));
+        const tools = params.tools.map((t) => this.toOpenAITool(t));
+        const streamParams = this.withOpenRouterSessionId({
+            model: this.model,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+            max_tokens: this.maxTokens,
+            stream: true,
+            stream_options: { include_usage: true },
+        }, params);
+        const stream = await this.createChatCompletionStream(streamParams, params.signal);
+        let text = "";
+        let reasoning = "";
+        let stopReason = "end_turn";
+        let usage;
+        const toolCalls = new Map();
+        for await (const chunk of stream) {
+            if (chunk.usage) {
+                usage = this.mapUsage(chunk.usage);
+            }
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            const delta = choice.delta;
+            if (delta.content) {
+                text += delta.content;
+                yield { type: "assistant_text_delta", text: delta.content };
+            }
+            const reasoningDelta = this.extractReasoningDelta(delta);
+            if (reasoningDelta) {
+                reasoning += reasoningDelta;
+                yield { type: "assistant_reasoning_delta", text: reasoningDelta };
+            }
+            for (const toolCall of delta.tool_calls ?? []) {
+                const existing = toolCalls.get(toolCall.index) ?? { arguments: "" };
+                if (toolCall.id)
+                    existing.id = toolCall.id;
+                if (toolCall.function?.name)
+                    existing.name = toolCall.function.name;
+                if (toolCall.function?.arguments) {
+                    existing.arguments += toolCall.function.arguments;
+                }
+                toolCalls.set(toolCall.index, existing);
+                yield {
+                    type: "tool_call_delta",
+                    index: toolCall.index,
+                    id: existing.id,
+                    name: existing.name,
+                    inputDelta: toolCall.function?.arguments,
+                };
+            }
+            if (choice.finish_reason) {
+                stopReason = this.mapFinishReason(choice.finish_reason);
+            }
+        }
+        const content = [];
+        if (text) {
+            content.push({ type: "text", text });
+        }
+        for (const [, toolCall] of [...toolCalls].sort(([left], [right]) => left - right)) {
+            if (!toolCall.id || !toolCall.name)
+                continue;
+            content.push({
+                type: "tool_use",
+                id: toolCall.id,
+                name: toolCall.name,
+                input: this.parseToolArguments(toolCall.arguments),
+            });
+        }
+        yield {
+            type: "response",
+            response: {
+                stopReason,
+                content,
+                reasoning: reasoning || undefined,
+                usage,
+            },
+        };
+    }
+    withOpenRouterSessionId(request, params) {
+        if (!this.openRouter || !params.sessionId)
+            return request;
+        if (params.sessionId.length > 256) {
+            throw new Error("OpenRouter session_id must be at most 256 characters.");
+        }
+        return { ...request, session_id: params.sessionId };
+    }
+    mapUsage(usage) {
+        const result = {
+            inputTokens: usage.prompt_tokens,
+            outputTokens: usage.completion_tokens,
+        };
+        const cachedTokens = usage.prompt_tokens_details?.cached_tokens;
+        const cacheWriteTokens = usage.prompt_tokens_details?.cache_write_tokens;
+        if (typeof cachedTokens === "number") {
+            result.cachedTokens = cachedTokens;
+        }
+        if (typeof cacheWriteTokens === "number") {
+            result.cacheWriteTokens = cacheWriteTokens;
+        }
+        return result;
+    }
+    async createChatCompletionStream(params, signal) {
+        try {
+            return await this.client.chat.completions.create(params, { signal });
+        }
+        catch (err) {
+            if (!this.isUnsupportedStreamOptionsError(err)) {
+                throw err;
+            }
+            const { stream_options: _streamOptions, ...fallbackParams } = params;
+            return this.client.chat.completions.create(fallbackParams, { signal });
+        }
+    }
+    toOpenAIMessages(systemPrompt, messages) {
+        const result = [
+            { role: "system", content: systemPrompt },
+        ];
+        for (const msg of messages) {
+            if (typeof msg.content === "string") {
+                result.push({ role: msg.role, content: msg.content });
+                continue;
+            }
+            if (msg.role === "assistant") {
+                const textParts = msg.content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("");
+                const toolCalls = msg.content
+                    .filter((b) => b.type === "tool_use")
+                    .map((b) => {
+                    const block = b;
+                    return {
+                        id: block.id,
+                        type: "function",
+                        function: {
+                            name: block.name,
+                            arguments: JSON.stringify(block.input),
+                        },
+                    };
+                });
+                // Some providers (e.g. Ollama OpenAI-compatible endpoints) reject
+                // assistant messages with null/empty content and no tool calls.
+                if (!textParts && toolCalls.length === 0) {
+                    continue;
+                }
+                result.push({
+                    role: "assistant",
+                    content: textParts || "",
+                    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                });
+            }
+            else {
+                // User messages may contain tool_result and attachment blocks.
+                const toolResults = msg.content.filter((b) => b.type === "tool_result");
+                const contentParts = msg.content.filter((b) => b.type === "text" || b.type === "image" || b.type === "file");
+                for (const block of toolResults) {
+                    const tr = block;
+                    result.push({
+                        role: "tool",
+                        tool_call_id: tr.toolUseId,
+                        content: tr.content,
+                    });
+                }
+                if (contentParts.length > 0) {
+                    result.push({
+                        role: "user",
+                        content: this.toOpenAIUserContent(contentParts),
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    toOpenAITool(tool) {
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            },
+        };
+    }
+    toOpenAIUserContent(blocks) {
+        if (blocks.every((block) => block.type === "text")) {
+            return blocks.map((block) => block.text).join("\n");
+        }
+        return blocks.map((block) => {
+            switch (block.type) {
+                case "text":
+                    return { type: "text", text: block.text };
+                case "image":
+                    return {
+                        type: "image_url",
+                        image_url: {
+                            url: this.attachmentUrl(block),
+                        },
+                    };
+                case "file":
+                    return {
+                        type: "file",
+                        file: {
+                            filename: block.name,
+                            file_data: this.attachmentUrl(block),
+                        },
+                    };
+            }
+        });
+    }
+    attachmentUrl(block) {
+        if (block.source.type === "url")
+            return block.source.url;
+        return `data:${block.source.mediaType};base64,${block.source.data}`;
+    }
+    fromOpenAIMessage(message) {
+        const blocks = [];
+        if (message.content) {
+            blocks.push({ type: "text", text: message.content });
+        }
+        if (message.tool_calls) {
+            for (const call of message.tool_calls) {
+                blocks.push({
+                    type: "tool_use",
+                    id: call.id,
+                    name: call.function.name,
+                    input: this.parseToolArguments(call.function.arguments),
+                });
+            }
+        }
+        return blocks;
+    }
+    extractReasoning(message) {
+        const reasoningMessage = message;
+        const candidate = reasoningMessage.reasoning_content ?? reasoningMessage.reasoning;
+        if (candidate == null)
+            return undefined;
+        if (typeof candidate === "string")
+            return candidate;
+        try {
+            return JSON.stringify(candidate);
+        }
+        catch {
+            return String(candidate);
+        }
+    }
+    extractReasoningDelta(delta) {
+        const reasoningDelta = delta;
+        const candidate = reasoningDelta.reasoning_content ?? reasoningDelta.reasoning;
+        if (candidate == null)
+            return undefined;
+        return typeof candidate === "string" ? candidate : String(candidate);
+    }
+    mapFinishReason(finishReason) {
+        switch (finishReason) {
+            case "tool_calls":
+            case "function_call":
+                return "tool_use";
+            case "length":
+                return "max_tokens";
+            case "content_filter":
+                return "error";
+            default:
+                return "end_turn";
+        }
+    }
+    parseToolArguments(inputJson) {
+        if (!inputJson)
+            return {};
+        try {
+            const parsed = JSON.parse(inputJson);
+            return this.isRecord(parsed) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    isRecord(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    isUnsupportedStreamOptionsError(err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return (message.includes("stream_options") ||
+            message.includes("include_usage"));
+    }
+}

package/dist/models/provider.d.ts

@@ -0,0 +1,33 @@
+import type { ConversationItem } from "../types/conversation.js";
+import type { Message } from "../types/messages.js";
+import type { ToolSchema } from "../types/tools.js";
+import type { ModelResponse } from "../types/agent.js";
+export interface ChatParams {
+    systemPrompt: string;
+    sessionId?: string;
+    conversationItems: ConversationItem[];
+    messages?: Message[];
+    tools: ToolSchema[];
+    /** Aborts the in-flight model request/stream when the run is cancelled. */
+    signal?: AbortSignal;
+}
+export interface ModelProvider {
+    chat(params: ChatParams): Promise<ModelResponse>;
+    streamChat?(params: ChatParams): AsyncIterable<ModelStreamEvent>;
+}
+export type ModelStreamEvent = {
+    type: "assistant_text_delta";
+    text: string;
+} | {
+    type: "assistant_reasoning_delta";
+    text: string;
+} | {
+    type: "tool_call_delta";
+    index: number;
+    id?: string;
+    name?: string;
+    inputDelta?: string;
+} | {
+    type: "response";
+    response: ModelResponse;
+};

package/dist/models/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/models/resolve.d.ts

@@ -0,0 +1,48 @@
+import type { ModelProvider } from "./provider.js";
+export declare const OLLAMA_CLOUD_MODELS: readonly ["glm-5.2", "minimax-m3", "deepseek-v4-pro", "kimi-k2.7-code"];
+export type ModelOptionGroupName = "Ollama Local" | "Ollama Cloud" | "OpenRouter";
+export interface ModelOption {
+    label: string;
+    value: string;
+    group: ModelOptionGroupName;
+    contextWindowTokens: number;
+    capabilities?: ModelCapabilities;
+}
+export interface ModelCapabilities {
+    attachments?: AttachmentCapabilities;
+}
+export interface AttachmentCapabilities {
+    images: boolean;
+    files: boolean;
+}
+export declare const MODEL_OPTIONS: readonly ModelOption[];
+export interface ModelOptionGroup {
+    group: ModelOptionGroupName;
+    options: ModelOption[];
+}
+export interface ModelOptionsResult {
+    options: ModelOption[];
+    ollamaDiscoveryFailed: boolean;
+}
+export interface ResolvedModel {
+    provider: string;
+    model: string;
+}
+export type ProviderConfig = {
+    type: "openai-compatible";
+    provider: string;
+    model: string;
+    contextWindowTokens: number;
+    apiKey?: string;
+    baseURL?: string;
+    maxTokens?: number;
+    openRouter?: boolean;
+};
+export declare function parseModelString(modelString: string): ResolvedModel;
+export declare function groupModelOptions(options?: readonly ModelOption[]): ModelOptionGroup[];
+export declare function getModelOptions(fetchImpl?: typeof fetch): Promise<ModelOptionsResult>;
+export declare function discoverLocalOllamaModelOptions(fetchImpl?: typeof fetch): Promise<ModelOption[] | undefined>;
+export declare function getModelContextWindowTokens(modelString: string): number;
+export declare function getModelCapabilities(modelString: string): ModelCapabilities;
+export declare function resolveProviderConfig(modelString: string): ProviderConfig;
+export declare function createProvider(modelString: string): ModelProvider;

package/dist/models/resolve.js

@@ -0,0 +1,211 @@
+import { OpenAIProvider } from "./openai.js";
+const OLLAMA_BASE_URL = "http://localhost:11434/v1";
+const OLLAMA_TAGS_URL = "http://localhost:11434/api/tags";
+const OLLAMA_CLOUD_BASE_URL = "https://ollama.com/v1";
+const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+const OLLAMA_DISCOVERY_TIMEOUT_MS = 1_000;
+const OLLAMA_CLOUD_MAX_TOKENS = 8_192;
+const UNKNOWN_MODEL_CONTEXT_WINDOW_TOKENS = 128_000;
+const GLM_CONTEXT_WINDOW_TOKENS = 198_000;
+const GLM_5_2_CONTEXT_WINDOW_TOKENS = 976_000;
+const DEEPSEEK_V4_PRO_CONTEXT_WINDOW_TOKENS = 1_000_000;
+const KIMI_K2_CONTEXT_WINDOW_TOKENS = 256_000;
+const MINIMAX_M3_OLLAMA_CONTEXT_WINDOW_TOKENS = 512_000;
+const MINIMAX_M3_OPENROUTER_CONTEXT_WINDOW_TOKENS = 1_000_000;
+export const OLLAMA_CLOUD_MODELS = [
+    "glm-5.2",
+    "minimax-m3",
+    "deepseek-v4-pro",
+    "kimi-k2.7-code",
+];
+const OLLAMA_CLOUD_CONTEXT_WINDOWS = {
+    "glm-5.2": GLM_5_2_CONTEXT_WINDOW_TOKENS,
+    "minimax-m3": MINIMAX_M3_OLLAMA_CONTEXT_WINDOW_TOKENS,
+    "deepseek-v4-pro": DEEPSEEK_V4_PRO_CONTEXT_WINDOW_TOKENS,
+    "kimi-k2.7-code": KIMI_K2_CONTEXT_WINDOW_TOKENS,
+};
+export const MODEL_OPTIONS = [
+    {
+        label: "GLM 4.7 Flash (local)",
+        value: "ollama/glm-4.7-flash:latest",
+        group: "Ollama Local",
+        contextWindowTokens: GLM_CONTEXT_WINDOW_TOKENS,
+    },
+    {
+        label: "GLM 5.1 (OpenRouter)",
+        value: "openrouter/z-ai/glm-5.1",
+        group: "OpenRouter",
+        contextWindowTokens: GLM_CONTEXT_WINDOW_TOKENS,
+        capabilities: { attachments: { images: false, files: true } },
+    },
+    {
+        label: "MiniMax M3 (OpenRouter)",
+        value: "openrouter/minimax/minimax-m3",
+        group: "OpenRouter",
+        contextWindowTokens: MINIMAX_M3_OPENROUTER_CONTEXT_WINDOW_TOKENS,
+        capabilities: { attachments: { images: true, files: true } },
+    },
+    {
+        label: "DeepSeek V4 Pro (OpenRouter)",
+        value: "openrouter/deepseek/deepseek-v4-pro",
+        group: "OpenRouter",
+        contextWindowTokens: DEEPSEEK_V4_PRO_CONTEXT_WINDOW_TOKENS,
+        capabilities: { attachments: { images: false, files: true } },
+    },
+    {
+        label: "Kimi K2.6 (OpenRouter)",
+        value: "openrouter/moonshotai/kimi-k2.6",
+        group: "OpenRouter",
+        contextWindowTokens: KIMI_K2_CONTEXT_WINDOW_TOKENS,
+        capabilities: { attachments: { images: true, files: true } },
+    },
+    ...OLLAMA_CLOUD_MODELS.map((model) => ({
+        label: `${model} (cloud)`,
+        value: `ollama-cloud/${model}`,
+        group: "Ollama Cloud",
+        contextWindowTokens: OLLAMA_CLOUD_CONTEXT_WINDOWS[model],
+        ...(model === "minimax-m3"
+            ? { capabilities: { attachments: { images: true, files: true } } }
+            : {}),
+        ...(model === "kimi-k2.7-code"
+            ? { capabilities: { attachments: { images: true, files: false } } }
+            : {}),
+    })),
+];
+export function parseModelString(modelString) {
+    const slashIndex = modelString.indexOf("/");
+    if (slashIndex === -1) {
+        throw new Error(`Invalid model format: "${modelString}". Expected "provider/model" (e.g., "ollama/glm-4.7-flash:latest")`);
+    }
+    return {
+        provider: modelString.slice(0, slashIndex),
+        model: modelString.slice(slashIndex + 1),
+    };
+}
+export function groupModelOptions(options = MODEL_OPTIONS) {
+    const groups = [];
+    for (const option of options) {
+        let group = groups.find((item) => item.group === option.group);
+        if (!group) {
+            group = { group: option.group, options: [] };
+            groups.push(group);
+        }
+        group.options.push(option);
+    }
+    return groups;
+}
+export async function getModelOptions(fetchImpl = fetch) {
+    const discoveredOllamaOptions = await discoverLocalOllamaModelOptions(fetchImpl);
+    const staticValues = new Set(MODEL_OPTIONS.map((option) => option.value));
+    const dynamicOptions = (discoveredOllamaOptions ?? []).filter((option) => !staticValues.has(option.value));
+    return {
+        options: [...MODEL_OPTIONS, ...dynamicOptions],
+        ollamaDiscoveryFailed: discoveredOllamaOptions === undefined,
+    };
+}
+export async function discoverLocalOllamaModelOptions(fetchImpl = fetch) {
+    try {
+        const response = await fetchImpl(OLLAMA_TAGS_URL, {
+            signal: AbortSignal.timeout(OLLAMA_DISCOVERY_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return undefined;
+        const payload = await response.json();
+        return parseOllamaModelNames(payload).map((name) => ({
+            label: `${name} (local)`,
+            value: `ollama/${name}`,
+            group: "Ollama Local",
+            contextWindowTokens: UNKNOWN_MODEL_CONTEXT_WINDOW_TOKENS,
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseOllamaModelNames(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload.models))
+        return [];
+    return payload.models
+        .map((model) => {
+        if (!isRecord(model))
+            return undefined;
+        const name = model.name ?? model.model;
+        return typeof name === "string" && name.length > 0 ? name : undefined;
+    })
+        .filter((name) => name !== undefined)
+        .sort((left, right) => left.localeCompare(right));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function assertSupportedOllamaCloudModel(model) {
+    if (OLLAMA_CLOUD_MODELS.includes(model))
+        return;
+    throw new Error(`Unsupported Ollama Cloud model: "${model}". Supported: ${OLLAMA_CLOUD_MODELS.join(", ")}`);
+}
+export function getModelContextWindowTokens(modelString) {
+    return (MODEL_OPTIONS.find((option) => option.value === modelString)
+        ?.contextWindowTokens ?? UNKNOWN_MODEL_CONTEXT_WINDOW_TOKENS);
+}
+export function getModelCapabilities(modelString) {
+    const option = MODEL_OPTIONS.find((item) => item.value === modelString);
+    if (option?.capabilities)
+        return option.capabilities;
+    const { provider } = parseModelString(modelString);
+    if (provider === "openrouter") {
+        return { attachments: { images: false, files: true } };
+    }
+    return {};
+}
+export function resolveProviderConfig(modelString) {
+    const { provider, model } = parseModelString(modelString);
+    const contextWindowTokens = getModelContextWindowTokens(modelString);
+    switch (provider) {
+        case "ollama":
+            return {
+                type: "openai-compatible",
+                provider,
+                model,
+                contextWindowTokens,
+                baseURL: OLLAMA_BASE_URL,
+            };
+        case "ollama-cloud":
+            assertSupportedOllamaCloudModel(model);
+            if (!process.env.OLLAMA_API_KEY) {
+                throw new Error("OLLAMA_API_KEY is required for ollama-cloud models. Set OLLAMA_API_KEY and try again.");
+            }
+            return {
+                type: "openai-compatible",
+                provider,
+                model,
+                contextWindowTokens,
+                apiKey: process.env.OLLAMA_API_KEY,
+                baseURL: OLLAMA_CLOUD_BASE_URL,
+                maxTokens: OLLAMA_CLOUD_MAX_TOKENS,
+            };
+        case "openrouter":
+            if (!process.env.OPENROUTER_API_KEY) {
+                throw new Error("OPENROUTER_API_KEY is required for openrouter models. Set OPENROUTER_API_KEY and try again.");
+            }
+            return {
+                type: "openai-compatible",
+                provider,
+                model,
+                contextWindowTokens,
+                apiKey: process.env.OPENROUTER_API_KEY,
+                baseURL: OPENROUTER_BASE_URL,
+                openRouter: true,
+            };
+        default:
+            throw new Error(`Unknown provider: "${provider}". Supported: ollama, ollama-cloud, openrouter`);
+    }
+}
+export function createProvider(modelString) {
+    const config = resolveProviderConfig(modelString);
+    return new OpenAIProvider(config.model, {
+        apiKey: config.apiKey,
+        baseURL: config.baseURL,
+        maxTokens: config.maxTokens,
+        openRouter: config.openRouter,
+    });
+}

package/dist/security/sensitive-content.d.ts

@@ -0,0 +1,6 @@
+export interface SensitiveContentFinding {
+    label: string;
+}
+export declare function detectSensitiveContent(content: string): SensitiveContentFinding[];
+export declare function containsSensitiveContent(content: string): boolean;
+export declare function redactSensitiveContent(content: string): string;

package/dist/security/sensitive-content.js

@@ -0,0 +1,59 @@
+const SENSITIVE_PATTERNS = [
+    {
+        label: "secret assignment",
+        pattern: /\b[A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PASSWD|PRIVATE[_-]?KEY)[A-Z0-9_]*\s*[:=]\s*["']?[^\s"']{8,}["']?/gi,
+    },
+    {
+        label: "private key",
+        pattern: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+    },
+    {
+        label: "GitHub token",
+        pattern: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{30,255}\b/g,
+    },
+    {
+        label: "GitHub fine-grained token",
+        pattern: /\bgithub_pat_[A-Za-z0-9_]{20,255}\b/g,
+    },
+    {
+        label: "OpenAI API key",
+        pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,255}\b/g,
+    },
+    {
+        label: "Anthropic API key",
+        pattern: /\bsk-ant-[A-Za-z0-9_-]{20,255}\b/g,
+    },
+    {
+        label: "AWS access key",
+        pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g,
+    },
+    {
+        label: "Slack token",
+        pattern: /\bxox[baprs]-[A-Za-z0-9-]{20,255}\b/g,
+    },
+    {
+        label: "JWT",
+        pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+    },
+];
+export function detectSensitiveContent(content) {
+    const labels = new Set();
+    for (const sensitivePattern of SENSITIVE_PATTERNS) {
+        sensitivePattern.pattern.lastIndex = 0;
+        if (sensitivePattern.pattern.test(content)) {
+            labels.add(sensitivePattern.label);
+        }
+    }
+    return [...labels].map((label) => ({ label }));
+}
+export function containsSensitiveContent(content) {
+    return detectSensitiveContent(content).length > 0;
+}
+export function redactSensitiveContent(content) {
+    let redacted = content;
+    for (const sensitivePattern of SENSITIVE_PATTERNS) {
+        sensitivePattern.pattern.lastIndex = 0;
+        redacted = redacted.replace(sensitivePattern.pattern, `[REDACTED: ${sensitivePattern.label}]`);
+    }
+    return redacted;
+}