@meetopenbot/github 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,145 +1,19 @@
-import { definePlugin, shouldHandleInvoke, agentOutput, uiWidget, } from '@meetopenbot/plugin-sdk';
-import { runGithubAgent } from './agent.js';
-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';
-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({
+import { defineMcpAgent } from '@meetopenbot/plugin-sdk';
+export const plugin = await defineMcpAgent({
     name: 'GitHub',
     description: 'Manage GitHub repositories, issues, and pull requests',
-    configSchema: githubPluginConfigSchema,
-    factory: (context) => {
-        return (builder) => {
-            builder.on('agent:invoke', async function* (event) {
-                if (!shouldHandleInvoke(event, context.agentId))
-                    return;
-                const userMessage = event.data?.content || '';
-                const threadId = event.meta?.threadId;
-                if (!userMessage)
-                    return;
-                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,
-                    });
-                    return;
-                }
-                try {
-                    for await (const chunk of runGithubAgent({
-                        prompt: userMessage,
-                        githubToken: auth.credentials.githubToken,
-                        authMode: auth.credentials.authMode,
-                        openaiApiKey: auth.credentials.openaiApiKey,
-                        model: auth.credentials.model,
-                    })) {
-                        if (chunk.kind === 'widget') {
-                            yield uiWidget({
-                                agentId: context.agentId,
-                                threadId,
-                                widget: chunk.widget,
-                                meta: event.meta,
-                            });
-                            continue;
-                        }
-                        yield agentOutput({
-                            agentId: context.agentId,
-                            content: chunk.content,
-                            threadId,
-                            meta: event.meta,
-                        });
-                    }
-                }
-                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: (creditsMessage ?? message)
-                            ? `I encountered an error: ${creditsMessage ?? message}`
-                            : 'GitHub agent failed for an unknown reason. Please try again.',
-                        threadId,
-                    });
-                }
-            });
-            builder.on('client:ui:widget:response', async function* (event) {
-                if (event.data?.widgetId !== GITHUB_TOKEN_WIDGET_ID)
-                    return;
-                const githubToken = event.data.values?.githubToken;
-                if (typeof githubToken !== 'string' || !githubToken.trim())
-                    return;
-                await context.storage.createVariable({
-                    key: GITHUB_TOKEN_VAR,
-                    value: githubToken.trim(),
-                    secret: true,
-                });
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: 'GitHub access token saved. Retry your last request.',
-                    threadId: event.meta?.threadId,
-                });
-            });
-        };
+    models: { providers: ['openai'], default: 'openai/gpt-4o-mini' },
+    secret: { envKeys: ['GITHUB_TOKEN'] },
+    mcp: {
+        url: 'https://api.githubcopilot.com/mcp/',
+        headers: (token) => ({
+            Authorization: `Bearer ${token}`,
+            'X-MCP-Toolsets': 'repos,issues,pull_requests',
+        }),
     },
+    system: `You are a GitHub assistant. Use the GitHub MCP tools to help with repositories, issues, and pull requests.
+Parse owner/repo from "owner/repo" when the user provides that format.
+Be concise and helpful.`,
+    maxSteps: 5,
 });
+export default plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/github",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Manage GitHub repositories, issues, and pull requests from OpenBot",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,10 +8,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@ai-sdk/mcp": "^2.0.14",
-    "@ai-sdk/openai": "^4.0.15",
-    "ai": "^7.0.29",
-    "@meetopenbot/plugin-sdk": "^0.2.0"
+    "@meetopenbot/plugin-sdk": "^0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -33,7 +30,6 @@
     "build": "tsc && node ../../scripts/write-plugin-declaration.mjs",
     "start": "node dist/index.js",
     "dev": "tsc --watch --preserveWatchOutput",
-    "typecheck": "tsc --noEmit",
-    "test": "node --experimental-strip-types --test src/diff.test.ts"
+    "typecheck": "tsc --noEmit"
   }
 }

package/dist/agent.js

