loopengine 0.3.8 → 0.3.10

package/dist/bin/ability-manager.js

@@ -26,6 +26,7 @@ import { parse as parseYaml } from 'yaml';
 import semver from 'semver';
 import { agentDir } from '../core/gateway-tools.js';
 import { abilityFetchAuth } from '../core/ability-sources.js';
+import { assertOfficialAbility } from '../core/official-abilities.js';
 import { clearMcpSchemaCache, resolveMcpManifest, McpManifestError } from '../core/mcp-abilities.js';
 import { appRuleName } from '../core/mcp-ability-generator.js';
 import { addToolToIndex, removeToolFromIndex, toCamelCase } from '../web/http-tool-admin.js';
@@ -363,6 +364,8 @@ function resolveMcp(manifest) {
     }
 }
 export async function installAbility(agentName, spec, options = {}) {
+    // A public ability only if LoopEngine publishes it (core/official-abilities.ts).
+    assertOfficialAbility(spec);
     const fetch = options.fetchAbilityDir ?? fetchAbilityDir;
     const abilityDir = fetch(spec);
     const manifest = readManifest(abilityDir);
@@ -635,6 +638,8 @@ export async function upgradeAbility(agentName, abilityName, options = {}) {
         throw new AbilityNotInstalledError(`Ability '${abilityName}' isn't installed for '${agentName}'.`);
     }
     const spec = options.spec ?? abilityName;
+    // New code is fetched: the same check as an install.
+    assertOfficialAbility(spec);
     const oldDir = fetch(oldContentSpec(record.spec, abilityName, record.version));
     const newDir = fetch(spec);
     const oldManifest = readManifest(oldDir);

package/dist/core/ability-sources.d.ts

@@ -20,7 +20,9 @@ export interface SourceAbility {
     spec: string;
 }
 export interface AbilityOrigin {
-    kind: 'public' | 'private';
+    /** official: under LoopEngine's @loopengine-co scope; public: any
+     * other npm package (an older lp-* one, say). */
+    kind: 'official' | 'public' | 'private';
     /** Where it came from, for the console's badge: "npm", "GitHub
      * loopengine-co/lp-github", "Folder ../loopengine-abilities", ... */
     label: string;

package/dist/core/ability-sources.js

@@ -260,7 +260,7 @@ export function abilityOrigin(spec, name, sources = safeReadSources()) {
     const npmSource = scope ? sources.find((s) => s.type === 'npm' && s.scope === scope) : undefined;
     if (npmSource)
         return { kind: 'private', label: describeSource(npmSource) };
-    return { kind: 'public', label: 'npm' };
+    return { kind: target.toLowerCase().startsWith('@loopengine-co/') ? 'official' : 'public', label: 'npm' };
 }
 function safeReadSources() {
     try {

package/dist/core/mcp-directory.d.ts

@@ -26,6 +26,22 @@ export declare const MCP_REGISTRY_URL_ENV = "LOOPENGINE_MCP_REGISTRY_URL";
 export declare const MCP_SERVERS_FILE_ENV = "LOOPENGINE_MCP_SERVERS_FILE";
 /** The workspace's saved servers. A malformed entry is skipped. */
 export declare function savedMcpServers(): McpDirectoryServer[];
+export declare class McpServerInputError extends Error {
+}
+/** A server the workspace adds by its address, checked and given an id
+ * from its name (the same id again for an address already saved). Not
+ * saved yet: saveMcpServer, once it has connected. */
+export declare function ownMcpServer(input: {
+    title?: unknown;
+    url?: unknown;
+    description?: unknown;
+    header?: unknown;
+}, saved?: McpDirectoryServer[]): McpDirectoryServer;
+/** Adds a server to the saved servers, or replaces the one with its id.
+ * The file's other entries are kept as they are. */
+export declare function saveMcpServer(server: McpDirectoryServer): void;
+/** Removes a saved server; false when there's none with that id. */
+export declare function removeSavedMcpServer(id: string): boolean;
 /** Saved servers matching `query`, then registry ones, verified first. */
 export declare function searchMcpServers(query: string, limit?: number): Promise<McpDirectoryServer[]>;
 /** One server by id: a saved one, else the registry's latest entry. */

package/dist/core/mcp-directory.js

@@ -11,12 +11,15 @@
 //       url: https://mcp.acme.internal/mcp
 //       auth: { header: X-Api-Key }     # optional; default Authorization: Bearer
 //
+// The console's Apps page adds to the same file ("Add your own server"):
+// a company's own server, connected like any app.
+//
 // A registry server counts as verified when its URL is on the domain its
 // registry name was verified for (com.stripe/mcp at mcp.stripe.com); the
 // rest are shown as unverified.
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { parse as parseYaml } from 'yaml';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 export const MCP_REGISTRY_URL_ENV = 'LOOPENGINE_MCP_REGISTRY_URL';
 export const MCP_SERVERS_FILE_ENV = 'LOOPENGINE_MCP_SERVERS_FILE';
 const DEFAULT_REGISTRY = 'https://registry.modelcontextprotocol.io';
@@ -27,9 +30,12 @@ function registryBase() {
         return undefined;
     return (value || DEFAULT_REGISTRY).replace(/\/+$/, '');
 }
+function savedServersPath() {
+    return resolve(process.cwd(), process.env[MCP_SERVERS_FILE_ENV]?.trim() || 'mcp-servers.yml');
+}
 /** The workspace's saved servers. A malformed entry is skipped. */
 export function savedMcpServers() {
-    const path = resolve(process.cwd(), process.env[MCP_SERVERS_FILE_ENV]?.trim() || 'mcp-servers.yml');
+    const path = savedServersPath();
     if (!existsSync(path))
         return [];
     let raw;
@@ -71,6 +77,93 @@ function isRemoteUrl(url) {
         return false;
     }
 }
+export class McpServerInputError extends Error {
+}
+const HEADER_NAME = /^[A-Za-z0-9-]{1,64}$/;
+/** A server the workspace adds by its address, checked and given an id
+ * from its name (the same id again for an address already saved). Not
+ * saved yet: saveMcpServer, once it has connected. */
+export function ownMcpServer(input, saved = savedMcpServers()) {
+    const text = (v) => (typeof v === 'string' ? v.trim() : '');
+    const title = text(input.title);
+    const url = text(input.url);
+    const description = text(input.description);
+    const header = text(input.header);
+    if (!title)
+        throw new McpServerInputError('Give the server a name, e.g. "Acme CRM".');
+    if (title.length > 60)
+        throw new McpServerInputError('Keep the name under 60 characters.');
+    if (description.length > 200)
+        throw new McpServerInputError('Keep the description under 200 characters.');
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new McpServerInputError('Enter the server\'s full address, e.g. https://mcp.yourcompany.com/mcp.');
+    }
+    if (!isRemoteUrl(parsed.href)) {
+        throw new McpServerInputError(parsed.protocol === 'http:'
+            ? 'Use the server\'s https address: its key would otherwise be sent unencrypted.'
+            : 'Enter the server\'s full https address, with nothing left to fill in, e.g. https://mcp.yourcompany.com/mcp.');
+    }
+    if (header && !HEADER_NAME.test(header))
+        throw new McpServerInputError('A header name is letters, digits and dashes, e.g. X-Api-Key.');
+    const same = saved.find((s) => s.url === url);
+    let id = same?.id;
+    if (!id) {
+        const base = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'server';
+        id = base;
+        for (let n = 2; saved.some((s) => s.id === id); n++)
+            id = `${base}-${n}`;
+    }
+    return {
+        id,
+        title,
+        description,
+        url,
+        transport: 'streamable-http',
+        source: 'saved',
+        verified: true,
+        ...(header && header.toLowerCase() !== 'authorization' ? { auth: { header } } : {}),
+    };
+}
+/** Adds a server to the saved servers, or replaces the one with its id.
+ * The file's other entries are kept as they are. */
+export function saveMcpServer(server) {
+    const path = savedServersPath();
+    let doc = {};
+    if (existsSync(path)) {
+        try {
+            doc = parseYaml(readFileSync(path, 'utf8')) ?? {};
+        }
+        catch (err) {
+            throw new McpServerInputError(`${path} couldn't be read, so the server wasn't saved: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const servers = Array.isArray(doc.servers) ? doc.servers.filter((e) => e?.id !== server.id) : [];
+    servers.push({
+        id: server.id,
+        title: server.title,
+        ...(server.description ? { description: server.description } : {}),
+        url: server.url,
+        ...(server.auth?.header ? { auth: { header: server.auth.header } } : {}),
+    });
+    writeFileSync(path, stringifyYaml({ ...doc, servers }));
+}
+/** Removes a saved server; false when there's none with that id. */
+export function removeSavedMcpServer(id) {
+    const path = savedServersPath();
+    if (!existsSync(path))
+        return false;
+    const doc = parseYaml(readFileSync(path, 'utf8')) ?? {};
+    const servers = Array.isArray(doc.servers) ? doc.servers : [];
+    const kept = servers.filter((e) => e?.id !== id);
+    if (kept.length === servers.length)
+        return false;
+    writeFileSync(path, stringifyYaml({ ...doc, servers: kept }));
+    return true;
+}
 /** io.github.firecrawl/… → firecrawl: the GitHub organisation the
  * registry verified the name for. */
 function githubOrg(name) {

package/dist/core/messaging/connectors/telegram/index.d.ts

@@ -31,9 +31,13 @@ export declare function setTelegramWebhook(botToken: string, url: string, secret
     botUsername?: string;
 }>;
 /** Where the bot's updates go now, and the last delivery error Telegram saw. */
+/** Where the bot's updates go now; the last delivery error Telegram saw
+ * and when (it keeps it until a newer one); and how many are waiting. */
 export declare function telegramWebhookInfo(botToken: string): Promise<{
     ok: boolean;
     url?: string;
     lastError?: string;
+    lastErrorAt?: string;
+    pending?: number;
     error?: string;
 }>;

package/dist/core/messaging/connectors/telegram/index.js

@@ -121,11 +121,20 @@ export async function setTelegramWebhook(botToken, url, secret) {
     return { ok: true, botUsername: await telegramBotUsername(botToken) };
 }
 /** Where the bot's updates go now, and the last delivery error Telegram saw. */
+/** Where the bot's updates go now; the last delivery error Telegram saw
+ * and when (it keeps it until a newer one); and how many are waiting. */
 export async function telegramWebhookInfo(botToken) {
     const info = await callTelegram(botToken, 'getWebhookInfo', {});
     if (!info.ok)
         return { ok: false, error: telegramSetupError(info.description) };
-    return { ok: true, url: info.result?.url || undefined, ...(info.result?.last_error_message ? { lastError: info.result.last_error_message } : {}) };
+    const r = info.result;
+    return {
+        ok: true,
+        url: r?.url || undefined,
+        ...(r?.last_error_message ? { lastError: r.last_error_message } : {}),
+        ...(r?.last_error_date ? { lastErrorAt: new Date(r.last_error_date * 1000).toISOString() } : {}),
+        ...(r?.pending_update_count ? { pending: r.pending_update_count } : {}),
+    };
 }
 function telegramSetupError(description) {
     if (/unauthorized|not found/i.test(description ?? ''))

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

@@ -34,5 +34,9 @@ export declare function toResponsesInput(message: Message): ResponseInputItem[];
  * blocks, message text, and function calls as tool_use blocks (their
  * call_id is the id a tool result answers). */
 export declare function fromResponse(response: OpenAI.Responses.Response): ModelResponse;
+/** OpenAI's reasoning models (GPT-5 on, the o-series), which reason by
+ * default and take a reasoning effort; older ones (gpt-4o, gpt-4.1)
+ * reject one. */
+export declare function isOpenAIReasoningModel(model: string): boolean;
 export declare function createOpenAIModelCall(options: OpenAIModelCallOptions): ModelCall;
 export {};

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

@@ -232,10 +232,20 @@ export function fromResponse(response) {
     const usage = response.usage ? { input_tokens: response.usage.input_tokens, output_tokens: response.usage.output_tokens } : undefined;
     return { stop_reason, content, ...(usage ? { usage } : {}) };
 }
+/** OpenAI's reasoning models (GPT-5 on, the o-series), which reason by
+ * default and take a reasoning effort; older ones (gpt-4o, gpt-4.1)
+ * reject one. */
+export function isOpenAIReasoningModel(model) {
+    return /^(gpt-(5|6|7|8|9)|o\d)/i.test(model);
+}
 export function createOpenAIModelCall(options) {
     const client = options.client ?? new OpenAI({ apiKey: options.apiKey });
+    // A reasoning model with no effort set reasons at OpenAI's default
+    // anyway (medium), which used to spend the 4096-token cap before it
+    // got to a tool call. Unset is low for those: quick, and room to act.
+    const reasoningEffort = options.reasoningEffort ?? (isOpenAIReasoningModel(options.model) ? 'low' : undefined);
     // Reasoning counts toward max_output_tokens.
-    const maxTokens = options.maxTokens ?? (options.reasoningEffort && options.reasoningEffort !== 'none' ? 16000 : 4096);
+    const maxTokens = options.maxTokens ?? (reasoningEffort && reasoningEffort !== 'none' ? 16000 : 4096);
     return async (messages, system, tools) => {
         const response = await client.responses.create({
             model: options.model,
@@ -245,7 +255,7 @@ export function createOpenAIModelCall(options) {
             tools: tools.length
                 ? tools.map((t) => ({ type: 'function', name: t.name, description: t.description, parameters: t.input_schema, strict: false }))
                 : undefined,
-            ...(options.reasoningEffort ? { reasoning: { effort: options.reasoningEffort } } : {}),
+            ...(reasoningEffort ? { reasoning: { effort: reasoningEffort } } : {}),
             store: false,
             include: ['reasoning.encrypted_content'],
         });

package/dist/core/official-abilities.d.ts

@@ -0,0 +1,14 @@
+/** LoopEngine's npm organisation: its scope is official by itself. */
+export declare const OFFICIAL_ABILITY_SCOPE = "@loopengine-co";
+/** Whether a package name is under LoopEngine's npm organisation. */
+export declare function isOfficialScope(name: string): boolean;
+export declare class UnofficialAbilityError extends Error {
+}
+export declare function unofficialAbilitiesAllowed(): boolean;
+/** The package name when a spec installs from the public npm registry:
+ * a bare name or @scope/name, with an optional @version, whose scope isn't
+ * one of the workspace's private registries. Undefined for anything else. */
+export declare function publicNpmPackage(spec: string): string | undefined;
+/** Refuses a public npm ability that isn't official, before anything is
+ * fetched. */
+export declare function assertOfficialAbility(spec: string): void;

package/dist/core/official-abilities.js

@@ -0,0 +1,58 @@
+// Official abilities: of the public ones on npm, only those LoopEngine
+// publishes are listed and installed. Anyone can publish a package with the
+// loopengine-ability keyword, or an lp-* name, and an ability runs code in
+// the agent's server with the agent's keys; so "official" is decided by who
+// can publish it: anything under the @loopengine-co scope, which only
+// members of LoopEngine's npm organisation can publish to. The older
+// unscoped ones (lp-gmail and the rest) aren't, and can't be installed or
+// upgraded; their official versions are under the scope.
+//
+// Private abilities are the workspace's own and stay allowed: a workspace
+// ability (file:), one from a GitHub source (github:owner/repo, git URLs),
+// and one from a private npm registry the workspace set up for a scope
+// (core/ability-sources.ts).
+//
+// LOOPENGINE_ALLOW_UNOFFICIAL_ABILITIES=1 turns the check off, for someone
+// developing their own public ability on a self-hosted server.
+import { readAbilitySources } from './ability-sources.js';
+/** LoopEngine's npm organisation: its scope is official by itself. */
+export const OFFICIAL_ABILITY_SCOPE = '@loopengine-co';
+/** Whether a package name is under LoopEngine's npm organisation. */
+export function isOfficialScope(name) {
+    return name.toLowerCase().startsWith(`${OFFICIAL_ABILITY_SCOPE}/`);
+}
+export class UnofficialAbilityError extends Error {
+}
+export function unofficialAbilitiesAllowed() {
+    return process.env.LOOPENGINE_ALLOW_UNOFFICIAL_ABILITIES === '1';
+}
+/** The package name when a spec installs from the public npm registry:
+ * a bare name or @scope/name, with an optional @version, whose scope isn't
+ * one of the workspace's private registries. Undefined for anything else. */
+export function publicNpmPackage(spec) {
+    const match = /^((?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*)(?:@[^/]+)?$/i.exec(spec.trim());
+    if (!match)
+        return undefined;
+    const name = match[1];
+    if (name.startsWith('@')) {
+        const scope = name.split('/')[0].toLowerCase();
+        let privateScopes = [];
+        try {
+            privateScopes = readAbilitySources().flatMap((s) => (s.type === 'npm' ? [s.scope.toLowerCase()] : []));
+        }
+        catch { }
+        if (privateScopes.includes(scope))
+            return undefined;
+    }
+    return name;
+}
+/** Refuses a public npm ability that isn't official, before anything is
+ * fetched. */
+export function assertOfficialAbility(spec) {
+    if (unofficialAbilitiesAllowed())
+        return;
+    const name = publicNpmPackage(spec);
+    if (!name || isOfficialScope(name))
+        return;
+    throw new UnofficialAbilityError(`${name} isn't an official LoopEngine ability, so it can't be installed: official abilities are under ${OFFICIAL_ABILITY_SCOPE} on npm (search them on the Abilities page). To use your own, add it as a private ability (Settings → Private ability sources, or upload it on the Abilities page).`);
+}

package/dist/core/system-agents/templates.d.ts

@@ -1,4 +1,5 @@
 import type { AgentCandidate } from './interviewer.js';
+import type { WorkflowParameter } from '../workflows.js';
 export interface TemplateRule {
     name: string;
     tool: string;
@@ -9,6 +10,14 @@ export interface TemplateSkill {
     id: string;
     description: string;
     body: string;
+    /** Makes it a workflow, with `body` as its instructions. `webhook`: its
+     * checklist says to add a webhook that sends each result (the URL and
+     * the sender's signing secret are set up with the sender). */
+    workflow?: {
+        title: string;
+        parameters?: Record<string, WorkflowParameter>;
+        webhook?: boolean;
+    };
 }
 export interface TemplateSchedule {
     /** How often, in the scheduler's terms: "10m", "1h", "7d". */