@ikarmic/forge-core 5.0.0 → 5.1.1

package/dist/mcp/mcp-client.js

@@ -24,12 +24,14 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { filterMcpServers, getOrgPolicy } from '../policy/policy.js';
 import { jsonSchemaToZod } from './json-schema-to-zod.js';
+import { ForgeOAuthProvider, McpAuthRequiredError, defaultMcpAuthDir, readSavedAuth } from './oauth.js';
 /**
  * Self-identifying info we send to every MCP server during the `initialize`
  * handshake. Version is read from our own package.json so it stays in sync
@@ -53,7 +55,7 @@ function readPackageVersion() {
     }
 }
 /** Connect to every server in a parsed MCP config. Failed connections are skipped with a warning. */
-export async function connectAll(config) {
+export async function connectAll(config, options = {}) {
     const { allowed, blocked } = filterMcpServers(config.mcpServers, getOrgPolicy()?.policy);
     for (const name of blocked) {
         process.stderr.write(`forge: MCP server "${name}" is blocked by organization policy
@@ -65,10 +67,14 @@ export async function connectAll(config) {
         if (spec.disabled)
             continue;
         try {
-            const server = await connectOne(name, spec);
+            const server = await connectOne(name, spec, options);
             results.push(server);
         }
         catch (err) {
+            if (err instanceof McpAuthRequiredError) {
+                process.stderr.write(`forge: MCP server "${name}" needs you to sign in. Run: forge mcp login ${name}\n`);
+                continue;
+            }
             // Skip failed servers so one bad entry doesn't take down the whole
             // session; surface the error so the caller can log it.
             process.stderr.write(`forge: MCP server "${name}" failed to connect: ${err.message}\n`);
@@ -76,21 +82,68 @@ export async function connectAll(config) {
     }
     return results;
 }
+export { McpAuthRequiredError } from './oauth.js';
+/** A 401 from a server we connected to without credentials. */
+function isUnauthorized(err) {
+    const e = err;
+    return err instanceof UnauthorizedError || e?.code === 401 || (typeof e?.message === 'string' && /\b401\b/.test(e.message));
+}
 /** Connect to a single server and pull its tools. */
-export async function connectOne(name, spec) {
-    const transport = buildTransport(spec);
-    const client = new Client(CLIENT_INFO, { capabilities: {} });
-    await client.connect(transport);
-    const { tools: mcpTools } = await client.listTools();
-    const tools = mcpTools.map((t) => mcpToolToForgeTool(name, t, client));
-    return { name, client, tools };
+export async function connectOne(name, spec, options = {}) {
+    const timeout = spec.timeout ? { timeout: spec.timeout } : undefined;
+    let client = new Client(CLIENT_INFO, { capabilities: {} });
+    const oauth = options.oauth;
+    // A static Authorization header is the user's own choice of credentials: leave OAuth out of it.
+    const hasStaticAuth = Object.keys(spec.headers ?? {}).some((h) => h.toLowerCase() === 'authorization');
+    const wantsOAuth = Boolean(oauth && spec.url && !spec.command && !hasStaticAuth);
+    if (!wantsOAuth) {
+        await client.connect(buildTransport(spec), timeout);
+    }
+    else {
+        const url = spec.url;
+        const haveTokens = Boolean((await readSavedAuth(oauth.storeDir ?? defaultMcpAuthDir(), url))?.tokens);
+        let provider;
+        if (haveTokens || oauth.interactive) {
+            provider = await ForgeOAuthProvider.create(name, url, oauth);
+        }
+        let transport = buildTransport(spec, provider);
+        try {
+            await client.connect(transport, timeout);
+        }
+        catch (err) {
+            if (!provider) {
+                // Tried without credentials and the server refused: it needs a sign-in the user has not done yet.
+                if (isUnauthorized(err))
+                    throw new McpAuthRequiredError(name);
+                throw err;
+            }
+            if (!(err instanceof UnauthorizedError))
+                throw err;
+            // The SDK started the sign-in (the browser is open); wait for the user, then connect again with the tokens.
+            try {
+                const code = await provider.waitForCode();
+                await transport.finishAuth(code);
+            }
+            catch (signInErr) {
+                provider.cancel();
+                throw signInErr;
+            }
+            await client.close().catch(() => undefined);
+            client = new Client(CLIENT_INFO, { capabilities: {} });
+            transport = buildTransport(spec, provider);
+            await client.connect(transport, timeout);
+        }
+    }
+    const { tools: mcpTools } = await client.listTools(undefined, spec.timeout ? { timeout: spec.timeout } : undefined);
+    const tools = mcpTools.map((t) => mcpToolToForgeTool(name, t, client, spec.timeout));
+    return { name, client, tools, instructions: client.getInstructions()?.trim() || undefined };
 }
 /**
  * Pick the right SDK transport for the server spec. The transport type is
  * either explicit (`type: 'sse'` etc.) or inferred from the shape of the
  * spec: `command` present ⇒ stdio, `url` present ⇒ SSE.
  */
-function buildTransport(spec) {
+function buildTransport(spec, authProvider) {
     const explicit = spec.type;
     const isStdio = explicit === 'stdio' || (!explicit && Boolean(spec.command));
     const isSse = explicit === 'sse' || (!explicit && Boolean(spec.url) && !explicit);
@@ -118,10 +171,17 @@ function buildTransport(spec) {
     const headers = spec.headers ?? {};
     const requestInit = headers ? { headers } : {};
     if (explicit === 'streamable-http') {
-        return new StreamableHTTPClientTransport(new URL(spec.url), { requestInit });
+        return new StreamableHTTPClientTransport(new URL(spec.url), { requestInit, ...(authProvider ? { authProvider } : {}) });
     }
     // Default for HTTP-transport specs: SSE (preserves prior behavior).
-    return new SSEClientTransport(new URL(spec.url), { requestInit });
+    return new SSEClientTransport(new URL(spec.url), { requestInit, ...(authProvider ? { authProvider } : {}) });
+}
+/** The instructions servers sent with `initialize`, as one prompt block (empty when none sent any). */
+export function mcpInstructionsBlock(servers) {
+    return servers
+        .filter((s) => s.instructions)
+        .map((s) => `<mcp-server-instructions server="${s.name.replace(/"/g, '')}">\n${s.instructions}\n</mcp-server-instructions>`)
+        .join('\n\n');
 }
 /** Close all clients and their underlying transports. */
 export async function closeAll(servers) {
@@ -133,7 +193,7 @@ export async function closeAll(servers) {
  * namespace of the built-in tools and tells the model which server a tool
  * came from at a glance.
  */
-function mcpToolToForgeTool(serverName, mcpTool, client) {
+function mcpToolToForgeTool(serverName, mcpTool, client, timeout) {
     const fullName = `mcp__${serverName}__${mcpTool.name}`;
     const description = [
         mcpTool.description ?? '',
@@ -150,10 +210,7 @@ function mcpToolToForgeTool(serverName, mcpTool, client) {
         // destructive so the user gets a confirmation prompt unless --auto.
         destructive: true,
         execute: async (args) => {
-            const result = await client.callTool({
-                name: mcpTool.name,
-                arguments: args,
-            });
+            const result = await client.callTool({ name: mcpTool.name, arguments: args }, undefined, timeout ? { timeout } : undefined);
             return mcpResultToValue(result);
         },
     };

package/dist/mcp/mcp-config.d.ts

@@ -45,6 +45,8 @@ export interface McpServerSpec {
     headers?: Record<string, string>;
     /** Keep the entry but do not connect it. */
     disabled?: boolean;
+    /** Milliseconds to wait for a connection or a tool call before giving up (default: the SDK's 60 s). */
+    timeout?: number;
 }
 /**
  * Load and validate a `forge.mcp.json` file. Throws if the file is missing,

package/dist/mcp/mcp-config.js

@@ -9,6 +9,7 @@ const serverSchema = z
     url: z.string().optional(),
     headers: z.record(z.string(), z.string()).optional(),
     disabled: z.boolean().optional(),
+    timeout: z.number().int().positive().max(3_600_000).optional(),
 })
     .refine((s) => Boolean(s.command) || Boolean(s.url), {
     message: 'Each MCP server must have either `command` (stdio) or `url` (sse/streamable-http).',

package/dist/mcp/oauth.d.ts

@@ -0,0 +1,55 @@
+import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
+export interface McpOAuthOptions {
+    /** Defaults to `~/.forge/mcp-auth`. */
+    storeDir?: string;
+    /** Show the authorization page to the user (their browser). Throw to refuse. */
+    openUrl: (url: string) => void | Promise<void>;
+    /** True: may open the browser and wait for the user. False: only use tokens already saved. */
+    interactive?: boolean;
+    /** How long to wait for the user to finish in the browser. Default five minutes. */
+    signInTimeoutMs?: number;
+}
+/** The server needs the user to sign in, and this connection was not allowed to ask. */
+export declare class McpAuthRequiredError extends Error {
+    readonly server: string;
+    constructor(server: string);
+}
+interface SavedAuth {
+    url: string;
+    port?: number;
+    clientInformation?: OAuthClientInformationMixed;
+    tokens?: OAuthTokens;
+}
+export declare function defaultMcpAuthDir(): string;
+export declare function readSavedAuth(dir: string, serverUrl: string): Promise<SavedAuth | undefined>;
+export declare function forgetSavedAuth(dir: string, serverUrl: string): Promise<void>;
+export declare class ForgeOAuthProvider implements OAuthClientProvider {
+    readonly serverName: string;
+    private readonly serverUrl;
+    private readonly dir;
+    private readonly port;
+    private readonly options;
+    private verifier;
+    private expectedState;
+    private receiver;
+    private constructor();
+    static create(serverName: string, serverUrl: string, options: McpOAuthOptions): Promise<ForgeOAuthProvider>;
+    get redirectUrl(): string;
+    get clientMetadata(): OAuthClientMetadata;
+    state(): string;
+    private saved;
+    clientInformation(): Promise<OAuthClientInformationMixed | undefined>;
+    saveClientInformation(info: OAuthClientInformationMixed): Promise<void>;
+    tokens(): Promise<OAuthTokens | undefined>;
+    saveTokens(tokens: OAuthTokens): Promise<void>;
+    saveCodeVerifier(v: string): void;
+    codeVerifier(): string;
+    invalidateCredentials(scope: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery'): Promise<void>;
+    /** Called by the SDK once it has the authorization URL. Without `interactive` this is where the connection stops. */
+    redirectToAuthorization(url: URL): Promise<void>;
+    /** After the SDK reported the sign-in as started: the code the browser brings back. */
+    waitForCode(): Promise<string>;
+    cancel(): void;
+}
+export {};

package/dist/mcp/oauth.js

@@ -0,0 +1,197 @@
+/**
+ * OAuth sign-in for MCP servers behind it (authorization code with PKCE, dynamic client registration).
+ * The SDK does the protocol; this file supplies what it leaves to the application: where tokens are kept,
+ * where the browser returns to (a one-shot page on 127.0.0.1), and a state value that must come back unchanged.
+ *
+ * Tokens live in `~/.forge/mcp-auth/<server>.json`, readable by the user only, one file per server URL.
+ * Signing in is always the user's act: a server that needs it is reported as such, and the browser opens only
+ * when `interactive` is set. A URL that is not http or https is never opened.
+ */
+import { randomBytes, createHash } from 'node:crypto';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import http from 'node:http';
+import { homedir } from 'node:os';
+import path from 'node:path';
+/** The server needs the user to sign in, and this connection was not allowed to ask. */
+export class McpAuthRequiredError extends Error {
+    server;
+    constructor(server) {
+        super(`MCP server "${server}" needs you to sign in`);
+        this.server = server;
+        this.name = 'McpAuthRequiredError';
+    }
+}
+export function defaultMcpAuthDir() {
+    return path.join(homedir(), '.forge', 'mcp-auth');
+}
+function fileFor(dir, serverUrl) {
+    return path.join(dir, `${createHash('sha256').update(serverUrl).digest('hex').slice(0, 32)}.json`);
+}
+export async function readSavedAuth(dir, serverUrl) {
+    try {
+        return JSON.parse(await readFile(fileFor(dir, serverUrl), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeSavedAuth(dir, auth) {
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(fileFor(dir, auth.url), JSON.stringify(auth, null, 2), { encoding: 'utf8', mode: 0o600 });
+}
+export async function forgetSavedAuth(dir, serverUrl) {
+    await rm(fileFor(dir, serverUrl), { force: true });
+}
+/** A port on 127.0.0.1: the one used last time if it is free (so a registered redirect URL keeps working), else any. */
+async function freePort(preferred) {
+    const tryListen = (port) => new Promise((resolve) => {
+        const s = http.createServer();
+        s.once('error', () => resolve(undefined));
+        s.listen(port, '127.0.0.1', () => {
+            const got = s.address().port;
+            s.close(() => resolve(got));
+        });
+    });
+    return (preferred ? await tryListen(preferred) : undefined) ?? (await tryListen(0)) ?? 0;
+}
+/** A one-shot page the browser returns to. Resolves with the code; a wrong `state` is ignored, an `error` rejects. */
+async function receiveCode(port, expectedState, timeoutMs) {
+    let resolveCode;
+    let rejectCode;
+    const code = new Promise((resolve, reject) => {
+        resolveCode = resolve;
+        rejectCode = reject;
+    });
+    const page = (title) => `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font-family:sans-serif;margin:3em"><h2>${title}</h2><p>You can close this tab and go back to your editor.</p>`;
+    const server = http.createServer((req, res) => {
+        const url = new URL(req.url ?? '/', `http://127.0.0.1:${port}`);
+        if (url.pathname !== '/callback') {
+            res.writeHead(404).end();
+            return;
+        }
+        if (url.searchParams.get('state') !== expectedState) {
+            res.writeHead(400, { 'content-type': 'text/html' }).end(page('This sign-in link is not for this session'));
+            return;
+        }
+        const error = url.searchParams.get('error');
+        const got = url.searchParams.get('code');
+        if (error || !got) {
+            res.writeHead(400, { 'content-type': 'text/html' }).end(page('Sign-in was not completed'));
+            rejectCode(new Error(`sign-in failed: ${error ?? 'no code returned'}`));
+            return;
+        }
+        res.writeHead(200, { 'content-type': 'text/html' }).end(page('Signed in to Forge'));
+        resolveCode(got);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', resolve);
+    });
+    const timer = setTimeout(() => rejectCode(new Error('sign-in timed out')), timeoutMs);
+    const close = () => {
+        clearTimeout(timer);
+        server.closeAllConnections();
+        server.close();
+    };
+    code.then(close, close);
+    return { code, close };
+}
+export class ForgeOAuthProvider {
+    serverName;
+    serverUrl;
+    dir;
+    port;
+    options;
+    verifier = '';
+    expectedState = '';
+    receiver;
+    constructor(serverName, serverUrl, dir, port, options) {
+        this.serverName = serverName;
+        this.serverUrl = serverUrl;
+        this.dir = dir;
+        this.port = port;
+        this.options = options;
+    }
+    static async create(serverName, serverUrl, options) {
+        const dir = options.storeDir ?? defaultMcpAuthDir();
+        const saved = await readSavedAuth(dir, serverUrl);
+        const port = await freePort(saved?.port);
+        await writeSavedAuth(dir, { ...(saved ?? { url: serverUrl }), url: serverUrl, port });
+        return new ForgeOAuthProvider(serverName, serverUrl, dir, port, options);
+    }
+    get redirectUrl() {
+        return `http://127.0.0.1:${this.port}/callback`;
+    }
+    get clientMetadata() {
+        return {
+            client_name: 'Ikarmic Forge',
+            redirect_uris: [this.redirectUrl],
+            grant_types: ['authorization_code', 'refresh_token'],
+            response_types: ['code'],
+            token_endpoint_auth_method: 'none',
+        };
+    }
+    state() {
+        this.expectedState = randomBytes(16).toString('hex');
+        return this.expectedState;
+    }
+    async saved() {
+        return (await readSavedAuth(this.dir, this.serverUrl)) ?? { url: this.serverUrl };
+    }
+    async clientInformation() {
+        const info = (await this.saved()).clientInformation;
+        // A registration made for another redirect URL cannot be used here: register again.
+        if (info?.redirect_uris && !info.redirect_uris.includes(this.redirectUrl))
+            return undefined;
+        return info;
+    }
+    async saveClientInformation(info) {
+        await writeSavedAuth(this.dir, { ...(await this.saved()), clientInformation: info });
+    }
+    async tokens() {
+        return (await this.saved()).tokens;
+    }
+    async saveTokens(tokens) {
+        await writeSavedAuth(this.dir, { ...(await this.saved()), tokens });
+    }
+    saveCodeVerifier(v) {
+        this.verifier = v;
+    }
+    codeVerifier() {
+        return this.verifier;
+    }
+    async invalidateCredentials(scope) {
+        const s = await this.saved();
+        if (scope === 'all' || scope === 'tokens')
+            delete s.tokens;
+        if (scope === 'all' || scope === 'client')
+            delete s.clientInformation;
+        await writeSavedAuth(this.dir, s);
+    }
+    /** Called by the SDK once it has the authorization URL. Without `interactive` this is where the connection stops. */
+    async redirectToAuthorization(url) {
+        if (!this.options.interactive)
+            throw new McpAuthRequiredError(this.serverName);
+        if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+            throw new Error(`MCP server "${this.serverName}" gave a sign-in address that is not a web page (${url.protocol}); refused`);
+        }
+        this.receiver?.close();
+        this.receiver = await receiveCode(this.port, this.expectedState, this.options.signInTimeoutMs ?? 5 * 60_000);
+        await this.options.openUrl(url.href);
+    }
+    /** After the SDK reported the sign-in as started: the code the browser brings back. */
+    async waitForCode() {
+        if (!this.receiver)
+            throw new Error('no sign-in is waiting');
+        try {
+            return await this.receiver.code;
+        }
+        finally {
+            this.receiver = undefined;
+        }
+    }
+    cancel() {
+        this.receiver?.close();
+        this.receiver = undefined;
+    }
+}

package/dist/mcp/resource-tools.d.ts

@@ -0,0 +1,8 @@
+import type { ConnectedMcpServer } from './mcp-client.js';
+import type { ToolDefinition } from '../types.js';
+/**
+ * `mcp_list_resources` and `mcp_read_resource`: let the model see and read what connected MCP servers publish
+ * (notes, files, schemas). Both only read, so neither asks for approval. `servers` is a function because
+ * servers connect, fail and reconnect while a chat is open.
+ */
+export declare function createMcpResourceTools(servers: () => readonly ConnectedMcpServer[]): ToolDefinition[];

package/dist/mcp/resource-tools.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+const MAX_RESOURCE_CHARS = 100_000;
+/**
+ * `mcp_list_resources` and `mcp_read_resource`: let the model see and read what connected MCP servers publish
+ * (notes, files, schemas). Both only read, so neither asks for approval. `servers` is a function because
+ * servers connect, fail and reconnect while a chat is open.
+ */
+export function createMcpResourceTools(servers) {
+    const listParams = z.object({ server: z.string().optional().describe('Only this MCP server. Omit for every server.') });
+    const readParams = z.object({
+        server: z.string().describe('MCP server name, as shown by mcp_list_resources.'),
+        uri: z.string().describe('Resource URI, as shown by mcp_list_resources.'),
+    });
+    const list = {
+        name: 'mcp_list_resources',
+        description: 'List the resources (documents, data, files) that connected MCP servers publish. Returns each resource server, uri, name and description.',
+        parameters: listParams,
+        execute: async (args) => {
+            const out = [];
+            for (const s of servers()) {
+                if (args.server && s.name !== args.server)
+                    continue;
+                try {
+                    const { resources } = await s.client.listResources();
+                    for (const r of resources) {
+                        out.push({ server: s.name, uri: r.uri, name: r.name, ...(r.description ? { description: r.description } : {}), ...(r.mimeType ? { mimeType: r.mimeType } : {}) });
+                    }
+                }
+                catch {
+                    // A server without resources support (or one that is down) just contributes nothing.
+                }
+            }
+            return { resources: out };
+        },
+    };
+    const read = {
+        name: 'mcp_read_resource',
+        description: 'Read one resource from a connected MCP server by its server name and uri (see mcp_list_resources).',
+        parameters: readParams,
+        execute: async (args) => {
+            const server = servers().find((s) => s.name === args.server);
+            if (!server)
+                throw new Error(`No MCP server "${args.server}" is connected.`);
+            const result = await server.client.readResource({ uri: args.uri });
+            const text = result.contents
+                .map((c) => ('text' in c && typeof c.text === 'string' ? c.text : `[binary content${c.mimeType ? `, ${c.mimeType}` : ''}]`))
+                .join('\n');
+            return {
+                server: args.server,
+                uri: args.uri,
+                text: text.length > MAX_RESOURCE_CHARS ? `${text.slice(0, MAX_RESOURCE_CHARS)}\n…(truncated)` : text,
+            };
+        },
+    };
+    return [list, read];
+}

package/dist/memory/session-digest.d.ts

@@ -0,0 +1,12 @@
+import type { LanguageModel } from 'ai';
+import type { ModelConfig } from '../types.js';
+export interface DigestItem {
+    role: 'user' | 'assistant';
+    text: string;
+}
+/** A conversation with fewer than two user messages is a question, not work worth remembering. */
+export declare function shouldDigest(items: readonly DigestItem[]): boolean;
+/** The model's reply as a digest: think block, fences and quotes removed; undefined when nothing usable is left (RB-1). */
+export declare function cleanDigest(reply: string): string | undefined;
+/** Summarise a finished chat for project memory with `model` (usually the cheap model); never throws. */
+export declare function generateSessionDigest(items: readonly DigestItem[], model: ModelConfig | undefined, modelFactory?: (cfg: ModelConfig) => LanguageModel): Promise<string | undefined>;

package/dist/memory/session-digest.js

@@ -0,0 +1,47 @@
+import { generateText } from 'ai';
+import { stripThinkTags } from '../agent/think-tags.js';
+import { createLanguageModel } from '../providers.js';
+const MAX_DIGEST_CHARS = 600;
+const MAX_INPUT_CHARS = 12_000;
+const INSTRUCTION = 'Below is a conversation between a user and a coding agent. Write what a later session needs to know: what was changed or decided, which files were involved, and anything left undone. ' +
+    'Two to five short bullet lines, each starting with "- ". Do not copy code. Reply with the bullets only, no preface, no code fences.';
+/** A conversation with fewer than two user messages is a question, not work worth remembering. */
+export function shouldDigest(items) {
+    return items.filter((i) => i.role === 'user').length >= 2;
+}
+/** The model's reply as a digest: think block, fences and quotes removed; undefined when nothing usable is left (RB-1). */
+export function cleanDigest(reply) {
+    const text = stripThinkTags(reply)
+        .trim()
+        .replace(/^```[a-z]*\s*\n?/i, '')
+        .replace(/\n?```$/, '')
+        .trim()
+        .replace(/^["'“”](.*)["'“”]$/s, '$1')
+        .trim();
+    if (!text)
+        return undefined;
+    return text.length > MAX_DIGEST_CHARS ? `${text.slice(0, MAX_DIGEST_CHARS - 1).trimEnd()}…` : text;
+}
+/** The end of the conversation, which is where its outcome is, within the input budget. */
+function transcript(items) {
+    const lines = items.map((i) => `${i.role === 'user' ? 'User' : 'Agent'}: ${i.text.trim()}`);
+    let out = '';
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (out.length + lines[i].length > MAX_INPUT_CHARS)
+            break;
+        out = `${lines[i]}\n\n${out}`;
+    }
+    return out.trim();
+}
+/** Summarise a finished chat for project memory with `model` (usually the cheap model); never throws. */
+export async function generateSessionDigest(items, model, modelFactory = createLanguageModel) {
+    if (!model || !shouldDigest(items))
+        return undefined;
+    try {
+        const result = await generateText({ model: modelFactory(model), prompt: `${INSTRUCTION}\n\nConversation:\n${transcript(items)}` });
+        return cleanDigest(result.text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/memory/stale.js

@@ -5,6 +5,7 @@
  */
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
+import { isOutsideRel } from '../tools/shared.js';
 /** Key a section in the stale map. */
 export function staleKey(s) {
     return `${s.source}#${s.heading}`;
@@ -23,7 +24,7 @@ export async function checkStale(sections, root, opts = {}) {
             const file = hash === -1 ? ref : ref.slice(0, hash);
             const symbol = hash === -1 ? '' : ref.slice(hash + 1);
             const rel = path.relative(root, path.resolve(root, file));
-            if (path.isAbsolute(file) || rel.startsWith('..') || path.isAbsolute(rel)) {
+            if (path.isAbsolute(file) || isOutsideRel(rel)) {
                 reasons.push(`${ref} is outside the project`);
                 continue;
             }

package/dist/model-alias.d.ts

@@ -1,4 +1,11 @@
-import type { ProviderName } from './types.js';
+/**
+ * User-defined model aliases from `~/.forge/config.json`:
+ *   "aliases": { "fast": "anthropic:claude-haiku-4-5", "big": "opus" }
+ * A value is `provider:model` or a bare model id (current provider), and may
+ * name another alias.
+ */
+import { type CustomProviderConfig, type ProviderEndpoint } from './custom-providers.js';
+import type { ModelConfig, ProviderName } from './types.js';
 export type ModelAliases = Record<string, string>;
 /** Follow alias links from `name`. Names that are not aliases come back unchanged. */
 export declare function expandModelAlias(name: string, aliases: ModelAliases | undefined): string;
@@ -7,9 +14,18 @@ export declare function splitModelRef(ref: string): {
     provider?: ProviderName;
     model: string;
 };
-export declare function resolveModelAlias(name: string, aliases: ModelAliases | undefined, defaultProvider: ProviderName): {
+/**
+ * `provider:model` for the eleven built-in providers, and `id:model` for a preset or `customProviders` id
+ * (`groq:llama-3.3-70b-versatile`), which resolves to an openai-compatible model with its endpoint. Ollama and
+ * LM Studio use `name:tag` model ids (`mistral:7b`), so for them only a prefix the user defined counts.
+ */
+export declare function resolveModelAlias(name: string, aliases: ModelAliases | undefined, defaultProvider: ProviderName, custom?: Record<string, CustomProviderConfig>): {
     provider: ProviderName;
     model: string;
+    endpoint?: ProviderEndpoint;
 };
+export type ResolvedModelRef = ReturnType<typeof resolveModelAlias>;
+/** A resolved model reference laid over a base model: the base's other settings stay, its endpoint never leaks into a different provider. */
+export declare function applyResolved(base: ModelConfig, resolved: ResolvedModelRef): ModelConfig;
 /** Human-readable alias list for `forge config`; '' when there are none. */
 export declare function formatAliasTable(aliases: ModelAliases | undefined): string;

package/dist/model-alias.js

@@ -4,6 +4,7 @@
  * A value is `provider:model` or a bare model id (current provider), and may
  * name another alias.
  */
+import { PROVIDER_PRESETS, apiModelId, registeredCustomProviders, resolveProviderEndpoint } from './custom-providers.js';
 import { MODEL_CATALOG } from './model-catalog.js';
 const MAX_HOPS = 5;
 const PROVIDERS = new Set(Object.keys(MODEL_CATALOG));
@@ -34,9 +35,32 @@ export function splitModelRef(ref) {
     }
     return { model: ref };
 }
-export function resolveModelAlias(name, aliases, defaultProvider) {
-    const { provider, model } = splitModelRef(expandModelAlias(name, aliases));
-    return { provider: provider ?? defaultProvider, model };
+/**
+ * `provider:model` for the eleven built-in providers, and `id:model` for a preset or `customProviders` id
+ * (`groq:llama-3.3-70b-versatile`), which resolves to an openai-compatible model with its endpoint. Ollama and
+ * LM Studio use `name:tag` model ids (`mistral:7b`), so for them only a prefix the user defined counts.
+ */
+export function resolveModelAlias(name, aliases, defaultProvider, custom) {
+    const providers = custom ?? registeredCustomProviders();
+    const expanded = expandModelAlias(name, aliases);
+    const { provider, model } = splitModelRef(expanded);
+    if (provider)
+        return { provider, model };
+    const idx = expanded.indexOf(':');
+    if (idx > 0) {
+        const prefix = expanded.slice(0, idx);
+        const local = defaultProvider === 'ollama' || defaultProvider === 'lmstudio';
+        const known = Object.prototype.hasOwnProperty.call(providers ?? {}, prefix) || (!local && Object.prototype.hasOwnProperty.call(PROVIDER_PRESETS, prefix));
+        const endpoint = known ? resolveProviderEndpoint(prefix, providers) : undefined;
+        if (endpoint)
+            return { provider: 'openai-compatible', model: apiModelId(prefix, expanded.slice(idx + 1), providers), endpoint };
+    }
+    return { provider: defaultProvider, model };
+}
+/** A resolved model reference laid over a base model: the base's other settings stay, its endpoint never leaks into a different provider. */
+export function applyResolved(base, resolved) {
+    const { endpoint: _stale, ...rest } = base;
+    return { ...rest, ...resolved };
 }
 /** Human-readable alias list for `forge config`; '' when there are none. */
 export function formatAliasTable(aliases) {

package/dist/model-catalog.js

@@ -38,7 +38,6 @@ export const MODEL_CATALOG = {
         { id: 'MiniMax-M3', label: 'MiniMax M3' },
         { id: 'MiniMax-M2.7', label: 'MiniMax M2.7' },
         { id: 'MiniMax-M2.7-highspeed', label: 'MiniMax M2.7 highspeed' },
-        { id: 'MiniMax-M2', label: 'MiniMax M2' },
     ],
     bedrock: [
         { id: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0', label: 'Claude Sonnet 4.5 (Bedrock, US)' },