@meetopenbot/openbot 0.1.1 → 0.1.2

package/dist/credits-auth.d.ts

@@ -0,0 +1,17 @@
+import type { OpenbotAuthMode } from './cloud-mode.js';
+export declare const INTEGRATIONS_TOKEN_HEADER = "x-openbot-integrations-token";
+export declare const CREDITS_API_KEY_PLACEHOLDER = "openbot-credits";
+export interface CreditsAuthConfig {
+    baseUrl: string;
+    token: string;
+}
+export type CreditsProviderId = 'openai' | 'anthropic';
+/** Cloud host injects these when routing LLM calls through OpenBot Credits. */
+export declare function resolveCreditsAuthConfig(): CreditsAuthConfig | undefined;
+export declare function creditsProviderBaseUrl(config: CreditsAuthConfig, provider: CreditsProviderId): string;
+export declare function shouldUseCreditsAuth(options?: {
+    authMode?: OpenbotAuthMode;
+    isCloudSystemAgent?: boolean;
+}): boolean;
+export declare function isCreditsErrorMessage(message: string): boolean;
+export declare function isAuthErrorMessage(message: string): boolean;

package/dist/credits-auth.js

@@ -0,0 +1,33 @@
+export const INTEGRATIONS_TOKEN_HEADER = 'x-openbot-integrations-token';
+export const CREDITS_API_KEY_PLACEHOLDER = 'openbot-credits';
+const CREDITS_PROVIDER_PATHS = {
+    openai: 'openai/v1',
+    anthropic: 'anthropic/v1',
+};
+/** Cloud host injects these when routing LLM calls through OpenBot Credits. */
+export function resolveCreditsAuthConfig() {
+    const baseUrl = process.env.OPENBOT_INTEGRATIONS_BASE_URL?.trim();
+    const token = process.env.OPENBOT_INTEGRATIONS_TOKEN?.trim();
+    if (!baseUrl || !token)
+        return undefined;
+    return { baseUrl: baseUrl.replace(/\/$/, ''), token };
+}
+export function creditsProviderBaseUrl(config, provider) {
+    return `${config.baseUrl}/${CREDITS_PROVIDER_PATHS[provider]}`;
+}
+export function shouldUseCreditsAuth(options) {
+    return options?.authMode === 'credits' && options?.isCloudSystemAgent === true;
+}
+export function isCreditsErrorMessage(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes('insufficient_credits') ||
+        lower.includes('insufficient credits') ||
+        lower.includes('402'));
+}
+export function isAuthErrorMessage(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes('api key') ||
+        lower.includes('401') ||
+        lower.includes('unauthorized') ||
+        lower.includes('authentication'));
+}

package/dist/model.d.ts

@@ -1,2 +1,7 @@
 import type { LanguageModel } from 'ai';
-export declare function resolveModel(modelString: string, _agentId?: string): LanguageModel;
+import type { OpenbotAuthMode } from './cloud-mode.js';
+export interface ResolveModelOptions {
+    authMode?: OpenbotAuthMode;
+    isCloudSystemAgent?: boolean;
+}
+export declare function resolveModel(modelString: string, options?: ResolveModelOptions): LanguageModel;

package/dist/model.js