@@ -1,191 +0,0 @@
-import { createMCPClient } from '@ai-sdk/mcp';
-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;
-function formatToolOutput(output) {
-    if (output === undefined || output === null)
-        return 'Done.';
-    if (typeof output === 'string')
-        return truncate(output);
-    try {
-        return truncate(JSON.stringify(output, null, 2));
-    }
-    catch {
-        return truncate(String(output));
-    }
-}
-function truncate(text) {
-    if (text.length <= TOOL_OUTPUT_MAX_LENGTH)
-        return text;
-    return `${text.slice(0, TOOL_OUTPUT_MAX_LENGTH)}…`;
-}
-function toolCallWidget(args) {
-    return toolTraceWidget({
-        widgetId: args.widgetId,
-        groupId: 'github:tools',
-        title: args.title,
-        body: args.body,
-    });
-}
-function findMcpTool(tools, name) {
-    const direct = tools[name];
-    if (direct)
-        return direct;
-    const needle = name.toLowerCase();
-    for (const [key, tool] of Object.entries(tools)) {
-        if (key.toLowerCase() === needle || key.toLowerCase().includes(needle)) {
-            return tool;
-        }
-    }
-    return undefined;
-}
-async function fetchPrFilesDiffWidget(args) {
-    const identity = prIdentityFromInput(args.input);
-    if (!identity)
-        return null;
-    const tool = findMcpTool(args.tools, 'pull_request_read');
-    if (!tool?.execute)
-        return null;
-    try {
-        const output = await tool.execute({
-            method: 'get_files',
-            owner: identity.owner,
-            repo: identity.repo,
-            pullNumber: identity.pullNumber,
-            perPage: 100,
-        }, { toolCallId: args.widgetId, messages: [] });
-        return diffWidgetFromTool({
-            widgetId: args.widgetId,
-            toolName: args.toolName,
-            input: {
-                ...(typeof args.input === 'object' && args.input ? args.input : {}),
-                method: 'get_files',
-                ...identity,
-            },
-            output,
-        });
-    }
-    catch {
-        return null;
-    }
-}
-const SYSTEM_PROMPT = `You are a GitHub assistant. Use the GitHub MCP tools to help with repositories, issues, and pull requests.
-Parse owner/repo from "owner/repo" when the user provides that format.
-Be concise and helpful.
-
-When the user asks to inspect, review, or see a pull request, commit, or code change:
-- Call pull_request_read with method get for title/author/status if needed.
-- Always also call pull_request_read with method get_files (preferred; includes per-file patches) or get_diff.
-A Diff widget is rendered from that file/diff result — keep your text reply to a short summary, not a pasted patch.`;
-export async function* runGithubAgent(args) {
-    const mcpClient = await createMCPClient({
-        transport: {
-            type: 'http',
-            url: GITHUB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${args.githubToken}`,
-                'X-MCP-Toolsets': 'repos,issues,pull_requests',
-            },
-        },
-    });
-    const queue = [];
-    let wake;
-    let agentDone = false;
-    let agentError;
-    const enqueue = (event) => {
-        queue.push(event);
-        wake?.();
-        wake = undefined;
-    };
-    const waitForQueue = () => new Promise((resolve) => {
-        wake = resolve;
-    });
-    const agentTask = (async () => {
-        try {
-            const tools = await mcpClient.tools();
-            const model = resolveOpenAiModel(args.model ?? 'openai/gpt-4o', {
-                authMode: args.authMode,
-                openaiApiKey: args.openaiApiKey,
-            });
-            const result = await generateText({
-                model,
-                stopWhen: stepCountIs(5),
-                system: SYSTEM_PROMPT,
-                prompt: args.prompt,
-                tools,
-                onToolExecutionStart: ({ toolCall }) => {
-                    enqueue({
-                        kind: 'widget',
-                        widget: toolCallWidget({
-                            widgetId: toolCall.toolCallId,
-                            title: toolCall.toolName,
-                        }),
-                    });
-                },
-                onToolExecutionEnd: async ({ toolCall, toolOutput }) => {
-                    const input = toolInputFrom(toolCall, toolOutput);
-                    const payload = unwrapToolOutput(toolOutput);
-                    enqueue({
-                        kind: 'widget',
-                        widget: toolCallWidget({
-                            widgetId: toolCall.toolCallId,
-                            title: toolCall.toolName,
-                            body: formatToolOutput(payload),
-                        }),
-                    });
-                    const widgetId = `github-diff:${toolCall.toolCallId}`;
-                    let widget = diffWidgetFromTool({
-                        widgetId,
-                        toolName: toolCall.toolName,
-                        input,
-                        output: payload,
-                    });
-                    if (!widget &&
-                        shouldFollowUpPrFiles({
-                            toolName: toolCall.toolName,
-                            input,
-                            hasDiffWidget: false,
-                        })) {
-                        widget = await fetchPrFilesDiffWidget({
-                            tools: tools,
-                            widgetId,
-                            toolName: toolCall.toolName,
-                            input,
-                        });
-                    }
-                    if (widget)
-                        enqueue({ kind: 'widget', widget });
-                },
-            });
-            if (result.text.trim()) {
-                enqueue({ kind: 'reply', content: result.text.trim() });
-            }
-        }
-        catch (error) {
-            agentError = error;
-        }
-        finally {
-            agentDone = true;
-            wake?.();
-            wake = undefined;
-        }
-    })();
-    try {
-        while (!agentDone || queue.length > 0) {
-            if (queue.length === 0) {
-                await waitForQueue();
-                continue;
-            }
-            yield queue.shift();
-        }
-        await agentTask;
-        if (agentError)
-            throw agentError;
-    }
-    finally {
-        await mcpClient.close().catch(() => undefined);
-    }
-}

package/dist/cloud-mode.js

@@ -1,10 +0,0 @@
-/** 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

@@ -1,74 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/diff.js

@@ -1,346 +0,0 @@
-const MAX_FILES = 40;
-const MAX_PATCH_CHARS = 48_000;
-const LANG_BY_EXT = {
-    ts: 'typescript',
-    tsx: 'tsx',
-    js: 'javascript',
-    jsx: 'jsx',
-    mjs: 'javascript',
-    cjs: 'javascript',
-    py: 'python',
-    go: 'go',
-    rs: 'rust',
-    rb: 'ruby',
-    java: 'java',
-    kt: 'kotlin',
-    swift: 'swift',
-    cs: 'csharp',
-    cpp: 'cpp',
-    cc: 'cpp',
-    cxx: 'cpp',
-    c: 'c',
-    h: 'c',
-    hpp: 'cpp',
-    md: 'markdown',
-    json: 'json',
-    css: 'css',
-    scss: 'scss',
-    html: 'html',
-    yml: 'yaml',
-    yaml: 'yaml',
-    toml: 'toml',
-    sh: 'bash',
-    bash: 'bash',
-    zsh: 'bash',
-    sql: 'sql',
-};
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function asString(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-function asNumber(value) {
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (typeof value === 'string' && value.trim() !== '') {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed))
-            return parsed;
-    }
-    return undefined;
-}
-function languageFromPath(path) {
-    const base = path.split('/').pop() ?? path;
-    const ext = base.includes('.') ? base.slice(base.lastIndexOf('.') + 1).toLowerCase() : '';
-    return LANG_BY_EXT[ext];
-}
-function mapStatus(status, oldPath) {
-    switch (status) {
-        case 'added':
-            return 'added';
-        case 'removed':
-        case 'deleted':
-            return 'deleted';
-        case 'renamed':
-        case 'copied':
-            return 'renamed';
-        default:
-            return oldPath ? 'renamed' : 'modified';
-    }
-}
-function countPatchStats(patch) {
-    let additions = 0;
-    let deletions = 0;
-    for (const line of patch.split('\n')) {
-        if (line.startsWith('+') && !line.startsWith('+++'))
-            additions += 1;
-        else if (line.startsWith('-') && !line.startsWith('---'))
-            deletions += 1;
-    }
-    return { additions, deletions };
-}
-function capPatch(patch) {
-    if (!patch)
-        return {};
-    if (patch.length <= MAX_PATCH_CHARS)
-        return { patch };
-    return { patch: patch.slice(0, MAX_PATCH_CHARS), truncated: true };
-}
-export function unwrapToolOutput(output) {
-    if (output == null)
-        return output;
-    if (typeof output === 'string') {
-        const trimmed = output.trim();
-        if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-            try {
-                return JSON.parse(trimmed);
-            }
-            catch {
-                return output;
-            }
-        }
-        return output;
-    }
-    if (Array.isArray(output)) {
-        if (output.length > 0 &&
-            output.every((part) => typeof part === 'string' ||
-                (isRecord(part) && (typeof part.text === 'string' || typeof part.value === 'string')))) {
-            const text = output
-                .map((part) => {
-                if (typeof part === 'string')
-                    return part;
-                if (isRecord(part))
-                    return asString(part.text) ?? asString(part.value) ?? '';
-                return '';
-            })
-                .join('\n');
-            return unwrapToolOutput(text);
-        }
-        return output;
-    }
-    if (isRecord(output)) {
-        // AI SDK onToolExecutionEnd passes { type: 'tool-result', output } / { type: 'tool-error', error }.
-        if (output.type === 'tool-result' && 'output' in output) {
-            return unwrapToolOutput(output.output);
-        }
-        if (output.type === 'tool-error' && 'error' in output) {
-            return unwrapToolOutput(output.error);
-        }
-        if (typeof output.text === 'string' && Object.keys(output).length <= 3) {
-            return unwrapToolOutput(output.text);
-        }
-        if (Array.isArray(output.content))
-            return unwrapToolOutput(output.content);
-        if ('value' in output)
-            return unwrapToolOutput(output.value);
-    }
-    return output;
-}
-/** Prefer the AI SDK tool-result input; fall back to the tool call. */
-export function toolInputFrom(toolCall, toolOutput) {
-    if (isRecord(toolOutput) && 'input' in toolOutput)
-        return toolOutput.input;
-    if (isRecord(toolCall) && 'input' in toolCall)
-        return toolCall.input;
-    return undefined;
-}
-export function prIdentityFromInput(input) {
-    if (!isRecord(input))
-        return null;
-    const owner = asString(input.owner);
-    const repo = asString(input.repo);
-    const pullNumber = asNumber(input.pullNumber) ?? asNumber(input.pull_number);
-    if (!owner || !repo || pullNumber == null)
-        return null;
-    return { owner, repo, pullNumber };
-}
-const PR_FILE_FOLLOW_UP_METHODS = new Set(['get', 'get_files', 'get_diff']);
-/** True when pull_request_read didn't yield a Diff widget but we can still fetch files. */
-export function shouldFollowUpPrFiles(args) {
-    if (args.hasDiffWidget)
-        return false;
-    if (!args.toolName.toLowerCase().includes('pull_request_read'))
-        return false;
-    if (!prIdentityFromInput(args.input))
-        return false;
-    const method = isRecord(args.input) ? asString(args.input.method)?.toLowerCase() : undefined;
-    if (!method)
-        return true;
-    return PR_FILE_FOLLOW_UP_METHODS.has(method);
-}
-function toDiffFile(file) {
-    const path = asString(file.filename);
-    if (!path)
-        return null;
-    const oldPath = asString(file.previous_filename);
-    const rawPatch = asString(file.patch);
-    const capped = capPatch(rawPatch);
-    const stats = rawPatch ? countPatchStats(rawPatch) : { additions: 0, deletions: 0 };
-    return {
-        path,
-        ...(oldPath ? { oldPath } : {}),
-        status: mapStatus(asString(file.status), oldPath),
-        ...(languageFromPath(path) ? { language: languageFromPath(path) } : {}),
-        additions: asNumber(file.additions) ?? (stats.additions || undefined),
-        deletions: asNumber(file.deletions) ?? (stats.deletions || undefined),
-        ...capped,
-    };
-}
-export function splitUnifiedDiff(raw) {
-    const text = raw.replace(/\r\n/g, '\n');
-    const starts = [];
-    const header = /^diff --git /gm;
-    let match;
-    while ((match = header.exec(text)))
-        starts.push(match.index);
-    if (starts.length === 0) {
-        if (!text.trim())
-            return [];
-        const stats = countPatchStats(text);
-        const capped = capPatch(text);
-        return [
-            {
-                path: 'diff',
-                status: 'modified',
-                additions: stats.additions || undefined,
-                deletions: stats.deletions || undefined,
-                ...capped,
-            },
-        ];
-    }
-    return starts
-        .map((start, index) => {
-        const chunk = text.slice(start, starts[index + 1]);
-        const names = /^diff --git a\/(.+?) b\/(.+)$/m.exec(chunk);
-        const oldPath = names?.[1] ?? 'unknown';
-        const path = names?.[2] ?? oldPath;
-        let status = 'modified';
-        if (/^new file mode /m.test(chunk) || oldPath === '/dev/null')
-            status = 'added';
-        else if (/^deleted file mode /m.test(chunk) || path === '/dev/null')
-            status = 'deleted';
-        else if (/^rename from /m.test(chunk) || oldPath !== path)
-            status = 'renamed';
-        const stats = countPatchStats(chunk);
-        return {
-            path: path === '/dev/null' ? oldPath : path,
-            ...(status === 'renamed' && oldPath !== path ? { oldPath } : {}),
-            status,
-            ...(languageFromPath(path) ? { language: languageFromPath(path) } : {}),
-            additions: stats.additions || undefined,
-            deletions: stats.deletions || undefined,
-            ...capPatch(chunk),
-        };
-    })
-        .slice(0, MAX_FILES);
-}
-function githubFileFromUnknown(item) {
-    if (!isRecord(item))
-        return null;
-    const filename = asString(item.filename) ?? asString(item.path) ?? asString(item.name);
-    if (!filename)
-        return null;
-    return {
-        filename,
-        previous_filename: asString(item.previous_filename) ??
-            asString(item.previousFilename) ??
-            asString(item.oldPath) ??
-            asString(item.old_path),
-        status: item.status,
-        additions: item.additions,
-        deletions: item.deletions,
-        patch: item.patch,
-    };
-}
-function filesFromUnknown(payload) {
-    if (Array.isArray(payload)) {
-        const files = payload
-            .map(githubFileFromUnknown)
-            .filter((file) => file != null);
-        return files.length > 0 ? files : null;
-    }
-    if (isRecord(payload) && Array.isArray(payload.files)) {
-        return filesFromUnknown(payload.files);
-    }
-    return null;
-}
-function isChangedFilePayload(payload) {
-    const files = filesFromUnknown(payload);
-    if (!files?.length)
-        return false;
-    return files.some((file) => typeof file.patch === 'string' ||
-        typeof file.status === 'string' ||
-        typeof file.additions === 'number' ||
-        typeof file.deletions === 'number');
-}
-function summarize(files) {
-    const additions = files.reduce((sum, file) => sum + (file.additions ?? 0), 0);
-    const deletions = files.reduce((sum, file) => sum + (file.deletions ?? 0), 0);
-    const fileLabel = files.length === 1 ? '1 file' : `${files.length} files`;
-    if (!additions && !deletions)
-        return fileLabel;
-    return `${fileLabel} · +${additions} −${deletions}`;
-}
-function titleFromInput(input) {
-    if (!input)
-        return 'Diff';
-    const owner = asString(input.owner);
-    const repo = asString(input.repo);
-    const pullNumber = asNumber(input.pullNumber) ?? asNumber(input.pull_number);
-    const sha = asString(input.sha);
-    if (owner && repo && pullNumber != null)
-        return `${owner}/${repo}#${pullNumber}`;
-    if (owner && repo && sha)
-        return `${owner}/${repo}@${sha.slice(0, 7)}`;
-    if (owner && repo)
-        return `${owner}/${repo}`;
-    return 'Diff';
-}
-function filesFromPayload(payload) {
-    if (typeof payload === 'string') {
-        const trimmed = payload.trim();
-        if (trimmed.startsWith('diff --git') || trimmed.startsWith('@@')) {
-            return splitUnifiedDiff(payload);
-        }
-        return null;
-    }
-    const githubFiles = filesFromUnknown(payload);
-    if (!githubFiles)
-        return null;
-    const files = githubFiles
-        .map(toDiffFile)
-        .filter((file) => file != null)
-        .slice(0, MAX_FILES);
-    return files.length > 0 ? files : null;
-}
-export function diffWidgetFromTool(args) {
-    const toolName = args.toolName.toLowerCase();
-    const input = isRecord(args.input) ? args.input : undefined;
-    const method = asString(input?.method)?.toLowerCase();
-    const payload = unwrapToolOutput(args.output);
-    const looksLikeDiffTool = (toolName.includes('pull_request_read') &&
-        (method === 'get_files' || method === 'get_diff')) ||
-        toolName.includes('get_commit') ||
-        toolName.includes('get_diff') ||
-        (typeof payload === 'string' && payload.trim().startsWith('diff --git')) ||
-        isChangedFilePayload(payload);
-    if (!looksLikeDiffTool)
-        return null;
-    const files = filesFromPayload(payload);
-    if (!files || files.length === 0)
-        return null;
-    return {
-        kind: 'diff',
-        widgetId: args.widgetId,
-        title: titleFromInput(input),
-        description: summarize(files),
-        files,
-        size: 'full',
-        display: 'expanded',
-        metadata: {
-            toolName: args.toolName,
-            ...(method ? { method } : {}),
-        },
-    };
-}

package/dist/model.js

@@ -1,24 +0,0 @@
-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);
-}