@meetopenbot/linear 0.0.3 → 0.0.5

package/dist/mcp-tool-args.js

@@ -0,0 +1,38 @@
+export function sanitizeMcpToolArgs(args) {
+    if (args === null || args === undefined)
+        return args;
+    if (typeof args !== "object" || Array.isArray(args))
+        return args;
+    const result = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (value === "")
+            continue;
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            const nested = sanitizeMcpToolArgs(value);
+            if (nested &&
+                typeof nested === "object" &&
+                !Array.isArray(nested) &&
+                Object.keys(nested).length > 0) {
+                result[key] = nested;
+            }
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+export function wrapMcpTools(tools) {
+    const wrapped = { ...tools };
+    for (const [name, tool] of Object.entries(tools)) {
+        if (!tool.execute)
+            continue;
+        const originalExecute = tool.execute.bind(tool);
+        wrapped[name] = {
+            ...tool,
+            execute: (input, options) => originalExecute(sanitizeMcpToolArgs(input), options),
+        };
+    }
+    return wrapped;
+}

package/dist/model-registry.js

@@ -0,0 +1,40 @@
+const REGISTRY_URL = "https://raw.githubusercontent.com/meetopenbot/openbot-registry/main/registry.json";
+const OPENAI_PROVIDER = "openai";
+const freeInputModelField = () => ({
+    type: "string",
+    override: true,
+    description: "OpenAI model in provider/model-id format (e.g. openai/gpt-4o-mini).",
+    default: "openai/gpt-4o-mini",
+});
+/** Registry-backed model field for plugin configSchema (`enum` + labeled `options`). */
+export async function resolveModelConfigField() {
+    try {
+        const res = await fetch(REGISTRY_URL, {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok)
+            return freeInputModelField();
+        const registry = (await res.json());
+        const provider = registry.providers?.[OPENAI_PROVIDER];
+        const models = provider?.models ?? [];
+        if (models.length === 0)
+            return freeInputModelField();
+        const defaultModel = models.find((model) => model.id === "gpt-4o-mini")?.id ?? models[0].id;
+        return {
+            type: "string",
+            override: true,
+            description: "OpenAI model from the OpenBot registry.",
+            default: `${OPENAI_PROVIDER}/${defaultModel}`,
+            enum: models.map((model) => `${OPENAI_PROVIDER}/${model.id}`),
+            options: models.map((model) => ({
+                label: `${provider?.label ?? "OpenAI"} — ${model.label}`,
+                value: `${OPENAI_PROVIDER}/${model.id}`,
+                description: model.description,
+            })),
+        };
+    }
+    catch {
+        return freeInputModelField();
+    }
+}

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/dist/thread-context.js

@@ -0,0 +1,72 @@
+export const MAX_THREAD_CONTEXT_LINES = 20;
+export function threadEventsToContextLines(events, agentId) {
+    const lines = [];
+    for (const raw of events) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const event = raw;
+        if (event.meta?.parentToolCallId)
+            continue;
+        switch (event.type) {
+            case "agent:invoke": {
+                const role = event.data?.role ?? "user";
+                const content = typeof event.data?.content === "string"
+                    ? event.data.content.trim()
+                    : "";
+                if (role === "user" && content) {
+                    lines.push({ role: "user", content });
+                }
+                break;
+            }
+            case "agent:output": {
+                if (event.meta?.agentId !== agentId)
+                    break;
+                const content = typeof event.data?.content === "string"
+                    ? event.data.content.trim()
+                    : "";
+                if (!content)
+                    break;
+                const last = lines[lines.length - 1];
+                if (last?.role === "assistant") {
+                    last.content += content;
+                }
+                else {
+                    lines.push({ role: "assistant", content });
+                }
+                break;
+            }
+        }
+    }
+    if (lines.length > MAX_THREAD_CONTEXT_LINES) {
+        return lines.slice(-MAX_THREAD_CONTEXT_LINES);
+    }
+    return lines;
+}
+export function formatThreadContext(lines) {
+    if (lines.length === 0)
+        return "";
+    const jsonl = lines.map((line) => JSON.stringify(line)).join("\n");
+    return `Previous conversation context (most recent last):\n${jsonl}`;
+}
+export async function loadThreadContext(storage, args) {
+    if (!args.channelId)
+        return "";
+    try {
+        const events = await storage.getEvents({
+            channelId: args.channelId,
+            threadId: args.threadId,
+        });
+        let lines = threadEventsToContextLines(events, args.agentId);
+        const currentMessage = args.currentMessage?.trim();
+        if (currentMessage) {
+            const last = lines[lines.length - 1];
+            if (last?.role === "user" && last.content === currentMessage) {
+                lines = lines.slice(0, -1);
+            }
+        }
+        return formatThreadContext(lines);
+    }
+    catch {
+        return "";
+    }
+}

package/package.json

@@ -1,41 +1,30 @@
 {
   "name": "@meetopenbot/linear",
-  "version": "0.0.3",
-  "description": "Linear OAuth connect flow and MCP-backed agent for issues, projects, and comments",
+  "version": "0.0.5",
+  "description": "Linear MCP-backed specialist agent for OpenBot",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "src",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
+  "exports": {
+    ".": "./dist/index.js"
   },
   "publishConfig": {
     "access": "public"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/meetopenbot/plugin-linear.git"
-  },
-  "keywords": [
-    "openbot",
-    "plugin",
-    "linear",
-    "oauth"
+  "files": [
+    "dist"
   ],
+  "scripts": {
+    "build": "tsc"
+  },
   "dependencies": {
     "@ai-sdk/mcp": "^2.0.14",
     "@ai-sdk/openai": "^4.0.15",
     "@meetopenbot/plugin-sdk": "^0.1.8",
-    "ai": "^7.0.29",
-    "mcp-server-linear": "^1.6.0"
+    "ai": "^7.0.29"
   },
   "devDependencies": {
-    "@types/node": "^25.9.1",
-    "typescript": "^6.0.3"
+    "@types/node": "^20.10.1",
+    "typescript": "^5.9.3"
   }
 }

package/dist/api.d.ts

@@ -1,94 +0,0 @@
-/**
- * Thin Linear GraphQL client over fetch. We use raw GraphQL instead of
- * @linear/sdk so list queries resolve relations (state, assignee, team) in a
- * single request and the plugin stays dependency-light.
- */
-export declare const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
-export type LinearAuth = {
-    kind: 'apiKey';
-    token: string;
-} | {
-    kind: 'oauth';
-    token: string;
-};
-export declare class LinearApiError extends Error {
-    readonly status?: number | undefined;
-    constructor(message: string, status?: number | undefined);
-}
-export declare function linearRequest<T = Record<string, unknown>>(auth: LinearAuth, query: string, variables?: Record<string, unknown>): Promise<T>;
-export declare const ISSUE_FIELDS = "\n  id\n  identifier\n  title\n  description\n  priority\n  priorityLabel\n  url\n  createdAt\n  updatedAt\n  dueDate\n  state { id name type }\n  assignee { id name displayName }\n  team { id key name }\n  project { id name }\n  labels { nodes { id name } }\n";
-export interface LinearIssue {
-    id: string;
-    identifier: string;
-    title: string;
-    description?: string | null;
-    priority: number;
-    priorityLabel: string;
-    url: string;
-    createdAt: string;
-    updatedAt: string;
-    dueDate?: string | null;
-    state?: {
-        id: string;
-        name: string;
-        type: string;
-    } | null;
-    assignee?: {
-        id: string;
-        name: string;
-        displayName: string;
-    } | null;
-    team?: {
-        id: string;
-        key: string;
-        name: string;
-    } | null;
-    project?: {
-        id: string;
-        name: string;
-    } | null;
-    labels?: {
-        nodes: Array<{
-            id: string;
-            name: string;
-        }>;
-    } | null;
-}
-/** Compact issue representation returned to the model/tool caller. */
-export declare function formatIssue(issue: LinearIssue): {
-    id: string;
-    identifier: string;
-    title: string;
-    description: string | undefined;
-    state: string | undefined;
-    stateType: string | undefined;
-    priority: string;
-    assignee: string | undefined;
-    team: string | undefined;
-    project: string | undefined;
-    labels: string[] | undefined;
-    dueDate: string | undefined;
-    url: string;
-    updatedAt: string;
-};
-export declare function fetchViewer(auth: LinearAuth): Promise<{
-    viewer: {
-        id: string;
-        name: string;
-        displayName: string;
-        email: string;
-    };
-    organization: {
-        id: string;
-        name: string;
-        urlKey: string;
-    };
-}>;
-/** Resolve a team by UUID, key (e.g. "ENG"), or exact name. */
-export declare function resolveTeam(auth: LinearAuth, team: string): Promise<{
-    id: string;
-    key: string;
-    name: string;
-} | {
-    id: string;
-}>;

package/dist/api.js

@@ -1,93 +0,0 @@
-/**
- * Thin Linear GraphQL client over fetch. We use raw GraphQL instead of
- * @linear/sdk so list queries resolve relations (state, assignee, team) in a
- * single request and the plugin stays dependency-light.
- */
-export const LINEAR_GRAPHQL_URL = 'https://api.linear.app/graphql';
-export class LinearApiError extends Error {
-    status;
-    constructor(message, status) {
-        super(message);
-        this.status = status;
-        this.name = 'LinearApiError';
-    }
-}
-export async function linearRequest(auth, query, variables) {
-    const response = await fetch(LINEAR_GRAPHQL_URL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            // Personal API keys are sent bare; OAuth tokens use the Bearer scheme.
-            Authorization: auth.kind === 'apiKey' ? auth.token : `Bearer ${auth.token}`,
-        },
-        body: JSON.stringify({ query, variables }),
-    });
-    if (!response.ok) {
-        const body = await response.text().catch(() => '');
-        if (response.status === 401) {
-            throw new LinearApiError('Linear rejected the credentials (401). Reconnect with `linear_connect` or update the API key.', 401);
-        }
-        throw new LinearApiError(`Linear API request failed (${response.status}): ${body.slice(0, 500)}`, response.status);
-    }
-    const payload = (await response.json());
-    if (payload.errors?.length) {
-        throw new LinearApiError(payload.errors.map((e) => e.message).join('; '));
-    }
-    if (!payload.data) {
-        throw new LinearApiError('Linear API returned no data.');
-    }
-    return payload.data;
-}
-export const ISSUE_FIELDS = `
-  id
-  identifier
-  title
-  description
-  priority
-  priorityLabel
-  url
-  createdAt
-  updatedAt
-  dueDate
-  state { id name type }
-  assignee { id name displayName }
-  team { id key name }
-  project { id name }
-  labels { nodes { id name } }
-`;
-/** Compact issue representation returned to the model/tool caller. */
-export function formatIssue(issue) {
-    return {
-        id: issue.id,
-        identifier: issue.identifier,
-        title: issue.title,
-        description: issue.description ?? undefined,
-        state: issue.state?.name,
-        stateType: issue.state?.type,
-        priority: issue.priorityLabel,
-        assignee: issue.assignee?.displayName ?? issue.assignee?.name,
-        team: issue.team?.key,
-        project: issue.project?.name,
-        labels: issue.labels?.nodes.map((l) => l.name),
-        dueDate: issue.dueDate ?? undefined,
-        url: issue.url,
-        updatedAt: issue.updatedAt,
-    };
-}
-export async function fetchViewer(auth) {
-    const data = await linearRequest(auth, `query { viewer { id name displayName email } organization { id name urlKey } }`);
-    return data;
-}
-/** Resolve a team by UUID, key (e.g. "ENG"), or exact name. */
-export async function resolveTeam(auth, team) {
-    const uuidLike = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (uuidLike.test(team))
-        return { id: team };
-    const data = await linearRequest(auth, `query { teams(first: 100) { nodes { id key name } } }`);
-    const match = data.teams.nodes.find((t) => t.key.toLowerCase() === team.toLowerCase() || t.name.toLowerCase() === team.toLowerCase());
-    if (!match) {
-        const available = data.teams.nodes.map((t) => t.key).join(', ');
-        throw new LinearApiError(`No Linear team matches "${team}". Available team keys: ${available}`);
-    }
-    return match;
-}

