loopengine 0.1.6 → 0.1.8

package/README.md

@@ -466,6 +466,18 @@ you, using the matching API key from the environment:
 | `'anthropic'` | `ANTHROPIC_API_KEY` | no — defaults to `claude-sonnet-5` |
 | `'openai'` | `OPENAI_API_KEY` | yes |
 | `'deepseek'` | `DEEPSEEK_API_KEY` | yes |
+| `'kimi'` | `MOONSHOT_API_KEY` | yes |
+| `'glm'` | `GLM_API_KEY` | yes |
+| `'gemini'` | `GEMINI_API_KEY` | yes |
+
+`'kimi'`'s env var is `MOONSHOT_API_KEY`, not `KIMI_API_KEY` — deliberate,
+matching Moonshot AI's own docs (the API/company behind Kimi) rather than
+this package's own provider name. `openai`/`deepseek`/`kimi`/`glm`/
+`gemini` all reuse the same OpenAI-Chat-Completions-compatible request
+translation, just pointed at each provider's own base URL — see
+`core/model-calls/*.ts` for the provider-specific details (base URLs,
+`max_completion_tokens` vs `max_tokens`, and Gemini's own "still in beta"
+caveat on Google's compatibility layer).
 
 For anything else (a custom SDK client, a canned/simulated model for
 testing), export your own `createModelCall(): ModelCall` instead.

package/dist/bin/cli.d.ts

@@ -7,7 +7,7 @@ export declare class AgentNotFoundError extends Error {
 }
 export declare class AgentModelError extends Error {
 }
-type Provider = 'anthropic' | 'openai' | 'deepseek';
+type Provider = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'glm' | 'gemini';
 export interface AgentTemplateOptions {
     systemPrompt?: string;
     model?: {

package/dist/bin/cli.js

@@ -26,6 +26,11 @@ const MODEL_ENV_VAR = {
     anthropic: 'ANTHROPIC_API_KEY',
     openai: 'OPENAI_API_KEY',
     deepseek: 'DEEPSEEK_API_KEY',
+    // Moonshot AI's own env var name, not KIMI_API_KEY — see
+    // kimi-model-call.ts's own header comment for why.
+    kimi: 'MOONSHOT_API_KEY',
+    glm: 'GLM_API_KEY',
+    gemini: 'GEMINI_API_KEY',
 };
 // Escapes a value for safe interpolation into a single-quoted TS string
 // literal in generated code — an operator-supplied systemPrompt (from

package/dist/core/agent-config.d.ts

@@ -237,9 +237,10 @@ export type HttpNotifierConfig = {
  * export your own `createModelCall` for anything this can't express (a
  * canned/simulated `ModelCall` for a demo, a custom SDK client, a
  * provider this doesn't list). `model` is required for `openai`/
- * `deepseek` (no safe hardcoded default — a flagship model name changes
- * too often to bake one in) but optional for `anthropic` (defaults to
- * `'claude-sonnet-5'`), mirroring each factory's own options exactly. */
+ * `deepseek`/`kimi`/`glm`/`gemini` (no safe hardcoded default — a
+ * flagship model name changes too often to bake one in) but optional for
+ * `anthropic` (defaults to `'claude-sonnet-5'`), mirroring each factory's
+ * own options exactly. */
 export type AgentModelConfig = {
     provider: 'anthropic';
     model?: string;
@@ -256,6 +257,24 @@ export type AgentModelConfig = {
     apiKey?: string;
     maxTokens?: number;
     baseURL?: string;
+} | {
+    provider: 'kimi';
+    model: string;
+    apiKey?: string;
+    maxTokens?: number;
+    baseURL?: string;
+} | {
+    provider: 'glm';
+    model: string;
+    apiKey?: string;
+    maxTokens?: number;
+    baseURL?: string;
+} | {
+    provider: 'gemini';
+    model: string;
+    apiKey?: string;
+    maxTokens?: number;
+    baseURL?: string;
 };
 export interface ToolSchema {
     name: string;

package/dist/core/discover-agents.js

@@ -47,8 +47,20 @@ export async function synthesizeCreateModelCall(model) {
         const { createOpenAIModelCall } = await import('./model-calls/openai-model-call.js');
         return () => (cached ??= createOpenAIModelCall(model));
     }
-    const { createDeepSeekModelCall } = await import('./model-calls/deepseek-model-call.js');
-    return () => (cached ??= createDeepSeekModelCall(model));
+    if (model.provider === 'deepseek') {
+        const { createDeepSeekModelCall } = await import('./model-calls/deepseek-model-call.js');
+        return () => (cached ??= createDeepSeekModelCall(model));
+    }
+    if (model.provider === 'kimi') {
+        const { createKimiModelCall } = await import('./model-calls/kimi-model-call.js');
+        return () => (cached ??= createKimiModelCall(model));
+    }
+    if (model.provider === 'glm') {
+        const { createGlmModelCall } = await import('./model-calls/glm-model-call.js');
+        return () => (cached ??= createGlmModelCall(model));
+    }
+    const { createGeminiModelCall } = await import('./model-calls/gemini-model-call.js');
+    return () => (cached ??= createGeminiModelCall(model));
 }
 /** Resolves one directory entry to an agent module's path, or undefined if
  * this entry isn't one — a `.ts`/`.js` file directly (the common case), or

package/dist/core/model-calls/gemini-model-call.d.ts

@@ -0,0 +1,17 @@
+import OpenAI from 'openai';
+import type { ModelCall } from '#core/run-agent.js';
+export interface GeminiModelCallOptions {
+    /** Defaults to the GEMINI_API_KEY env var. */
+    apiKey?: string;
+    /** No hardcoded default — same reasoning as OpenAIModelCallOptions.model:
+     * pass the one you actually want. */
+    model: string;
+    maxTokens?: number;
+    /** Defaults to Google's own OpenAI-compatible endpoint — override to
+     * point at a proxy/mirror. Trailing slash required (see this file's
+     * own header comment). */
+    baseURL?: string;
+    /** Inject a pre-configured client instead of building one from apiKey/baseURL — e.g. to pass a custom `fetch` in tests. */
+    client?: OpenAI;
+}
+export declare function createGeminiModelCall(options: GeminiModelCallOptions): ModelCall;

package/dist/core/model-calls/gemini-model-call.js

@@ -0,0 +1,53 @@
+// A sixth real ModelCall implementation. Google's own OpenAI-compatible
+// endpoint for Gemini (ai.google.dev/gemini-api/docs/openai) supports the
+// same messages/tools/tool_choice request shape and tool_calls response
+// shape as OpenAI's Chat Completions API, so this reuses
+// openai-model-call.ts's translation verbatim via the real `openai` SDK
+// client, same pattern deepseek/kimi/glm-model-call.ts already
+// established — rather than a bespoke native @google/genai integration
+// (Gemini's own SDK has a meaningfully different message-role/content-
+// parts/function-calling shape).
+//
+// Caveat, from Google's own docs: "Support for the OpenAI libraries is
+// still in beta while we extend feature support" — this is the one
+// provider here riding a compatibility layer its own vendor calls beta,
+// not a fully stable wire contract the way DeepSeek/Kimi/GLM's own docs
+// present theirs. Uses `max_completion_tokens`, same as Kimi/GLM.
+//
+// The trailing slash on the base URL matters — Google's endpoint 404s
+// without it (confirmed against their own docs' exact example URL).
+import OpenAI from 'openai';
+import { toMessageParams, toModelResponse } from './openai-model-call.js';
+export function createGeminiModelCall(options) {
+    if (!options.client && !options.apiKey && !process.env.GEMINI_API_KEY) {
+        // Fails here, with a Gemini-specific message, rather than letting the
+        // OpenAI SDK's own constructor validation reject it — that error says
+        // "set OPENAI_API_KEY", which would send someone who never touched
+        // that variable chasing the wrong fix.
+        throw new Error('createGeminiModelCall: no apiKey given and GEMINI_API_KEY is not set.');
+    }
+    const client = options.client ??
+        new OpenAI({
+            // Explicitly null, not undefined, if neither is set — see
+            // kimi-model-call.ts's identical comment for why this matters even
+            // though the guard above already rules out reaching here with no
+            // key at all.
+            apiKey: options.apiKey ?? process.env.GEMINI_API_KEY ?? null,
+            baseURL: options.baseURL ?? 'https://generativelanguage.googleapis.com/v1beta/openai/',
+        });
+    const maxTokens = options.maxTokens ?? 4096;
+    return async (messages, system, tools) => {
+        const response = await client.chat.completions.create({
+            model: options.model,
+            max_completion_tokens: maxTokens,
+            messages: [{ role: 'system', content: system }, ...messages.flatMap(toMessageParams)],
+            tools: tools.length
+                ? tools.map((t) => ({
+                    type: 'function',
+                    function: { name: t.name, description: t.description, parameters: t.input_schema },
+                }))
+                : undefined,
+        });
+        return toModelResponse(response.choices[0]);
+    };
+}

package/dist/core/model-calls/glm-model-call.d.ts

@@ -0,0 +1,15 @@
+import OpenAI from 'openai';
+import type { ModelCall } from '#core/run-agent.js';
+export interface GlmModelCallOptions {
+    /** Defaults to the GLM_API_KEY env var. */
+    apiKey?: string;
+    /** No hardcoded default — same reasoning as OpenAIModelCallOptions.model:
+     * pass the one you actually want. */
+    model: string;
+    maxTokens?: number;
+    /** Defaults to Zhipu's own API — override to point at a proxy/mirror. */
+    baseURL?: string;
+    /** Inject a pre-configured client instead of building one from apiKey/baseURL — e.g. to pass a custom `fetch` in tests. */
+    client?: OpenAI;
+}
+export declare function createGlmModelCall(options: GlmModelCallOptions): ModelCall;

package/dist/core/model-calls/glm-model-call.js

@@ -0,0 +1,46 @@
+// A fifth real ModelCall implementation. GLM (Zhipu AI / Z.ai)'s Chat
+// Completions API is OpenAI-compatible — confirmed against Zhipu's own
+// docs (docs.bigmodel.cn/cn/guide/develop/openai/introduction): same
+// messages/tools/tool_choice request shape, same tool_calls response
+// shape — so this reuses openai-model-call.ts's message/response
+// translation verbatim via the real `openai` SDK client, just pointed at
+// Zhipu's base URL, rather than duplicating that logic. Same pattern
+// deepseek-model-call.ts/kimi-model-call.ts already established.
+//
+// Uses the newer `max_completion_tokens` field, same as Kimi — no
+// DeepSeek-style documented exception for GLM.
+import OpenAI from 'openai';
+import { toMessageParams, toModelResponse } from './openai-model-call.js';
+export function createGlmModelCall(options) {
+    if (!options.client && !options.apiKey && !process.env.GLM_API_KEY) {
+        // Fails here, with a GLM-specific message, rather than letting the
+        // OpenAI SDK's own constructor validation reject it — that error says
+        // "set OPENAI_API_KEY", which would send someone who never touched
+        // that variable chasing the wrong fix.
+        throw new Error('createGlmModelCall: no apiKey given and GLM_API_KEY is not set.');
+    }
+    const client = options.client ??
+        new OpenAI({
+            // Explicitly null, not undefined, if neither is set — see
+            // kimi-model-call.ts's identical comment for why this matters even
+            // though the guard above already rules out reaching here with no
+            // key at all.
+            apiKey: options.apiKey ?? process.env.GLM_API_KEY ?? null,
+            baseURL: options.baseURL ?? 'https://open.bigmodel.cn/api/paas/v4/',
+        });
+    const maxTokens = options.maxTokens ?? 4096;
+    return async (messages, system, tools) => {
+        const response = await client.chat.completions.create({
+            model: options.model,
+            max_completion_tokens: maxTokens,
+            messages: [{ role: 'system', content: system }, ...messages.flatMap(toMessageParams)],
+            tools: tools.length
+                ? tools.map((t) => ({
+                    type: 'function',
+                    function: { name: t.name, description: t.description, parameters: t.input_schema },
+                }))
+                : undefined,
+        });
+        return toModelResponse(response.choices[0]);
+    };
+}

package/dist/core/model-calls/kimi-model-call.d.ts

@@ -0,0 +1,15 @@
+import OpenAI from 'openai';
+import type { ModelCall } from '#core/run-agent.js';
+export interface KimiModelCallOptions {
+    /** Defaults to the MOONSHOT_API_KEY env var. */
+    apiKey?: string;
+    /** No hardcoded default — same reasoning as OpenAIModelCallOptions.model:
+     * pass the one you actually want. */
+    model: string;
+    maxTokens?: number;
+    /** Defaults to Moonshot's own API — override to point at a proxy/mirror. */
+    baseURL?: string;
+    /** Inject a pre-configured client instead of building one from apiKey/baseURL — e.g. to pass a custom `fetch` in tests. */
+    client?: OpenAI;
+}
+export declare function createKimiModelCall(options: KimiModelCallOptions): ModelCall;

package/dist/core/model-calls/kimi-model-call.js

@@ -0,0 +1,59 @@
+// A fourth real ModelCall implementation. Kimi (Moonshot AI)'s Chat
+// Completions API is wire-compatible with OpenAI's — confirmed against
+// Moonshot's own docs (platform.kimi.ai/docs/api/chat): same messages/
+// tools/tool_choice request shape, same tool_calls response shape — so
+// this reuses openai-model-call.ts's message/response translation
+// verbatim via the real `openai` SDK client, just pointed at Moonshot's
+// base URL, rather than duplicating that logic. Same pattern
+// deepseek-model-call.ts already established for a third provider.
+//
+// Unlike DeepSeek, Moonshot's docs use the newer `max_completion_tokens`
+// field (matching the current OpenAI SDK) rather than the deprecated
+// `max_tokens` DeepSeek's own docs still list — decided at the request-
+// building call site below, since toMessageParams/toModelResponse don't
+// touch that field either way.
+//
+// Env var is MOONSHOT_API_KEY, not KIMI_API_KEY, despite every other
+// provider here matching its own literal exactly — deliberate: this
+// matches the underlying API/company's own docs and what anyone
+// copy-pasting from Moonshot's own examples already has set, not this
+// package's own provider name.
+import OpenAI from 'openai';
+import { toMessageParams, toModelResponse } from './openai-model-call.js';
+export function createKimiModelCall(options) {
+    if (!options.client && !options.apiKey && !process.env.MOONSHOT_API_KEY) {
+        // Fails here, with a Kimi-specific message, rather than letting the
+        // OpenAI SDK's own constructor validation reject it — that error says
+        // "set OPENAI_API_KEY", which would send someone who never touched
+        // that variable chasing the wrong fix.
+        throw new Error('createKimiModelCall: no apiKey given and MOONSHOT_API_KEY is not set.');
+    }
+    const client = options.client ??
+        new OpenAI({
+            // Explicitly null, not undefined, if neither is set — the OpenAI
+            // SDK's own constructor falls back to reading OPENAI_API_KEY itself
+            // when apiKey is undefined (its normal, correct behavior for
+            // createOpenAIModelCall), which here would silently authenticate
+            // against Moonshot with an OpenAI key if one happens to be set. The
+            // guard above already rules out reaching here with no key at all,
+            // but null (not undefined) is kept regardless so this line is
+            // correct on its own, not just because of the guard before it.
+            apiKey: options.apiKey ?? process.env.MOONSHOT_API_KEY ?? null,
+            baseURL: options.baseURL ?? 'https://api.moonshot.ai/v1',
+        });
+    const maxTokens = options.maxTokens ?? 4096;
+    return async (messages, system, tools) => {
+        const response = await client.chat.completions.create({
+            model: options.model,
+            max_completion_tokens: maxTokens,
+            messages: [{ role: 'system', content: system }, ...messages.flatMap(toMessageParams)],
+            tools: tools.length
+                ? tools.map((t) => ({
+                    type: 'function',
+                    function: { name: t.name, description: t.description, parameters: t.input_schema },
+                }))
+                : undefined,
+        });
+        return toModelResponse(response.choices[0]);
+    };
+}

package/dist/index.d.ts

@@ -14,6 +14,12 @@ export { createOpenAIModelCall } from './core/model-calls/openai-model-call.js';
 export type { OpenAIModelCallOptions } from './core/model-calls/openai-model-call.js';
 export { createDeepSeekModelCall } from './core/model-calls/deepseek-model-call.js';
 export type { DeepSeekModelCallOptions } from './core/model-calls/deepseek-model-call.js';
+export { createKimiModelCall } from './core/model-calls/kimi-model-call.js';
+export type { KimiModelCallOptions } from './core/model-calls/kimi-model-call.js';
+export { createGlmModelCall } from './core/model-calls/glm-model-call.js';
+export type { GlmModelCallOptions } from './core/model-calls/glm-model-call.js';
+export { createGeminiModelCall } from './core/model-calls/gemini-model-call.js';
+export type { GeminiModelCallOptions } from './core/model-calls/gemini-model-call.js';
 export { discoverAgents, loadAgentModule, synthesizeCreateModelCall } from './core/discover-agents.js';
 export type { AgentModule } from './core/discover-agents.js';
 export { agentAsTool } from './core/agent-as-tool.js';

package/dist/index.js

@@ -16,6 +16,9 @@ export { VectorIndex, embed, cosineSimilarity } from './core/vector-index.js';
 export { createAnthropicModelCall } from './core/model-calls/anthropic-model-call.js';
 export { createOpenAIModelCall } from './core/model-calls/openai-model-call.js';
 export { createDeepSeekModelCall } from './core/model-calls/deepseek-model-call.js';
+export { createKimiModelCall } from './core/model-calls/kimi-model-call.js';
+export { createGlmModelCall } from './core/model-calls/glm-model-call.js';
+export { createGeminiModelCall } from './core/model-calls/gemini-model-call.js';
 export { discoverAgents, loadAgentModule, synthesizeCreateModelCall } from './core/discover-agents.js';
 export { agentAsTool } from './core/agent-as-tool.js';
 // Everything below backs the Admin UI (agents-config/list/global-config

package/dist/web/agent-file-admin.d.ts

@@ -2,7 +2,7 @@ export declare class AgentEditNotSupportedError extends Error {
 }
 export declare class AgentFileNotFoundError extends Error {
 }
-type Provider = 'anthropic' | 'openai' | 'deepseek';
+type Provider = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'glm' | 'gemini';
 export interface AgentEditableFields {
     systemPrompt?: string;
     model?: {

package/dist/web/agent-file-admin.js

@@ -45,6 +45,11 @@ const MODEL_ENV_VAR = {
     anthropic: 'ANTHROPIC_API_KEY',
     openai: 'OPENAI_API_KEY',
     deepseek: 'DEEPSEEK_API_KEY',
+    // Moonshot AI's own env var name, not KIMI_API_KEY — see
+    // core/model-calls/kimi-model-call.ts's own header comment for why.
+    kimi: 'MOONSHOT_API_KEY',
+    glm: 'GLM_API_KEY',
+    gemini: 'GEMINI_API_KEY',
 };
 // The exact shape agentIndexTemplate (bin/cli.ts) always generates for the
 // model field's trailing comment — used to recognize a comment this

package/dist/web/agents-config-page.js

@@ -653,7 +653,7 @@ export const agentsConfigPageHtml = `<!doctype html>
         '<form class="add-source" id="modelForm" style="display:none">' +
           '<label>Provider' +
             '<select name="provider">' +
-              ['anthropic', 'openai', 'deepseek'].map(function (p) {
+              ['anthropic', 'openai', 'deepseek', 'kimi', 'glm', 'gemini'].map(function (p) {
                 return '<option value="' + p + '"' + (p === cfg.model.provider ? ' selected' : '') + '>' + p + '</option>';
               }).join('') +
             '</select>' +

package/dist/web/global-config.d.ts

@@ -1,6 +1,6 @@
 import type { AgentConfig } from '../core/agent-config.js';
 export interface ModelProviderInfo {
-    provider: 'anthropic' | 'openai' | 'deepseek';
+    provider: 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'glm' | 'gemini';
     envVar: string;
     configured: boolean;
 }

package/dist/web/global-config.js

@@ -8,6 +8,11 @@ const KNOWN_PROVIDERS = [
     { provider: 'anthropic', envVar: 'ANTHROPIC_API_KEY' },
     { provider: 'openai', envVar: 'OPENAI_API_KEY' },
     { provider: 'deepseek', envVar: 'DEEPSEEK_API_KEY' },
+    // Moonshot AI's own env var name, not KIMI_API_KEY — see
+    // core/model-calls/kimi-model-call.ts's own header comment for why.
+    { provider: 'kimi', envVar: 'MOONSHOT_API_KEY' },
+    { provider: 'glm', envVar: 'GLM_API_KEY' },
+    { provider: 'gemini', envVar: 'GEMINI_API_KEY' },
 ];
 /** Every registered agent's resolved model, alongside whether each
  * supported provider actually has credentials available in this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",
@@ -41,6 +41,12 @@
     "dist/core/model-calls/openai-model-call.d.ts",
     "dist/core/model-calls/deepseek-model-call.js",
     "dist/core/model-calls/deepseek-model-call.d.ts",
+    "dist/core/model-calls/kimi-model-call.js",
+    "dist/core/model-calls/kimi-model-call.d.ts",
+    "dist/core/model-calls/glm-model-call.js",
+    "dist/core/model-calls/glm-model-call.d.ts",
+    "dist/core/model-calls/gemini-model-call.js",
+    "dist/core/model-calls/gemini-model-call.d.ts",
     "dist/core/discover-agents.js",
     "dist/core/discover-agents.d.ts",
     "dist/core/agent-as-tool.js",