@@ -1,18 +1,38 @@
-import { openai as defaultOpenai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
+import { createOpenAI, openai as defaultOpenai } from '@ai-sdk/openai';
+import { createAnthropic, anthropic } from '@ai-sdk/anthropic';
 import { google } from '@ai-sdk/google';
-export function resolveModel(modelString, _agentId) {
+import { CREDITS_API_KEY_PLACEHOLDER, INTEGRATIONS_TOKEN_HEADER, creditsProviderBaseUrl, resolveCreditsAuthConfig, shouldUseCreditsAuth, } from './credits-auth.js';
+function resolveCreditsProvider(provider, modelId) {
+    const config = resolveCreditsAuthConfig();
+    if (!config) {
+        throw new Error('OpenBot Credits is not configured. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN.');
+    }
+    const baseURL = creditsProviderBaseUrl(config, provider);
+    const headers = { [INTEGRATIONS_TOKEN_HEADER]: config.token };
+    const apiKey = CREDITS_API_KEY_PLACEHOLDER;
+    switch (provider) {
+        case 'openai':
+            return createOpenAI({ baseURL, apiKey, headers })(modelId);
+        case 'anthropic':
+            return createAnthropic({ baseURL, apiKey, headers })(modelId);
+    }
+}
+export function resolveModel(modelString, options) {
     const [provider, ...rest] = modelString.split('/');
     const modelId = rest.join('/');
     if (!modelId) {
         throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
     }
+    const useCredits = shouldUseCreditsAuth(options);
     switch (provider) {
         case 'openai':
-            return defaultOpenai(modelId);
+            return useCredits ? resolveCreditsProvider('openai', modelId) : defaultOpenai(modelId);
         case 'anthropic':
-            return anthropic(modelId);
+            return useCredits ? resolveCreditsProvider('anthropic', modelId) : anthropic(modelId);
         case 'google':
+            if (useCredits) {
+                throw new Error('Google models are not available via OpenBot Credits. Switch to an OpenAI or Anthropic model, or use BYOK mode.');
+            }
             return google(modelId);
         default:
             throw new Error(`Unsupported AI provider: "${provider}"`);

package/dist/runtime.js

@@ -2,6 +2,7 @@ import { generateText } from 'ai';
 import { eventsToModelMessages } from './history.js';
 import { buildContext } from './context.js';
 import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+import { isAuthErrorMessage, isCreditsErrorMessage } from './credits-auth.js';
 import { resolveModel } from './model.js';
 async function buildSystemPrompt(state, storage) {
     const context = await buildContext(state, storage);
@@ -68,7 +69,11 @@ function createToolBatchTracker(state, storage, channelId, threadId) {
 export const openbotRuntime = (options) => (builder) => {
     const { model: modelString = 'openai/gpt-4o-mini', authMode = 'byok', agentId, storage, toolDefinitions = {}, abortSignal, host, } = options;
     let currentModelString = modelString;
-    let model = resolveModel(currentModelString, agentId);
+    const resolveCurrentModel = () => resolveModel(currentModelString, {
+        authMode,
+        isCloudSystemAgent: host.isCloudSystemAgent(agentId ?? ''),
+    });
+    let model = resolveCurrentModel();
     const isCreditsCloudAgent = (id) => host.isCloudSystemAgent(id ?? '') && authMode === 'credits';
     const runLLM = async function* (context, threadId, trigger) {
         if (!storage)
@@ -162,11 +167,29 @@ export const openbotRuntime = (options) => (builder) => {
             if (abortSignal?.aborted)
                 return;
             const errorMessage = error instanceof Error ? error.message : String(error);
-            const isApiKeyError = errorMessage.includes('API key') ||
-                errorMessage.includes('401') ||
-                errorMessage.includes('Unauthorized') ||
-                errorMessage.includes('authentication');
-            if (isApiKeyError && !isCreditsCloudAgent(context.state.agentId)) {
+            if (isCreditsCloudAgent(context.state.agentId)) {
+                if (isCreditsErrorMessage(errorMessage)) {
+                    yield {
+                        type: 'agent:output',
+                        data: {
+                            content: 'Insufficient workspace credits. Add credits in workspace settings or switch this agent to BYOK mode.',
+                        },
+                        meta: { agentId: context.state.agentId, threadId },
+                    };
+                    return;
+                }
+                if (isAuthErrorMessage(errorMessage)) {
+                    yield {
+                        type: 'agent:output',
+                        data: {
+                            content: 'Could not authenticate via OpenBot Credits. Check your workspace credit balance in settings, or switch this agent to BYOK mode.',
+                        },
+                        meta: { agentId: context.state.agentId, threadId },
+                    };
+                    return;
+                }
+            }
+            if (isAuthErrorMessage(errorMessage) && !isCreditsCloudAgent(context.state.agentId)) {
                 const registry = await host.resolveModelRegistry();
                 const providerActions = host.listApiKeyProvidersFromRegistry(registry).map((provider) => ({
                     id: provider.id,
@@ -340,7 +363,7 @@ export const openbotRuntime = (options) => (builder) => {
             await storage.createVariable({ key: envVar, value: apiKey, secret: true });
             process.env[envVar] = apiKey;
             currentModelString = newModelString;
-            model = resolveModel(currentModelString, agentId);
+            model = resolveCurrentModel();
             try {
                 host.saveConfig({ model: currentModelString });
                 const details = await storage.getAgentDetails({ agentId: context.state.agentId });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Monolithic OpenBot agent runtime with batteries-included tools.",
   "type": "module",
   "main": "dist/index.js",