package/dist/auth.d.ts

@@ -1,33 +0,0 @@
-/**
- * Credential resolution for the Linear plugin.
- *
- * Priority:
- *   1. `apiKey` in plugin config (AGENT.md) — personal API key.
- *   2. `LINEAR_API_KEY` workspace variable / env — personal API key.
- *   3. `LINEAR_ACCESS_TOKEN` workspace variable — OAuth token saved by
- *      `linear_connect`, refreshed automatically via `LINEAR_REFRESH_TOKEN`.
- */
-import type { PluginContext } from '@meetopenbot/plugin-sdk';
-import type { LinearAuth } from './api.js';
-import { type OAuthTokens } from './oauth.js';
-export declare const VAR_API_KEY = "LINEAR_API_KEY";
-export declare const VAR_ACCESS_TOKEN = "LINEAR_ACCESS_TOKEN";
-export declare const VAR_REFRESH_TOKEN = "LINEAR_REFRESH_TOKEN";
-export declare const VAR_TOKEN_EXPIRES_AT = "LINEAR_TOKEN_EXPIRES_AT";
-/** Stored by the runtime's install-time OAuth flow; used to refresh tokens. */
-export declare const VAR_CLIENT_ID = "LINEAR_CLIENT_ID";
-export interface LinearPluginConfig {
-    apiKey?: string;
-    clientId?: string;
-    clientSecret?: string;
-    oauthPort?: number;
-    scopes?: string;
-}
-export declare function readConfig(context: PluginContext): LinearPluginConfig;
-export declare function saveTokens(context: PluginContext, tokens: OAuthTokens): Promise<void>;
-export declare function clearTokens(context: PluginContext): Promise<void>;
-export declare class NotConnectedError extends Error {
-    constructor();
-}
-/** Resolve usable Linear credentials, refreshing the OAuth token if needed. */
-export declare function resolveAuth(context: PluginContext): Promise<LinearAuth>;

