@meetopenbot/github 0.1.0 → 0.1.1

package/README.md

@@ -4,7 +4,7 @@ GitHub specialist agent for OpenBot, backed by GitHub's official remote MCP.
 
 ## Setup
 
-The agent expects `OPENAI_API_KEY` in the environment.
+### GitHub token
 
 If no GitHub token is already available (plugin config, `GITHUB_TOKEN` env, or a workspace variable), the agent shows a form. Submitting it stores the token as a secret `GITHUB_TOKEN` workspace variable.
 
@@ -19,6 +19,12 @@ plugins:
 
 Create a Personal Access Token at [GitHub Developer Settings](https://github.com/settings/tokens) with `repo` scope.
 
+### OpenAI
+
+On cloud, `authMode: credits` (the default) uses your workspace credit balance via OpenBot. For BYOK, set `authMode: byok` and add `OPENAI_API_KEY` under workspace settings.
+
+Locally, the agent uses BYOK from `OPENAI_API_KEY` in the environment or workspace variables.
+
 ## Usage
 
 Ask things like:

package/dist/agent.js

@@ -1,7 +1,7 @@
 import { createMCPClient } from '@ai-sdk/mcp';
-import { createOpenAI } from '@ai-sdk/openai';
 import { toolTraceWidget } from '@meetopenbot/plugin-sdk';
 import { generateText, stepCountIs } from 'ai';
+import { resolveOpenAiModel } from './model.js';
 import { diffWidgetFromTool, prIdentityFromInput, shouldFollowUpPrFiles, toolInputFrom, unwrapToolOutput, } from './diff.js';
 export const GITHUB_MCP_URL = 'https://api.githubcopilot.com/mcp/';
 const TOOL_OUTPUT_MAX_LENGTH = 2_000;
@@ -106,9 +106,12 @@ export async function* runGithubAgent(args) {
     const agentTask = (async () => {
         try {
             const tools = await mcpClient.tools();
-            const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+            const model = resolveOpenAiModel(args.model ?? 'openai/gpt-4o', {
+                authMode: args.authMode,
+                openaiApiKey: args.openaiApiKey,
+            });
             const result = await generateText({
-                model: openai('gpt-4o'),
+                model,
                 stopWhen: stepCountIs(5),
                 system: SYSTEM_PROMPT,
                 prompt: args.prompt,

package/dist/cloud-mode.js

@@ -0,0 +1,10 @@
+/** True when this runtime is a platform-managed cloud deployment. */
+export const isCloudMode = () => process.env.OPENBOT_CLOUD_MODE === "1";
+/** Default auth mode: Credits on cloud, BYOK locally. */
+export const defaultAuthMode = () => isCloudMode() ? "credits" : "byok";
+export function resolveAuthMode(config) {
+    if (config.authMode === "byok" || config.authMode === "credits") {
+        return config.authMode;
+    }
+    return defaultAuthMode();
+}

package/dist/config.js

@@ -0,0 +1,74 @@
+import { resolveAuthMode } from "./cloud-mode.js";
+import { shouldUseCreditsAuth } from "./credits-auth.js";
+export const GITHUB_TOKEN_VAR = "GITHUB_TOKEN";
+function variableValue(variables, key) {
+    const entry = variables[key];
+    if (typeof entry === "string")
+        return entry || undefined;
+    return entry?.value || undefined;
+}
+export function readGithubConfig(config) {
+    return {
+        githubToken: typeof config.githubToken === "string" && config.githubToken.trim()
+            ? config.githubToken.trim()
+            : undefined,
+        authMode: config.authMode === "byok" || config.authMode === "credits"
+            ? config.authMode
+            : undefined,
+        model: typeof config.model === "string" && config.model.trim()
+            ? config.model.trim()
+            : undefined,
+    };
+}
+export function formatMissingCredentials(missing, authMode) {
+    const lines = [
+        "GitHub agent setup is incomplete. Configure the following in plugin config, workspace settings, or environment variables:",
+    ];
+    if (missing.includes("githubToken")) {
+        lines.push("- `githubToken` / `GITHUB_TOKEN` — GitHub Personal Access Token with repo scope");
+    }
+    if (missing.includes("openaiApiKey")) {
+        if (authMode === "credits") {
+            lines.push("- OpenAI API key is required in BYOK mode — add `OPENAI_API_KEY` under workspace settings, or switch `authMode` to `credits` on cloud");
+        }
+        else {
+            lines.push("- `OPENAI_API_KEY` — OpenAI API key for the agent loop (BYOK mode), or switch `authMode` to `credits` on cloud");
+        }
+    }
+    return lines.join("\n");
+}
+export async function resolveGithubCredentials(config, storage) {
+    const authMode = resolveAuthMode({ authMode: config.authMode });
+    const useCredits = shouldUseCreditsAuth({ authMode });
+    const variables = (await storage.getVariables().catch(() => ({})));
+    const resolve = (configKey, envKey) => {
+        const fromConfig = config[configKey];
+        if (typeof fromConfig === "string" && fromConfig.trim()) {
+            return fromConfig.trim();
+        }
+        if (process.env[envKey]?.trim())
+            return process.env[envKey].trim();
+        return variableValue(variables, envKey)?.trim();
+    };
+    const githubToken = resolve("githubToken", GITHUB_TOKEN_VAR);
+    const openaiApiKey = process.env.OPENAI_API_KEY?.trim() ||
+        variableValue(variables, "OPENAI_API_KEY");
+    const model = resolve("model", "OPENAI_MODEL") ?? "openai/gpt-4o";
+    const missing = [];
+    if (!githubToken)
+        missing.push("githubToken");
+    if (!useCredits && !openaiApiKey)
+        missing.push("openaiApiKey");
+    if (missing.length > 0) {
+        return { ok: false, missing, authMode };
+    }
+    return {
+        ok: true,
+        credentials: {
+            githubToken: githubToken,
+            authMode,
+            openaiApiKey: openaiApiKey || undefined,
+            model,
+        },
+    };
+}

package/dist/credits-auth.js

@@ -0,0 +1,53 @@
+import { isCloudMode } from "./cloud-mode.js";
+export const INTEGRATIONS_TOKEN_HEADER = "x-openbot-integrations-token";
+export const CREDITS_API_KEY_PLACEHOLDER = "openbot-credits";
+/** 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) {
+    return `${config.baseUrl}/openai/v1`;
+}
+export function shouldUseCreditsAuth(options) {
+    if (options?.authMode === "byok")
+        return false;
+    if (options?.authMode === "credits")
+        return true;
+    return isCloudMode() && resolveCreditsAuthConfig() !== undefined;
+}
+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"));
+}
+export function isIntegrationsProviderError(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes("provider api key not configured") ||
+        (lower.includes("503") && lower.includes("provider")));
+}
+export const CREDITS_NOT_CONFIGURED_MESSAGE = "OpenBot Credits is not configured on this runtime. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN (try redeploying the workspace).";
+export const CREDITS_PROVIDER_UNAVAILABLE_MESSAGE = "OpenBot Credits could not reach OpenAI — the platform provider API key is not configured yet. Try again later or switch this agent to BYOK mode.";
+export const CREDITS_AUTH_FAILED_MESSAGE = "GitHub could not authenticate via OpenBot Credits. Check your workspace credit balance in settings, or switch this agent to BYOK mode.";
+export function creditsErrorMessage(message) {
+    if (isIntegrationsProviderError(message)) {
+        return CREDITS_PROVIDER_UNAVAILABLE_MESSAGE;
+    }
+    if (isCreditsErrorMessage(message)) {
+        return "Insufficient workspace credits. Add credits in workspace settings or switch this agent to BYOK mode.";
+    }
+    if (isAuthErrorMessage(message))
+        return CREDITS_AUTH_FAILED_MESSAGE;
+    return undefined;
+}

package/dist/index.js

@@ -1,34 +1,39 @@
 import { definePlugin, shouldHandleInvoke, agentOutput, uiWidget, } from '@meetopenbot/plugin-sdk';
 import { runGithubAgent } from './agent.js';
-const GITHUB_TOKEN_VAR = 'GITHUB_TOKEN';
+import { isCloudMode } from './cloud-mode.js';
+import { CREDITS_NOT_CONFIGURED_MESSAGE, creditsErrorMessage, resolveCreditsAuthConfig, } from './credits-auth.js';
+import { formatMissingCredentials, GITHUB_TOKEN_VAR, readGithubConfig, resolveGithubCredentials, } from './config.js';
 const GITHUB_TOKEN_WIDGET_ID = 'github-token-form';
-function readVariable(variables, key) {
-    const stored = variables[key];
-    if (typeof stored === 'string')
-        return stored || undefined;
-    return stored?.value || undefined;
-}
+const githubPluginConfigSchema = {
+    type: 'object',
+    properties: {
+        ...(isCloudMode()
+            ? {
+                authMode: {
+                    type: 'string',
+                    description: 'Credits uses your workspace credit balance via OpenBot. BYOK uses `OPENAI_API_KEY` from workspace settings.',
+                    enum: ['credits', 'byok'],
+                    default: 'credits',
+                },
+            }
+            : {}),
+        githubToken: {
+            type: 'string',
+            description: 'GitHub Personal Access Token',
+            format: 'password',
+        },
+        model: {
+            type: 'string',
+            description: 'OpenAI model for GitHub agent invocations',
+            default: 'openai/gpt-4o',
+        },
+    },
+};
 export default definePlugin({
     name: 'GitHub',
     description: 'Manage GitHub repositories, issues, and pull requests',
-    configSchema: {
-        type: 'object',
-        properties: {
-            githubToken: {
-                type: 'string',
-                description: 'GitHub Personal Access Token',
-                format: 'password',
-            },
-        },
-    },
+    configSchema: githubPluginConfigSchema,
     factory: (context) => {
-        const getGithubToken = async () => {
-            const config = context.config;
-            const variables = await context.storage.getVariables();
-            return (config.githubToken ||
-                process.env.GITHUB_TOKEN ||
-                readVariable(variables, GITHUB_TOKEN_VAR));
-        };
         return (builder) => {
             builder.on('agent:invoke', async function* (event) {
                 if (!shouldHandleInvoke(event, context.agentId))
@@ -37,34 +42,55 @@ export default definePlugin({
                 const threadId = event.meta?.threadId;
                 if (!userMessage)
                     return;
-                const githubToken = await getGithubToken();
-                if (!githubToken) {
-                    yield uiWidget({
+                const githubConfig = readGithubConfig(context.config);
+                const auth = await resolveGithubCredentials(githubConfig, context.storage);
+                if (!auth.ok) {
+                    if (auth.missing.includes('githubToken')) {
+                        yield uiWidget({
+                            agentId: context.agentId,
+                            threadId,
+                            widget: {
+                                kind: 'form',
+                                widgetId: GITHUB_TOKEN_WIDGET_ID,
+                                title: 'GitHub Access Token',
+                                description: 'Enter a GitHub Personal Access Token with repo scope to continue.',
+                                fields: [
+                                    {
+                                        id: 'githubToken',
+                                        label: 'GitHub Access Token',
+                                        type: 'password',
+                                        placeholder: 'ghp_...',
+                                        required: true,
+                                    },
+                                ],
+                                submitLabel: 'Save Token',
+                            },
+                        });
+                        return;
+                    }
+                    yield agentOutput({
+                        agentId: context.agentId,
+                        content: formatMissingCredentials(auth.missing, auth.authMode),
+                        threadId,
+                    });
+                    return;
+                }
+                if (auth.credentials.authMode === 'credits' &&
+                    !resolveCreditsAuthConfig()) {
+                    yield agentOutput({
                         agentId: context.agentId,
+                        content: CREDITS_NOT_CONFIGURED_MESSAGE,
                         threadId,
-                        widget: {
-                            kind: 'form',
-                            widgetId: GITHUB_TOKEN_WIDGET_ID,
-                            title: 'GitHub Access Token',
-                            description: 'Enter a GitHub Personal Access Token with repo scope to continue.',
-                            fields: [
-                                {
-                                    id: 'githubToken',
-                                    label: 'GitHub Access Token',
-                                    type: 'password',
-                                    placeholder: 'ghp_...',
-                                    required: true,
-                                },
-                            ],
-                            submitLabel: 'Save Token',
-                        },
                     });
                     return;
                 }
                 try {
                     for await (const chunk of runGithubAgent({
                         prompt: userMessage,
-                        githubToken,
+                        githubToken: auth.credentials.githubToken,
+                        authMode: auth.credentials.authMode,
+                        openaiApiKey: auth.credentials.openaiApiKey,
+                        model: auth.credentials.model,
                     })) {
                         if (chunk.kind === 'widget') {
                             yield uiWidget({
@@ -85,9 +111,14 @@ export default definePlugin({
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
+                    const creditsMessage = auth.credentials.authMode === 'credits'
+                        ? creditsErrorMessage(message)
+                        : undefined;
                     yield agentOutput({
                         agentId: context.agentId,
-                        content: `I encountered an error: ${message}`,
+                        content: (creditsMessage ?? message)
+                            ? `I encountered an error: ${creditsMessage ?? message}`
+                            : 'GitHub agent failed for an unknown reason. Please try again.',
                         threadId,
                     });
                 }

package/dist/model.js

@@ -0,0 +1,24 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { CREDITS_API_KEY_PLACEHOLDER, INTEGRATIONS_TOKEN_HEADER, creditsProviderBaseUrl, resolveCreditsAuthConfig, shouldUseCreditsAuth, } from "./credits-auth.js";
+function normalizeOpenAiModelId(model) {
+    return model.includes("/") ? model.split("/").slice(1).join("/") : model;
+}
+export function resolveOpenAiModel(model, options) {
+    const modelId = normalizeOpenAiModelId(model);
+    const useCredits = shouldUseCreditsAuth(options);
+    if (useCredits) {
+        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);
+        const headers = { [INTEGRATIONS_TOKEN_HEADER]: config.token };
+        const apiKey = config.token || CREDITS_API_KEY_PLACEHOLDER;
+        return createOpenAI({ baseURL, apiKey, headers })(modelId);
+    }
+    const apiKey = options?.openaiApiKey?.trim();
+    if (!apiKey) {
+        throw new Error("OpenAI API key is required in BYOK mode. Add `OPENAI_API_KEY` under workspace settings or switch `authMode` to `credits` on cloud.");
+    }
+    return createOpenAI({ apiKey })(modelId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/github",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Manage GitHub repositories, issues, and pull requests from OpenBot",
   "type": "module",
   "main": "./dist/index.js",