@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/ai/opencode-provider.js

@@ -0,0 +1,332 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import os from "node:os";
+import { generateText, Output } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createMinimax, createMinimaxOpenAI } from "vercel-minimax-ai-provider";
+// --- State (set from plugin init in index.ts, Task 4) ---
+let _statePath = null;
+let _connectedProviders = [];
+export function setStatePath(path) {
+    _statePath = path;
+}
+export function getStatePath() {
+    if (!_statePath) {
+        throw new Error("opencode state path not initialized. Plugin may not be fully started.");
+    }
+    return _statePath;
+}
+// Provider name aliases mapping
+const PROVIDER_ALIASES = {
+    "MiniMax Coding Plan (minimaxi.com)": "minimax-cn-coding-plan",
+    "MiniMax (minimaxi.com)": "minimax",
+    "MiniMax Coding Plan (minimax.io)": "minimax-coding-plan",
+};
+// Reverse mapping: internal name -> opencode display name
+const ALIASES_REVERSE = {
+    "minimax-cn-coding-plan": "MiniMax Coding Plan (minimaxi.com)",
+    "minimax": "MiniMax (minimaxi.com)",
+    "minimax-coding-plan": "MiniMax Coding Plan (minimax.io)",
+};
+export function setConnectedProviders(providers) {
+    let validProviders = [];
+    if (Array.isArray(providers)) {
+        validProviders = providers.filter(p => typeof p === "string");
+    }
+    else if (typeof providers === "string") {
+        try {
+            const parsed = JSON.parse(providers);
+            validProviders = Array.isArray(parsed) ? parsed.filter(p => typeof p === "string") : [];
+        }
+        catch {
+            validProviders = [];
+        }
+    }
+    _connectedProviders = validProviders;
+}
+export function isProviderConnected(providerName) {
+    if (providerName.includes("minimax") || providerName.includes("MiniMax")) {
+        const homeDir = os.homedir();
+        const authPath = join(homeDir, ".local", "share", "opencode", "auth.json");
+        try {
+            if (existsSync(authPath)) {
+                const authContent = readFileSync(authPath, "utf-8");
+                const auth = JSON.parse(authContent);
+                const keys = Object.keys(auth);
+                const hasMinimax = keys.some(k => k.toLowerCase().includes("minimax"));
+                return hasMinimax;
+            }
+        }
+        catch { }
+    }
+    if (_connectedProviders.includes(providerName)) {
+        return true;
+    }
+    for (const connected of _connectedProviders) {
+        if (PROVIDER_ALIASES[connected] === providerName) {
+            return true;
+        }
+    }
+    const reverseMatch = ALIASES_REVERSE[providerName];
+    if (reverseMatch && _connectedProviders.includes(reverseMatch)) {
+        return true;
+    }
+    return false;
+}
+// --- Auth ---
+function findAuthJsonPath(statePath) {
+    const homeDir = os.homedir();
+    const candidates = [
+        join(statePath, "auth.json"),
+        join(dirname(dirname(statePath)), "share", "opencode", "auth.json"),
+        join(statePath.replace("/state/", "/share/"), "auth.json"),
+        join(statePath.replace("\\state\\", "\\share\\"), "auth.json"),
+        // 全局 auth.json 路径 (Linux/macOS: ~/.local/share/opencode/auth.json, Windows: %USERPROFILE%/.local/share/opencode/auth.json)
+        join(homeDir, ".local", "share", "opencode", "auth.json"),
+        // Windows 可能的全局路径
+        join(homeDir, ".config", "opencode", "auth.json"),
+    ];
+    return candidates.find(existsSync);
+}
+export function readOpencodeAuth(statePath, providerName) {
+    const authPath = findAuthJsonPath(statePath);
+    let raw;
+    if (authPath) {
+        try {
+            raw = readFileSync(authPath, "utf-8");
+        }
+        catch { }
+    }
+    if (!raw || !authPath) {
+        throw new Error(`opencode auth.json not found at ${authPath ?? statePath}. Is opencode authenticated?`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Failed to read opencode auth.json: invalid JSON`);
+    }
+    let auth = parsed[providerName];
+    if (!auth) {
+        const reverseKey = ALIASES_REVERSE[providerName];
+        if (reverseKey) {
+            auth = parsed[reverseKey];
+        }
+    }
+    if (!auth) {
+        for (const [authKey, internalName] of Object.entries(PROVIDER_ALIASES)) {
+            if (internalName === providerName && parsed[authKey]) {
+                auth = parsed[authKey];
+                break;
+            }
+        }
+    }
+    if (!auth) {
+        const connected = Object.keys(parsed).join(", ") || "none";
+        throw new Error(`Provider '${providerName}' not found in opencode auth.json. Connected providers: ${connected}`);
+    }
+    return auth;
+}
+// --- OAuth Fetch ---
+const OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const OAUTH_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+const OAUTH_REQUIRED_BETAS = ["oauth-2025-04-20", "interleaved-thinking-2025-05-14"];
+const MCP_TOOL_PREFIX = "mcp_";
+export function createOAuthFetch(statePath, providerName) {
+    return async (input, init) => {
+        let auth = readOpencodeAuth(statePath, providerName);
+        // Refresh token if expired
+        if (!auth.access || auth.expires < Date.now()) {
+            const refreshResponse = await fetch(OAUTH_TOKEN_URL, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    grant_type: "refresh_token",
+                    refresh_token: auth.refresh,
+                    client_id: OAUTH_CLIENT_ID,
+                }),
+            });
+            if (!refreshResponse.ok) {
+                throw new Error(`OAuth token refresh failed: ${refreshResponse.status}`);
+            }
+            const json = (await refreshResponse.json());
+            auth = {
+                type: "oauth",
+                refresh: json.refresh_token,
+                access: json.access_token,
+                expires: Date.now() + json.expires_in * 1000,
+            };
+            const authPath = findAuthJsonPath(statePath);
+            if (authPath) {
+                try {
+                    const allAuth = JSON.parse(readFileSync(authPath, "utf-8"));
+                    allAuth[providerName] = auth;
+                    writeFileSync(authPath, JSON.stringify(allAuth));
+                }
+                catch { }
+            }
+        }
+        // Build headers
+        const requestInit = init ?? {};
+        const requestHeaders = new Headers();
+        if (input instanceof Request) {
+            input.headers.forEach((value, key) => requestHeaders.set(key, value));
+        }
+        if (requestInit.headers) {
+            if (requestInit.headers instanceof Headers) {
+                requestInit.headers.forEach((value, key) => requestHeaders.set(key, value));
+            }
+            else if (Array.isArray(requestInit.headers)) {
+                for (const pair of requestInit.headers) {
+                    const [key, value] = pair;
+                    if (typeof value !== "undefined")
+                        requestHeaders.set(key, value);
+                }
+            }
+            else {
+                for (const [key, value] of Object.entries(requestInit.headers)) {
+                    if (typeof value !== "undefined")
+                        requestHeaders.set(key, String(value));
+                }
+            }
+        }
+        // Merge beta headers
+        const incomingBeta = requestHeaders.get("anthropic-beta") ?? "";
+        const incomingBetas = incomingBeta
+            .split(",")
+            .map((b) => b.trim())
+            .filter(Boolean);
+        const mergedBetas = [...new Set([...OAUTH_REQUIRED_BETAS, ...incomingBetas])].join(",");
+        requestHeaders.set("authorization", `Bearer ${auth.access}`);
+        requestHeaders.set("anthropic-beta", mergedBetas);
+        requestHeaders.set("user-agent", "claude-cli/2.1.2 (external, cli)");
+        requestHeaders.delete("x-api-key");
+        // Prefix tool names in request body
+        let body = requestInit.body;
+        if (body && typeof body === "string") {
+            try {
+                const parsed = JSON.parse(body);
+                if (parsed.tools && Array.isArray(parsed.tools)) {
+                    parsed.tools = parsed.tools.map((tool) => ({
+                        ...tool,
+                        name: tool.name ? `${MCP_TOOL_PREFIX}${tool.name}` : tool.name,
+                    }));
+                }
+                if (parsed.messages && Array.isArray(parsed.messages)) {
+                    parsed.messages = parsed.messages.map((msg) => {
+                        if (msg.content && Array.isArray(msg.content)) {
+                            msg.content = msg.content.map((block) => {
+                                if (block.type === "tool_use" && block.name) {
+                                    return { ...block, name: `${MCP_TOOL_PREFIX}${block.name}` };
+                                }
+                                return block;
+                            });
+                        }
+                        return msg;
+                    });
+                }
+                body = JSON.stringify(parsed);
+            }
+            catch { }
+        }
+        // Modify URL: add ?beta=true to /v1/messages
+        let requestInput = input;
+        try {
+            let requestUrl = null;
+            if (typeof input === "string" || input instanceof URL) {
+                requestUrl = new URL(input.toString());
+            }
+            else if (input instanceof Request) {
+                requestUrl = new URL(input.url);
+            }
+            if (requestUrl?.pathname === "/v1/messages" && !requestUrl.searchParams.has("beta")) {
+                requestUrl.searchParams.set("beta", "true");
+                requestInput =
+                    input instanceof Request ? new Request(requestUrl.toString(), input) : requestUrl;
+            }
+        }
+        catch { }
+        const response = await fetch(requestInput, { ...requestInit, body, headers: requestHeaders });
+        // Strip mcp_ prefix from tool names in streaming response
+        if (response.body) {
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            const encoder = new TextEncoder();
+            const stream = new ReadableStream({
+                async pull(controller) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                    let text = decoder.decode(value, { stream: true });
+                    text = text.replace(/"name"\s*:\s*"mcp_([^"]+)"/g, '"name": "$1"');
+                    controller.enqueue(encoder.encode(text));
+                },
+            });
+            return new Response(stream, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
+        }
+        return response;
+    };
+}
+// --- Provider ---
+export function createOpencodeAIProvider(providerName, auth, statePath) {
+    if (providerName === "anthropic") {
+        if (auth.type === "oauth") {
+            if (!statePath)
+                throw new Error("statePath is required for OAuth authentication");
+            return createAnthropic({
+                apiKey: "",
+                fetch: createOAuthFetch(statePath, providerName),
+            });
+        }
+        return createAnthropic({ apiKey: auth.key });
+    }
+    if (providerName === "openai") {
+        if (auth.type === "oauth") {
+            throw new Error("OpenAI does not support OAuth authentication. Use an API key instead.");
+        }
+        return createOpenAI({ apiKey: auth.key });
+    }
+    if (providerName === "minimax") {
+        if (auth.type === "oauth") {
+            throw new Error("Minimax does not support OAuth authentication. Use an API key instead.");
+        }
+        return createMinimaxOpenAI({ apiKey: auth.key });
+    }
+    if (providerName === "minimax-cn-coding-plan") {
+        if (auth.type === "oauth") {
+            throw new Error("Minimax does not support OAuth authentication. Use an API key instead.");
+        }
+        return createMinimax({
+            apiKey: auth.key,
+            baseURL: "https://api.minimaxi.com/anthropic/v1"
+        });
+    }
+    if (providerName === "minimax-cn") {
+        if (auth.type === "oauth") {
+            throw new Error("Minimax does not support OAuth authentication. Use an API key instead.");
+        }
+        return createMinimaxOpenAI({ apiKey: auth.key });
+    }
+    throw new Error(`Unsupported opencode provider: '${providerName}'. Supported providers: anthropic, openai, minimax, minimax-cn-coding-plan, minimax-cn`);
+}
+// --- Structured Output ---
+export async function generateStructuredOutput(options) {
+    const auth = readOpencodeAuth(options.statePath, options.providerName);
+    const provider = createOpencodeAIProvider(options.providerName, auth, options.statePath);
+    const result = await generateText({
+        model: provider(options.modelId),
+        system: options.systemPrompt,
+        prompt: options.userPrompt,
+        output: Output.object({ schema: options.schema }),
+        temperature: options.temperature ?? 0.3,
+    });
+    return result.output;
+}

package/dist/services/ai/provider-config.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderConfig } from "./providers/base-provider.js";
+interface MemoryProviderRuntimeConfig {
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
+    memoryTemperature?: number | false;
+    memoryExtraParams?: Record<string, unknown>;
+    autoCaptureMaxIterations?: number;
+    autoCaptureIterationTimeout?: number;
+}
+interface ProviderConfigOverrides {
+    maxIterations?: number;
+    iterationTimeout?: number;
+}
+export declare function buildMemoryProviderConfig(config: MemoryProviderRuntimeConfig, overrides?: ProviderConfigOverrides): ProviderConfig;
+export {};
+//# sourceMappingURL=provider-config.d.ts.map

package/dist/services/ai/provider-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-config.d.ts","sourceRoot":"","sources":["../../../src/services/ai/provider-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,UAAU,2BAA2B;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACnC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,UAAU,uBAAuB;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,2BAA2B,EACnC,SAAS,GAAE,uBAA4B,GACtC,cAAc,CAchB"}

package/dist/services/ai/provider-config.js

@@ -0,0 +1,14 @@
+export function buildMemoryProviderConfig(config, overrides = {}) {
+    if (!config.memoryModel || !config.memoryApiUrl) {
+        throw new Error("External API not configured for memory provider");
+    }
+    return {
+        model: config.memoryModel,
+        apiUrl: config.memoryApiUrl,
+        apiKey: config.memoryApiKey,
+        memoryTemperature: config.memoryTemperature,
+        extraParams: config.memoryExtraParams,
+        maxIterations: overrides.maxIterations ?? config.autoCaptureMaxIterations,
+        iterationTimeout: overrides.iterationTimeout ?? config.autoCaptureIterationTimeout,
+    };
+}

package/dist/services/ai/providers/anthropic-messages.d.ts

@@ -0,0 +1,12 @@
+import { BaseAIProvider, type ToolCallResult } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { type ChatCompletionTool } from "../tools/tool-schema.js";
+export declare class AnthropicMessagesProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+    private extractToolUse;
+}
+//# sourceMappingURL=anthropic-messages.d.ts.map

package/dist/services/ai/providers/anthropic-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAuB,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AA4BvF,qBAAa,yBAA0B,SAAQ,cAAc;IAC3D,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,gBAAgB;IAK3D,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,OAAO;IAIpB,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;IAoL1B,OAAO,CAAC,cAAc;CAavB"}

package/dist/services/ai/providers/anthropic-messages.js

@@ -0,0 +1,184 @@
+import { BaseAIProvider } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { ToolSchemaConverter } from "../tools/tool-schema.js";
+import { log } from "../../logger.js";
+import { UserProfileValidator } from "../validators/user-profile-validator.js";
+export class AnthropicMessagesProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "anthropic";
+    }
+    supportsSession() {
+        return true;
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = this.aiSessionManager.getSession(sessionId, "anthropic");
+        if (!session) {
+            session = this.aiSessionManager.createSession({
+                provider: "anthropic",
+                sessionId,
+                metadata: { systemPrompt },
+            });
+        }
+        const storedMessages = this.aiSessionManager.getMessages(session.id);
+        const messages = [];
+        for (const msg of storedMessages) {
+            if (msg.role === "system")
+                continue;
+            const anthropicMsg = {
+                role: msg.role,
+                content: msg.contentBlocks || msg.content,
+            };
+            messages.push(anthropicMsg);
+        }
+        const userSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+        this.aiSessionManager.addMessage({
+            aiSessionId: session.id,
+            sequence: userSequence,
+            role: "user",
+            content: userPrompt,
+        });
+        messages.push({ role: "user", content: userPrompt });
+        let iterations = 0;
+        const maxIterations = this.config.maxIterations ?? 5;
+        const iterationTimeout = this.config.iterationTimeout ?? 30000;
+        while (iterations < maxIterations) {
+            iterations++;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), iterationTimeout);
+            try {
+                const tool = ToolSchemaConverter.toAnthropic(toolSchema);
+                const requestBody = {
+                    model: this.config.model,
+                    max_tokens: this.config.maxTokens ?? 4096,
+                    system: systemPrompt,
+                    messages,
+                    tools: [tool],
+                };
+                const headers = {
+                    "Content-Type": "application/json",
+                    "anthropic-version": "2023-06-01",
+                };
+                if (this.config.apiKey) {
+                    headers["x-api-key"] = this.config.apiKey;
+                }
+                const response = await fetch(`${this.config.apiUrl}/messages`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("Anthropic Messages API error", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        status: response.status,
+                        error: errorText,
+                        iteration: iterations,
+                    });
+                    return {
+                        success: false,
+                        error: `API error: ${response.status} - ${errorText}`,
+                        iterations,
+                    };
+                }
+                const data = (await response.json());
+                const assistantSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+                this.aiSessionManager.addMessage({
+                    aiSessionId: session.id,
+                    sequence: assistantSequence,
+                    role: "assistant",
+                    content: JSON.stringify(data.content),
+                    contentBlocks: data.content,
+                });
+                messages.push({
+                    role: "assistant",
+                    content: data.content,
+                });
+                const toolUse = this.extractToolUse(data, toolSchema.function.name);
+                if (toolUse) {
+                    try {
+                        const result = UserProfileValidator.validate(toolUse);
+                        if (!result.valid) {
+                            throw new Error(result.errors.join(", "));
+                        }
+                        return {
+                            success: true,
+                            data: result.data,
+                            iterations,
+                        };
+                    }
+                    catch (validationError) {
+                        const errorStack = validationError instanceof Error ? validationError.stack : undefined;
+                        log("Anthropic tool response validation failed", {
+                            error: String(validationError),
+                            stack: errorStack,
+                            errorType: validationError instanceof Error
+                                ? validationError.constructor.name
+                                : typeof validationError,
+                            toolName: toolSchema.function.name,
+                            iteration: iterations,
+                            rawData: JSON.stringify(toolUse).slice(0, 500),
+                        });
+                        return {
+                            success: false,
+                            error: `Validation failed: ${String(validationError)}`,
+                            iterations,
+                        };
+                    }
+                }
+                if (data.stop_reason === "end_turn") {
+                    const retrySequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+                    const retryPrompt = "Please use the save_memories tool to extract and save the memories from the conversation as instructed.";
+                    this.aiSessionManager.addMessage({
+                        aiSessionId: session.id,
+                        sequence: retrySequence,
+                        role: "user",
+                        content: retryPrompt,
+                    });
+                    messages.push({ role: "user", content: retryPrompt });
+                }
+                else {
+                    break;
+                }
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (error instanceof Error && error.name === "AbortError") {
+                    return {
+                        success: false,
+                        error: `API request timeout (${this.config.iterationTimeout}ms)`,
+                        iterations,
+                    };
+                }
+                return {
+                    success: false,
+                    error: String(error),
+                    iterations,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `Max iterations (${maxIterations}) reached without tool use`,
+            iterations,
+        };
+    }
+    extractToolUse(data, expectedToolName) {
+        if (!data.content || !Array.isArray(data.content)) {
+            return null;
+        }
+        for (const block of data.content) {
+            if (block.type === "tool_use" && block.name === expectedToolName && block.input) {
+                return block.input;
+            }
+        }
+        return null;
+    }
+}

package/dist/services/ai/providers/base-provider.d.ts

@@ -0,0 +1,25 @@
+export interface ToolCallResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    iterations?: number;
+}
+export interface ProviderConfig {
+    model: string;
+    apiUrl: string;
+    apiKey?: string;
+    maxIterations?: number;
+    iterationTimeout?: number;
+    maxTokens?: number;
+    memoryTemperature?: number | false;
+    extraParams?: Record<string, unknown>;
+}
+export declare function applySafeExtraParams(requestBody: Record<string, any>, extraParams: Record<string, unknown>): void;
+export declare abstract class BaseAIProvider {
+    protected config: ProviderConfig;
+    constructor(config: ProviderConfig);
+    abstract executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: any, sessionId: string): Promise<ToolCallResult>;
+    abstract getProviderName(): string;
+    abstract supportsSession(): boolean;
+}
+//# sourceMappingURL=base-provider.d.ts.map

package/dist/services/ai/providers/base-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-provider.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/base-provider.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAaD,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,IAAI,CAMN;AAED,8BAAsB,cAAc;IAClC,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;gBAErB,MAAM,EAAE,cAAc;IAIlC,QAAQ,CAAC,eAAe,CACtB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,GAAG,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;IAE1B,QAAQ,CAAC,eAAe,IAAI,MAAM;IAElC,QAAQ,CAAC,eAAe,IAAI,OAAO;CACpC"}

package/dist/services/ai/providers/base-provider.js

@@ -0,0 +1,23 @@
+const PROTECTED_KEYS = new Set([
+    "model",
+    "messages",
+    "tools",
+    "tool_choice",
+    "temperature",
+    "input",
+    "instructions",
+    "conversation",
+]);
+export function applySafeExtraParams(requestBody, extraParams) {
+    for (const [key, value] of Object.entries(extraParams)) {
+        if (!PROTECTED_KEYS.has(key)) {
+            requestBody[key] = value;
+        }
+    }
+}
+export class BaseAIProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+}

package/dist/services/ai/providers/google-gemini.d.ts

@@ -0,0 +1,16 @@
+import { BaseAIProvider, type ToolCallResult } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import type { ChatCompletionTool } from "../tools/tool-schema.js";
+/**
+ * Google Gemini Provider
+ * Supports Google's Gemini models (e.g. gemini-1.5-flash) via Google AI Studio API.
+ */
+export declare class GoogleGeminiProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    private addToolResponse;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+}
+//# sourceMappingURL=google-gemini.d.ts.map

package/dist/services/ai/providers/google-gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-gemini.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/google-gemini.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAIlE;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,cAAc;IACtD,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,gBAAgB;IAK3D,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,OAAO;IAI1B,OAAO,CAAC,eAAe;IA4BjB,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;CA2N3B"}