package/dist/auth.js

@@ -1,91 +0,0 @@
-/**
- * Credential resolution for the Linear plugin.
- *
- * Priority:
- *   1. `apiKey` in plugin config (AGENT.md) — personal API key.
- *   2. `LINEAR_API_KEY` workspace variable / env — personal API key.
- *   3. `LINEAR_ACCESS_TOKEN` workspace variable — OAuth token saved by
- *      `linear_connect`, refreshed automatically via `LINEAR_REFRESH_TOKEN`.
- */
-import { refreshAccessToken } from './oauth.js';
-export const VAR_API_KEY = 'LINEAR_API_KEY';
-export const VAR_ACCESS_TOKEN = 'LINEAR_ACCESS_TOKEN';
-export const VAR_REFRESH_TOKEN = 'LINEAR_REFRESH_TOKEN';
-export const VAR_TOKEN_EXPIRES_AT = 'LINEAR_TOKEN_EXPIRES_AT';
-/** Stored by the runtime's install-time OAuth flow; used to refresh tokens. */
-export const VAR_CLIENT_ID = 'LINEAR_CLIENT_ID';
-/** Refresh this long before the reported expiry. */
-const REFRESH_MARGIN_MS = 5 * 60 * 1000;
-export function readConfig(context) {
-    const config = (context.config ?? {});
-    return {
-        apiKey: typeof config.apiKey === 'string' && config.apiKey.trim() ? config.apiKey.trim() : undefined,
-        clientId: typeof config.clientId === 'string' && config.clientId.trim() ? config.clientId.trim() : undefined,
-        clientSecret: typeof config.clientSecret === 'string' && config.clientSecret.trim() ? config.clientSecret.trim() : undefined,
-        oauthPort: typeof config.oauthPort === 'number' ? config.oauthPort : 4137,
-        scopes: typeof config.scopes === 'string' && config.scopes.trim()
-            ? config.scopes.trim()
-            : 'read,write,issues:create,comments:create',
-    };
-}
-function variableValue(variables, key) {
-    const entry = variables[key];
-    if (typeof entry === 'string')
-        return entry || undefined;
-    return entry?.value || undefined;
-}
-export async function saveTokens(context, tokens) {
-    await context.storage.createVariable({ key: VAR_ACCESS_TOKEN, value: tokens.accessToken, secret: true });
-    if (tokens.refreshToken) {
-        await context.storage.createVariable({ key: VAR_REFRESH_TOKEN, value: tokens.refreshToken, secret: true });
-    }
-    if (tokens.expiresAt) {
-        await context.storage.createVariable({ key: VAR_TOKEN_EXPIRES_AT, value: String(tokens.expiresAt), secret: false });
-    }
-}
-export async function clearTokens(context) {
-    for (const key of [VAR_ACCESS_TOKEN, VAR_REFRESH_TOKEN, VAR_TOKEN_EXPIRES_AT]) {
-        await context.storage.deleteVariable({ key }).catch(() => { });
-    }
-}
-export class NotConnectedError extends Error {
-    constructor() {
-        super('Linear is not connected. Use the `linear_connect` tool to connect with OAuth, or set an API key in the plugin config / LINEAR_API_KEY variable.');
-        this.name = 'NotConnectedError';
-    }
-}
-/** Resolve usable Linear credentials, refreshing the OAuth token if needed. */
-export async function resolveAuth(context) {
-    const config = readConfig(context);
-    if (config.apiKey)
-        return { kind: 'apiKey', token: config.apiKey };
-    const variables = (await context.storage.getVariables().catch(() => ({})));
-    const apiKey = variableValue(variables, VAR_API_KEY) ?? process.env[VAR_API_KEY];
-    if (apiKey)
-        return { kind: 'apiKey', token: apiKey };
-    const accessToken = variableValue(variables, VAR_ACCESS_TOKEN) ?? process.env[VAR_ACCESS_TOKEN];
-    if (!accessToken)
-        throw new NotConnectedError();
-    const expiresAtRaw = variableValue(variables, VAR_TOKEN_EXPIRES_AT) ?? process.env[VAR_TOKEN_EXPIRES_AT];
-    const expiresAt = expiresAtRaw ? Number(expiresAtRaw) : undefined;
-    const refreshToken = variableValue(variables, VAR_REFRESH_TOKEN) ?? process.env[VAR_REFRESH_TOKEN];
-    // Client id from plugin config, or the variable stored by the runtime's
-    // install-time OAuth flow (openbot.one plugins page).
-    const clientId = config.clientId ?? variableValue(variables, VAR_CLIENT_ID) ?? process.env[VAR_CLIENT_ID];
-    const needsRefresh = expiresAt !== undefined && Number.isFinite(expiresAt) && Date.now() > expiresAt - REFRESH_MARGIN_MS;
-    if (needsRefresh && refreshToken && clientId) {
-        try {
-            const tokens = await refreshAccessToken({
-                refreshToken,
-                clientId,
-                clientSecret: config.clientSecret,
-            });
-            await saveTokens(context, tokens);
-            return { kind: 'oauth', token: tokens.accessToken };
-        }
-        catch {
-            // Fall through and try the stored token; a 401 will tell the user to reconnect.
-        }
-    }
-    return { kind: 'oauth', token: accessToken };
-}

