opc-agent 1.1.2 → 1.1.3

package/dist/providers/index.d.ts

@@ -5,5 +5,5 @@ export interface LLMProvider {
     chatStream(messages: Message[], systemPrompt?: string): AsyncIterable<string>;
 }
 export declare function createProvider(name?: string, model?: string, baseUrl?: string, apiKey?: string): LLMProvider;
-export declare const SUPPORTED_PROVIDERS: readonly ["openai", "deepseek", "qwen"];
+export declare const SUPPORTED_PROVIDERS: readonly ["openai", "deepseek", "qwen", "gemini"];
 //# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -69,20 +69,27 @@ class OpenAICompatibleProvider {
             throw new Error('No API key configured. Set OPC_LLM_API_KEY or OPENAI_API_KEY environment variable.');
         }
         const url = new URL(`${this.baseUrl}/chat/completions`);
+        const isGemini = url.hostname.includes('googleapis.com');
+        if (isGemini) {
+            url.searchParams.set('key', this.apiKey);
+        }
         const isHttps = url.protocol === 'https:';
         const lib = isHttps ? https : http;
         const postData = JSON.stringify(body);
+        const headers = {
+            'Content-Type': 'application/json',
+            'Content-Length': String(Buffer.byteLength(postData)),
+        };
+        if (!isGemini) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
         return new Promise((resolve, reject) => {
             const req = lib.request({
                 hostname: url.hostname,
                 port: url.port || (isHttps ? 443 : 80),
-                path: url.pathname,
+                path: url.pathname + url.search,
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.apiKey}`,
-                    'Content-Length': Buffer.byteLength(postData),
-                },
+                headers,
             }, (res) => {
                 let data = '';
                 res.on('data', (chunk) => (data += chunk.toString()));
@@ -127,6 +134,10 @@ class OpenAICompatibleProvider {
         }
         const formatted = this.formatMessages(messages, systemPrompt);
         const url = new URL(`${this.baseUrl}/chat/completions`);
+        const isGemini = url.hostname.includes('googleapis.com');
+        if (isGemini) {
+            url.searchParams.set('key', this.apiKey);
+        }
         const isHttps = url.protocol === 'https:';
         const lib = isHttps ? https : http;
         const postData = JSON.stringify({
@@ -136,17 +147,20 @@ class OpenAICompatibleProvider {
             max_tokens: 2048,
             stream: true,
         });
+        const streamHeaders = {
+            'Content-Type': 'application/json',
+            'Content-Length': String(Buffer.byteLength(postData)),
+        };
+        if (!isGemini) {
+            streamHeaders['Authorization'] = `Bearer ${this.apiKey}`;
+        }
         const response = await new Promise((resolve, reject) => {
             const req = lib.request({
                 hostname: url.hostname,
                 port: url.port || (isHttps ? 443 : 80),
-                path: url.pathname,
+                path: url.pathname + url.search,
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.apiKey}`,
-                    'Content-Length': Buffer.byteLength(postData),
-                },
+                headers: streamHeaders,
             }, resolve);
             req.on('error', reject);
             req.write(postData);
@@ -183,9 +197,130 @@ class OpenAICompatibleProvider {
         }
     }
 }