package/dist/config.d.ts

@@ -1,41 +0,0 @@
-import type { Storage } from "@meetopenbot/plugin-sdk";
-import { type OAuthTokens } from "./oauth.js";
-export declare const VAR_API_KEY = "LINEAR_API_KEY";
-export declare const VAR_ACCESS_TOKEN = "LINEAR_ACCESS_TOKEN";
-export declare const VAR_REFRESH_TOKEN = "LINEAR_REFRESH_TOKEN";
-export declare const VAR_TOKEN_EXPIRES_AT = "LINEAR_TOKEN_EXPIRES_AT";
-export declare const VAR_CLIENT_ID = "LINEAR_CLIENT_ID";
-export declare const GO_BACK_TO_OPENBOT_URL = "https://openbot.one/settings/agents";
-export declare const LINEAR_OPENBOT_CLIENT_ID = "1263fc2dbbf08efa7b2c4b1b2b2582be";
-export type LinearPluginConfig = {
-    clientId?: string;
-    clientSecret?: string;
-    apiKey?: string;
-    oauthPort?: number;
-    scopes?: string;
-    openaiApiKey?: string;
-    model?: string;
-    /** Public runtime base URL, e.g. https://my-host.com (used for OAuth webhook callback). */
-    webhookBaseUrl?: string;
-};
-export type LinearCredentials = {
-    accessToken: string;
-    openaiApiKey: string;
-    model: string;
-    clientId?: string;
-    clientSecret?: string;
-};
-export declare function readLinearConfig(config: Record<string, unknown>): LinearPluginConfig;
-export declare function resolveWebhookBaseUrl(config: LinearPluginConfig, publicBaseUrl?: string): string | undefined;
-export declare function saveTokens(storage: Storage, tokens: OAuthTokens): Promise<void>;
-export declare function clearTokens(storage: Storage): Promise<void>;
-export declare function formatMissingCredentials(missing: Array<"accessToken" | "openaiApiKey">): string;
-export declare function resolveLinearCredentials(config: LinearPluginConfig, storage: Storage, options?: {
-    requireOpenAi?: boolean;
-}): Promise<{
-    ok: true;
-    credentials: LinearCredentials;
-} | {
-    ok: false;
-    missing: Array<"accessToken" | "openaiApiKey">;
-}>;