+class GeminiNativeProvider {
+    name = 'gemini';
+    model;
+    apiKey;
+    constructor(model, apiKey) {
+        this.model = model;
+        this.apiKey = apiKey || getApiKey();
+    }
+    buildUrl(stream) {
+        const action = stream ? 'streamGenerateContent?alt=sse&' : 'generateContent?';
+        return `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:${action}key=${this.apiKey}`;
+    }
+    formatContents(messages, systemPrompt) {
+        const contents = [];
+        for (const m of messages) {
+            contents.push({ role: m.role === 'assistant' ? 'model' : 'user', parts: [{ text: m.content }] });
+        }
+        const result = { contents };
+        if (systemPrompt) {
+            result.systemInstruction = { parts: [{ text: systemPrompt }] };
+        }
+        return result;
+    }
+    async chat(messages, systemPrompt) {
+        if (!this.apiKey) {
+            const last = messages[messages.length - 1];
+            return `[gemini/${this.model} - no API key] Echo: ${last?.content ?? ''}`;
+        }
+        const body = this.formatContents(messages, systemPrompt);
+        const url = this.buildUrl(false);
+        const postData = JSON.stringify(body);
+        return new Promise((resolve, reject) => {
+            const parsedUrl = new URL(url);
+            const req = https.request({
+                hostname: parsedUrl.hostname,
+                path: parsedUrl.pathname + parsedUrl.search,
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(postData)) },
+            }, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk.toString()));
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode >= 400) {
+                        reject(new Error(`Gemini API error ${res.statusCode}: ${data}`));
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        resolve(parsed.candidates?.[0]?.content?.parts?.[0]?.text ?? '');
+                    }
+                    catch {
+                        reject(new Error(`Invalid Gemini response: ${data.slice(0, 200)}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(postData);
+            req.end();
+        });
+    }
+    async *chatStream(messages, systemPrompt) {
+        if (!this.apiKey) {
+            const last = messages[messages.length - 1];
+            yield `[gemini/${this.model} - no API key] Echo: ${last?.content ?? ''}`;
+            return;
+        }
+        const body = this.formatContents(messages, systemPrompt);
+        const url = this.buildUrl(true);
+        const postData = JSON.stringify(body);
+        const parsedUrl = new URL(url);
+        const response = await new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: parsedUrl.hostname,
+                path: parsedUrl.pathname + parsedUrl.search,
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(postData)) },
+            }, resolve);
+            req.on('error', reject);
+            req.write(postData);
+            req.end();
+        });
+        if (response.statusCode && response.statusCode >= 400) {
+            let data = '';
+            for await (const chunk of response)
+                data += chunk.toString();
+            throw new Error(`Gemini API error ${response.statusCode}: ${data}`);
+        }
+        let buffer = '';
+        for await (const chunk of response) {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith('data: '))
+                    continue;
+                const data = trimmed.slice(6);
+                if (data === '[DONE]')
+                    return;
+                try {
+                    const parsed = JSON.parse(data);
+                    const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
+                    if (text)
+                        yield text;
+                }
+                catch { }
+            }
+        }
+    }
+}
+function isGeminiNative() {
+    const baseUrl = process.env.OPC_LLM_BASE_URL || '';
+    const key = getApiKey();
+    // Use native Gemini API when: key starts with AQ. (new format) OR base URL points to googleapis
+    return key.startsWith('AQ.') || (baseUrl.includes('googleapis.com') && !baseUrl.includes('/openai'));
+}
 function createProvider(name = 'openai', model, baseUrl, apiKey) {
     const finalModel = model || process.env.OPC_LLM_MODEL || 'gpt-4o-mini';
+    const finalKey = apiKey || getApiKey();
+    // Auto-detect Gemini native when key is new format
+    if (finalKey.startsWith('AQ.') || isGeminiNative()) {
+        return new GeminiNativeProvider(finalModel, finalKey);
+    }
     return new OpenAICompatibleProvider(name, finalModel, baseUrl, apiKey);
 }
-exports.SUPPORTED_PROVIDERS = ['openai', 'deepseek', 'qwen'];
+exports.SUPPORTED_PROVIDERS = ['openai', 'deepseek', 'qwen', 'gemini'];
 //# sourceMappingURL=index.js.map

package/dist/schema/oad.d.ts

@@ -577,6 +577,7 @@ export declare const SpecSchema: z.ZodObject<{
         config?: Record<string, unknown> | undefined;
     }[] | undefined;
 }, {
+    model?: string | undefined;
     auth?: {
         enabled?: boolean | undefined;
         apiKeys?: string[] | undefined;
@@ -597,7 +598,6 @@ export declare const SpecSchema: z.ZodObject<{
         default?: string | undefined;
         allowed?: string[] | undefined;
     } | undefined;
-    model?: string | undefined;
     systemPrompt?: string | undefined;
     skills?: {
         name: string;
@@ -995,6 +995,7 @@ export declare const OADSchema: z.ZodObject<{
             config?: Record<string, unknown> | undefined;
         }[] | undefined;
     }, {
+        model?: string | undefined;
         auth?: {
             enabled?: boolean | undefined;
             apiKeys?: string[] | undefined;
@@ -1015,7 +1016,6 @@ export declare const OADSchema: z.ZodObject<{
             default?: string | undefined;
             allowed?: string[] | undefined;
         } | undefined;
-        model?: string | undefined;
         systemPrompt?: string | undefined;
         skills?: {
             name: string;
@@ -1183,6 +1183,7 @@ export declare const OADSchema: z.ZodObject<{
         } | undefined;
     };
     spec: {
+        model?: string | undefined;
         auth?: {
             enabled?: boolean | undefined;
             apiKeys?: string[] | undefined;
@@ -1203,7 +1204,6 @@ export declare const OADSchema: z.ZodObject<{
             default?: string | undefined;
             allowed?: string[] | undefined;
         } | undefined;
-        model?: string | undefined;
         systemPrompt?: string | undefined;
         skills?: {
             name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/providers/index.ts

@@ -51,23 +51,31 @@ class OpenAICompatibleProvider implements LLMProvider {
     }
 
     const url = new URL(`${this.baseUrl}/chat/completions`);
+    const isGemini = url.hostname.includes('googleapis.com');
+    if (isGemini) {
+      url.searchParams.set('key', this.apiKey);
+    }
     const isHttps = url.protocol === 'https:';
     const lib = isHttps ? https : http;
 
     const postData = JSON.stringify(body);
 
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'Content-Length': String(Buffer.byteLength(postData)),
+    };
+    if (!isGemini) {
+      headers['Authorization'] = `Bearer ${this.apiKey}`;
+    }
+
     return new Promise((resolve, reject) => {
       const req = lib.request(
         {
           hostname: url.hostname,
           port: url.port || (isHttps ? 443 : 80),
-          path: url.pathname,
+          path: url.pathname + url.search,
           method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${this.apiKey}`,
-            'Content-Length': Buffer.byteLength(postData),
-          },
+          headers,
         },
         (res) => {
           let data = '';
@@ -116,6 +124,10 @@ class OpenAICompatibleProvider implements LLMProvider {
 
     const formatted = this.formatMessages(messages, systemPrompt);
     const url = new URL(`${this.baseUrl}/chat/completions`);
+    const isGemini = url.hostname.includes('googleapis.com');
+    if (isGemini) {
+      url.searchParams.set('key', this.apiKey);
+    }
     const isHttps = url.protocol === 'https:';
     const lib = isHttps ? https : http;
     const postData = JSON.stringify({
@@ -126,18 +138,22 @@ class OpenAICompatibleProvider implements LLMProvider {
       stream: true,
     });
 
+    const streamHeaders: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'Content-Length': String(Buffer.byteLength(postData)),
+    };
+    if (!isGemini) {
+      streamHeaders['Authorization'] = `Bearer ${this.apiKey}`;
+    }
+
     const response = await new Promise<http.IncomingMessage>((resolve, reject) => {
       const req = lib.request(
         {
           hostname: url.hostname,
           port: url.port || (isHttps ? 443 : 80),
-          path: url.pathname,
+          path: url.pathname + url.search,
           method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${this.apiKey}`,
-            'Content-Length': Buffer.byteLength(postData),
-          },
+          headers: streamHeaders,
         },
         resolve,
       );
@@ -175,9 +191,132 @@ class OpenAICompatibleProvider implements LLMProvider {
   }
 }
 
+class GeminiNativeProvider implements LLMProvider {
+  name = 'gemini';
+  private model: string;
+  private apiKey: string;
+
+  constructor(model: string, apiKey?: string) {
+    this.model = model;
+    this.apiKey = apiKey || getApiKey();
+  }
+
+  private buildUrl(stream: boolean): string {
+    const action = stream ? 'streamGenerateContent?alt=sse&' : 'generateContent?';
+    return `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:${action}key=${this.apiKey}`;
+  }
+
+  private formatContents(messages: Message[], systemPrompt?: string): { contents: any[]; systemInstruction?: any } {
+    const contents: any[] = [];
+    for (const m of messages) {
+      contents.push({ role: m.role === 'assistant' ? 'model' : 'user', parts: [{ text: m.content }] });
+    }
+    const result: any = { contents };
+    if (systemPrompt) {
+      result.systemInstruction = { parts: [{ text: systemPrompt }] };
+    }
+    return result;
+  }
+
+  async chat(messages: Message[], systemPrompt?: string): Promise<string> {
+    if (!this.apiKey) {
+      const last = messages[messages.length - 1];
+      return `[gemini/${this.model} - no API key] Echo: ${last?.content ?? ''}`;
+    }
+    const body = this.formatContents(messages, systemPrompt);
+    const url = this.buildUrl(false);
+    const postData = JSON.stringify(body);
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(url);
+      const req = https.request({
+        hostname: parsedUrl.hostname,
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(postData)) },
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk: Buffer) => (data += chunk.toString()));
+        res.on('end', () => {
+          if (res.statusCode && res.statusCode >= 400) { reject(new Error(`Gemini API error ${res.statusCode}: ${data}`)); return; }
+          try {
+            const parsed = JSON.parse(data);
+            resolve(parsed.candidates?.[0]?.content?.parts?.[0]?.text ?? '');
+          } catch { reject(new Error(`Invalid Gemini response: ${data.slice(0, 200)}`)); }
+        });
+      });
+      req.on('error', reject);
+      req.write(postData);
+      req.end();
+    });
+  }
+
+  async *chatStream(messages: Message[], systemPrompt?: string): AsyncIterable<string> {
+    if (!this.apiKey) {
+      const last = messages[messages.length - 1];
+      yield `[gemini/${this.model} - no API key] Echo: ${last?.content ?? ''}`;
+      return;
+    }
+    const body = this.formatContents(messages, systemPrompt);
+    const url = this.buildUrl(true);
+    const postData = JSON.stringify(body);
+    const parsedUrl = new URL(url);
+
+    const response = await new Promise<http.IncomingMessage>((resolve, reject) => {
+      const req = https.request({
+        hostname: parsedUrl.hostname,
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(postData)) },
+      }, resolve);
+      req.on('error', reject);
+      req.write(postData);
+      req.end();
+    });
+
+    if (response.statusCode && response.statusCode >= 400) {
+      let data = '';
+      for await (const chunk of response) data += chunk.toString();
+      throw new Error(`Gemini API error ${response.statusCode}: ${data}`);
+    }
+
+    let buffer = '';
+    for await (const chunk of response) {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data: ')) continue;
+        const data = trimmed.slice(6);
+        if (data === '[DONE]') return;
+        try {
+          const parsed = JSON.parse(data);
+          const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (text) yield text;
+        } catch {}
+      }
+    }
+  }
+}
+
+function isGeminiNative(): boolean {
+  const baseUrl = process.env.OPC_LLM_BASE_URL || '';
+  const key = getApiKey();
+  // Use native Gemini API when: key starts with AQ. (new format) OR base URL points to googleapis
+  return key.startsWith('AQ.') || (baseUrl.includes('googleapis.com') && !baseUrl.includes('/openai'));
+}
+
 export function createProvider(name: string = 'openai', model?: string, baseUrl?: string, apiKey?: string): LLMProvider {
   const finalModel = model || process.env.OPC_LLM_MODEL || 'gpt-4o-mini';
+  const finalKey = apiKey || getApiKey();
+
+  // Auto-detect Gemini native when key is new format
+  if (finalKey.startsWith('AQ.') || isGeminiNative()) {
+    return new GeminiNativeProvider(finalModel, finalKey);
+  }
+
   return new OpenAICompatibleProvider(name, finalModel, baseUrl, apiKey);
 }
 
-export const SUPPORTED_PROVIDERS = ['openai', 'deepseek', 'qwen'] as const;
+export const SUPPORTED_PROVIDERS = ['openai', 'deepseek', 'qwen', 'gemini'] as const;