package/dist/index.d.ts

@@ -1,54 +0,0 @@
-import { type PluginContext, type ToolDefinition } from "@meetopenbot/plugin-sdk";
-declare const _default: {
-    id: string;
-    name: string;
-    description: string;
-    configSchema: {
-        type: "object";
-        properties: {
-            clientId: {
-                type: "string";
-                description: string;
-                default: string;
-            };
-            clientSecret: {
-                type: "string";
-                description: string;
-                format: "password";
-            };
-            apiKey: {
-                type: "string";
-                description: string;
-                format: "password";
-            };
-            oauthPort: {
-                type: "number";
-                description: string;
-                default: number;
-            };
-            scopes: {
-                type: "string";
-                description: string;
-                default: string;
-            };
-            webhookBaseUrl: {
-                type: "string";
-                description: string;
-                format: "url";
-            };
-            openaiApiKey: {
-                type: "string";
-                description: string;
-                format: "password";
-            };
-            model: {
-                type: "string";
-                description: string;
-                default: string;
-            };
-        };
-    };
-    toolDefinitions: Record<string, ToolDefinition>;
-    factory: (pluginContext: PluginContext) => (builder: import("melony").MelonyBuilder<import("@meetopenbot/plugin-sdk").OpenBotState, import("@meetopenbot/plugin-sdk").OpenBotEvent>) => void;
-};
-export default _default;

package/dist/linear-agent.d.ts

@@ -1,14 +0,0 @@
-import type { LinearIssue } from "./linear-issues.js";
-export type RunLinearAgentArgs = {
-    prompt: string;
-    openaiApiKey: string;
-    accessToken: string;
-    model?: string;
-};
-export type LinearAgentResult = {
-    text: string;
-    issues: LinearIssue[];
-    usedTools: boolean;
-    toolErrors: string[];
-};
-export declare function runLinearAgent(args: RunLinearAgentArgs): Promise<LinearAgentResult>;