invokora 0.1.0

package/dist/cli/config.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from './types.js';
+export declare class ConfigStore {
+    private readonly configPath;
+    constructor(configPath?: string);
+    get path(): string;
+    load(): Config | null;
+    save(config: Config): void;
+    require(): Config;
+    private ensurePathSafe;
+}
+export declare function loadConfig(configPath?: string): Config | null;
+export declare function saveConfig(config: Config, configPath?: string): void;

package/dist/cli/config.js

@@ -0,0 +1,73 @@
+import { lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { CONFIG_PATH } from './constants.js';
+export class ConfigStore {
+    configPath;
+    constructor(configPath = CONFIG_PATH) {
+        this.configPath = configPath;
+    }
+    get path() {
+        return this.configPath;
+    }
+    load() {
+        if (!isReadableConfigFile(this.configPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(readFileSync(this.configPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    save(config) {
+        this.ensurePathSafe();
+        mkdirSync(dirname(this.configPath), { recursive: true });
+        // 凭证文件先落临时文件再替换，避免中断时把登录态写成半截 JSON。
+        const tmpPath = `${this.configPath}.tmp-${process.pid}-${Date.now()}`;
+        try {
+            writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+            renameSync(tmpPath, this.configPath);
+        }
+        catch (error) {
+            rmSync(tmpPath, { force: true });
+            throw error;
+        }
+    }
+    require() {
+        const config = this.load();
+        if (!config) {
+            throw new Error('Not logged in. Run: invokora login');
+        }
+        return config;
+    }
+    ensurePathSafe() {
+        try {
+            const stat = lstatSync(this.configPath);
+            // 拒绝跟随符号链接，避免凭证被写进用户未预期的位置。
+            if (stat.isSymbolicLink()) {
+                throw new Error(`Refusing to write symlink config path: ${this.configPath}`);
+            }
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code === 'ENOENT')
+                return;
+            throw error;
+        }
+    }
+}
+function isReadableConfigFile(path) {
+    try {
+        return lstatSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function loadConfig(configPath = CONFIG_PATH) {
+    return new ConfigStore(configPath).load();
+}
+export function saveConfig(config, configPath = CONFIG_PATH) {
+    new ConfigStore(configPath).save(config);
+}

package/dist/cli/constants.d.ts

@@ -0,0 +1,24 @@
+import type { McpTarget, McpTargetPickerOption, SyncScope, SyncTarget } from './types.js';
+export declare const INVOKORA_HOME_DIR: string;
+export declare const CONFIG_PATH: string;
+export declare const MCP_SESSION_DIR: string;
+export declare const LANGUAGE_PATH: string;
+export declare const DEFAULT_BACKEND_URL = "https://useskilz.com";
+export declare const API_V1 = "/v1";
+export declare const SKILL_SHELL_MARKER = "The actual skill content is securely managed by Invokora and is never stored locally.";
+export declare const OAUTH_CALLBACK_PATH = "/oauth/callback";
+export declare const OAUTH_DEFAULT_TIMEOUT_MS = 120000;
+export declare const MCP_TARGET_ALIASES: {
+    readonly '1': "claude";
+    readonly claude: "claude";
+    readonly '2': "cursor";
+    readonly cursor: "cursor";
+    readonly '3': "codex";
+    readonly codex: "codex";
+};
+export declare const SYNC_SCOPE_ALIASES: Record<string, SyncScope>;
+export declare const SYNC_TARGET_ALIASES: Record<string, SyncTarget>;
+export declare const DEFAULT_MCP_TARGET_INPUT = "1,2,3";
+export declare const DEFAULT_SYNC_TARGET_INPUT = "1";
+export declare const DEFAULT_MCP_CONFIG_PATHS: Record<McpTarget, () => string>;
+export declare const MCP_TARGET_PICKER_OPTIONS: McpTargetPickerOption[];

package/dist/cli/constants.js

@@ -0,0 +1,52 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { DEFAULT_BACKEND_URL as RELEASE_DEFAULT_BACKEND_URL } from './release.js';
+export const INVOKORA_HOME_DIR = join(homedir(), '.invokora');
+export const CONFIG_PATH = join(INVOKORA_HOME_DIR, 'config.json');
+export const MCP_SESSION_DIR = join(INVOKORA_HOME_DIR, 'sessions');
+export const LANGUAGE_PATH = join(INVOKORA_HOME_DIR, 'language');
+export const DEFAULT_BACKEND_URL = RELEASE_DEFAULT_BACKEND_URL;
+export const API_V1 = '/v1';
+export const SKILL_SHELL_MARKER = 'The actual skill content is securely managed by Invokora and is never stored locally.';
+export const OAUTH_CALLBACK_PATH = '/oauth/callback';
+export const OAUTH_DEFAULT_TIMEOUT_MS = 120_000;
+export const MCP_TARGET_ALIASES = {
+    '1': 'claude',
+    claude: 'claude',
+    '2': 'cursor',
+    cursor: 'cursor',
+    '3': 'codex',
+    codex: 'codex',
+};
+export const SYNC_SCOPE_ALIASES = {
+    project: 'project',
+    p: 'project',
+    repo: 'project',
+    workspace: 'project',
+    user: 'user',
+    u: 'user',
+    global: 'user',
+    personal: 'user',
+};
+export const SYNC_TARGET_ALIASES = {
+    '1': 'codex',
+    codex: 'codex',
+    '2': 'claude',
+    claude: 'claude',
+    'claude-code': 'claude',
+    claudecode: 'claude',
+    '3': 'cursor',
+    cursor: 'cursor',
+};
+export const DEFAULT_MCP_TARGET_INPUT = '1,2,3';
+export const DEFAULT_SYNC_TARGET_INPUT = '1';
+export const DEFAULT_MCP_CONFIG_PATHS = {
+    claude: () => join(homedir(), '.claude.json'),
+    cursor: () => join(process.cwd(), '.cursor', 'mcp.json'),
+    codex: () => join(homedir(), '.codex', 'config.toml'),
+};
+export const MCP_TARGET_PICKER_OPTIONS = [
+    { target: 'claude', label: 'Claude', path: '~/.claude.json', summary: 'Project and personal Claude config' },
+    { target: 'cursor', label: 'Cursor', path: '.cursor/mcp.json', summary: 'Workspace-local Cursor MCP config' },
+    { target: 'codex', label: 'Codex', path: '~/.codex/config.toml', summary: 'Global Codex MCP server config' },
+];

package/dist/cli/http.d.ts

@@ -0,0 +1,2 @@
+export declare function errorMessageFromJson(json: unknown, status: number): string;
+export declare function readJsonResponse<T>(response: Response): Promise<T>;

package/dist/cli/http.js

@@ -0,0 +1,23 @@
+export function errorMessageFromJson(json, status) {
+    if (json && typeof json === 'object' && 'error' in json) {
+        const err = json.error;
+        if (typeof err?.message === 'string')
+            return err.message;
+    }
+    return `HTTP ${status}`;
+}
+export async function readJsonResponse(response) {
+    const raw = await response.text();
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error(`Empty response body (HTTP ${response.status})`);
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        const contentType = response.headers.get('content-type') || 'unknown content-type';
+        const snippet = trimmed.length > 160 ? `${trimmed.slice(0, 160)}...` : trimmed;
+        throw new Error(`Expected JSON response but received ${contentType} (HTTP ${response.status}): ${snippet}`);
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export { ConfigStore, loadConfig, saveConfig } from './config.js';
+export { cmdLogin, getUsageText, isMainModule, loadCliLanguage, main, parseCliLanguage, saveCliLanguage, InvokoraCliApp } from './app.js';
+export type { CliLanguage } from './app.js';
+export { base64UrlEncode, buildS256CodeChallenge, chooseLoopbackHost, createOAuthLoopbackListener, exchangeOAuthCode, generateCodeVerifier, generateOAuthState, normalizeCallbackError, OAuthBrowserLoginFlow, OAuthCLIClient, OAuthLoopbackServer, openBrowserURL, parseLoginCommandOptions, runOAuthBrowserLogin, startOAuthCLI, withTimeout, } from './oauth.js';
+export type { AccessibleSkill, Config, LoginCommandOptions, LocalSkillRemovalResult, McpRootJson, McpServerConfig, McpTarget, OAuthCallbackPayload, OAuthExchangeResponse, OAuthLoopbackListener, OAuthStartResponse, RunOAuthBrowserLoginParams, SkillSummary, SyncOptions, SyncResult, } from './types.js';

package/dist/cli/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { isMainModule, main } from './app.js';
+export { ConfigStore, loadConfig, saveConfig } from './config.js';
+export { cmdLogin, getUsageText, isMainModule, loadCliLanguage, main, parseCliLanguage, saveCliLanguage, InvokoraCliApp } from './app.js';
+export { base64UrlEncode, buildS256CodeChallenge, chooseLoopbackHost, createOAuthLoopbackListener, exchangeOAuthCode, generateCodeVerifier, generateOAuthState, normalizeCallbackError, OAuthBrowserLoginFlow, OAuthCLIClient, OAuthLoopbackServer, openBrowserURL, parseLoginCommandOptions, runOAuthBrowserLogin, startOAuthCLI, withTimeout, } from './oauth.js';
+if (isMainModule(import.meta.url)) {
+    main().catch((error) => {
+        console.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/cli/mcp/app.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type HandleChatToolOptions, type StartStdioServerOptions } from './schemas.js';
+import type { ReasoningEffort } from '../types.js';
+export declare class InvokoraMcpApp {
+    private readonly options;
+    constructor(options: HandleChatToolOptions);
+    createServer(): McpServer;
+}
+export declare function createMcpServer(options: HandleChatToolOptions): McpServer;
+export declare function resolveBackendBaseUrl(options?: Partial<StartStdioServerOptions>): string;
+export declare function startStdioServer(options?: Partial<StartStdioServerOptions>): Promise<McpServer>;
+export declare function normalizeReasoningEffort(value: unknown): ReasoningEffort | undefined;

package/dist/cli/mcp/app.js

@@ -0,0 +1,85 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadConfig } from '../config.js';
+import { DEFAULT_BACKEND_URL, RELEASE_VERSION } from '../release.js';
+import { SKILZ_CHAT_TOOL, ChatToolInputSchema, ChatToolOutputSchema, } from './schemas.js';
+import { handleChatTool } from './tool_handlers.js';
+import { createProgressReporter } from './progress.js';
+const SERVER_INSTRUCTIONS = [
+    'Use chat for every Invokora Skill request. Put the user intent and slash command, such as /code-review, in messages.',
+    'Invokora injects hosted Skill content server-side. This MCP server never exposes raw hosted Skill source content.',
+    'This MCP server does not read files, write files, run shell commands, or grant local tools. The host agent decides whether to collect local context and include it in chat messages.',
+    'If a hosted Skill asks for local context or a patch, it returns structured fenced JSON for the host to evaluate; those blocks are not MCP tool calls.',
+    'This server is local stdio MCP only. Remote HTTP MCP is not currently provided.',
+].join('\n');
+export class InvokoraMcpApp {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    createServer() {
+        const server = new McpServer({
+            name: 'invokora',
+            version: RELEASE_VERSION,
+        }, { instructions: SERVER_INSTRUCTIONS });
+        server.registerTool(SKILZ_CHAT_TOOL, {
+            title: 'Chat with Invokora',
+            description: 'Send an Invokora chat turn through the unified Responses API. ' +
+                'Include a slash command such as /code-review in the user message to select or switch Skills; later turns may omit it and continue the local session. ' +
+                'The host agent, not this MCP server, collects local file context and decides whether to apply any suggested actions.',
+            inputSchema: ChatToolInputSchema,
+            outputSchema: ChatToolOutputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+        }, async (input, extra) => handleChatTool(input, {
+            ...this.options,
+            progressReporter: createProgressReporter(extra._meta?.progressToken, extra.sendNotification),
+            signal: extra.signal,
+        }));
+        return server;
+    }
+}
+export function createMcpServer(options) {
+    return new InvokoraMcpApp(options).createServer();
+}
+export function resolveBackendBaseUrl(options = {}) {
+    return options.backendBaseUrl ?? process.env.SKILZ_BACKEND_URL ?? DEFAULT_BACKEND_URL;
+}
+export async function startStdioServer(options = {}) {
+    const localConfig = loadConfig();
+    const backendBaseUrl = options.backendBaseUrl ?? process.env.SKILZ_BACKEND_URL ?? localConfig?.backend_url ?? DEFAULT_BACKEND_URL;
+    const authToken = options.authToken ?? process.env.SKILZ_TOKEN ?? localConfig?.token;
+    const refreshToken = options.refreshToken ?? process.env.SKILZ_REFRESH_TOKEN ?? localConfig?.refresh_token;
+    const apiKey = options.apiKey ?? process.env.SKILZ_API_KEY;
+    const defaultModel = options.defaultModel ?? process.env.SKILZ_DEFAULT_MODEL ?? localConfig?.default_model;
+    const defaultReason = normalizeReasoningEffort(options.defaultReason ?? process.env.SKILZ_DEFAULT_REASON ?? localConfig?.default_reason);
+    const server = createMcpServer({
+        backendBaseUrl,
+        authToken,
+        refreshToken,
+        apiKey,
+        defaultModel,
+        defaultReason,
+        fetchImpl: options.fetchImpl,
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    return server;
+}
+export function normalizeReasoningEffort(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'low' || normalized === 'medium' || normalized === 'high' || normalized === 'xhigh') {
+        return normalized;
+    }
+    throw new Error('default reason must be one of: low, medium, high, xhigh');
+}

package/dist/cli/mcp/backend_client.d.ts

@@ -0,0 +1,10 @@
+import type { ChatToolInput, ChatToolOutput, ChatViaBackendOptions } from './schemas.js';
+export declare class InvokoraBackendClient {
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(options: ChatViaBackendOptions);
+    chat(input: ChatToolInput): Promise<ChatToolOutput>;
+    private runChatSession;
+    private responsesBearerToken;
+}
+export declare function refreshAccessToken(backendBaseUrl: string, refreshToken: string, fetchImpl?: typeof fetch): Promise<string>;

package/dist/cli/mcp/backend_client.js

@@ -0,0 +1,91 @@
+import { runResponsesChatSession } from './responses_session.js';
+import { BackendInvocationError, createBackendInvocationError, formatHttpResponseDiagnostic, getErrorMessage, parseJsonResponse, } from './errors.js';
+export class InvokoraBackendClient {
+    options;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async chat(input) {
+        const bearerToken = await this.responsesBearerToken();
+        try {
+            return await this.runChatSession(input, bearerToken);
+        }
+        catch (error) {
+            if (error instanceof BackendInvocationError && error.status === 401 && !this.options.apiKey && this.options.authToken && this.options.refreshToken) {
+                const refreshed = await refreshAccessToken(this.options.backendBaseUrl, this.options.refreshToken, this.fetchImpl);
+                try {
+                    return await this.runChatSession(input, refreshed);
+                }
+                catch (retryError) {
+                    throw withSupportHint(retryError, this.options.backendBaseUrl, input.session_id);
+                }
+            }
+            throw withSupportHint(error, this.options.backendBaseUrl, input.session_id);
+        }
+    }
+    async runChatSession(input, bearerToken) {
+        return runResponsesChatSession({
+            backendBaseUrl: this.options.backendBaseUrl,
+            apiKey: bearerToken,
+            model: input.model,
+            reason: input.reason,
+            defaultModel: this.options.defaultModel,
+            defaultReason: this.options.defaultReason,
+            sessionID: input.session_id,
+            messages: input.messages,
+            sessionStore: this.options.sessionStore,
+            compactAfterChars: this.options.compactAfterChars,
+            fetchImpl: this.options.fetchImpl,
+            progressReporter: this.options.progressReporter,
+            signal: this.options.signal,
+        });
+    }
+    async responsesBearerToken() {
+        if (this.options.apiKey) {
+            return this.options.apiKey;
+        }
+        if (this.options.authToken) {
+            return this.options.authToken;
+        }
+        throw new Error('Run: invokora login');
+    }
+}
+function withSupportHint(error, backendBaseUrl, sessionId) {
+    const base = error instanceof Error ? error : new Error(String(error));
+    const q = new URLSearchParams();
+    if (sessionId)
+        q.set('session_id', sessionId);
+    q.set('category', 'cannot_invoke');
+    const code = error?.code;
+    if (code)
+        q.set('last_error_code', code);
+    q.set('last_error_message', base.message.slice(0, 500));
+    const supportUrl = new URL(`/workspace/support?${q.toString()}`, backendBaseUrl).toString();
+    return new Error(`${base.message}\nSupport: ${supportUrl}`);
+}
+export async function refreshAccessToken(backendBaseUrl, refreshToken, fetchImpl = fetch) {
+    const url = new URL('/v1/auth/refresh', backendBaseUrl);
+    let response;
+    try {
+        response = await fetchImpl(url.toString(), {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ refresh_token: refreshToken }),
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to reach backend: ${getErrorMessage(error)}`);
+    }
+    const responseBody = await parseJsonResponse(response);
+    const body = responseBody;
+    if (!response.ok) {
+        throw createBackendInvocationError(response.status, responseBody);
+    }
+    const token = body?.token;
+    if (!token) {
+        throw new Error(`Token refresh response missing token field: ${formatHttpResponseDiagnostic(response.status, responseBody)}`);
+    }
+    return token;
+}

package/dist/cli/mcp/errors.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { type ToolResult, type ToolTextContent } from './schemas.js';
+export declare class BackendInvocationError extends Error {
+    readonly code?: string;
+    readonly status: number;
+    readonly requestId?: string;
+    constructor(params: {
+        status: number;
+        message: string;
+        code?: string;
+        requestId?: string;
+    });
+}
+export declare function createErrorResult<TStructured extends Record<string, unknown> = Record<string, unknown>>(message: string, structuredContent?: TStructured): ToolResult<TStructured>;
+export declare function formatToolError(error: unknown): string;
+export declare function formatZodError(error: z.ZodError): string;
+export declare function getErrorMessage(error: unknown): string;
+export declare function parseJsonResponse(response: Response): Promise<unknown>;
+export declare function summarizeResponseBody(responseBody: unknown): string;
+export declare function formatHttpResponseDiagnostic(status: number, responseBody: unknown): string;
+export declare function createBackendInvocationError(status: number, responseBody: unknown): BackendInvocationError;
+export declare function createBackendInvocationErrorFromPayload(status: number, payload: {
+    code?: unknown;
+    message?: unknown;
+}): BackendInvocationError;
+export declare function textContent(text: string): {
+    content: ToolTextContent[];
+};

package/dist/cli/mcp/errors.js

@@ -0,0 +1,139 @@
+import { BackendErrorResponseSchema } from './schemas.js';
+const RESPONSE_BODY_SNIPPET_LIMIT = 200;
+const KNOWN_BACKEND_ERROR_MESSAGES = {
+    BALANCE_EXHAUSTED: 'Wallet balance is too low. Top up your Invokora wallet before continuing.',
+    INSUFFICIENT_WALLET_BALANCE: 'Wallet balance is too low. Top up your Invokora wallet before continuing.',
+    'balance_exhausted': 'Wallet balance is too low. Top up your Invokora wallet before continuing.',
+    'error.insufficient_wallet_balance': 'Wallet balance is too low. Top up your Invokora wallet before continuing.',
+};
+export class BackendInvocationError extends Error {
+    code;
+    status;
+    requestId;
+    constructor(params) {
+        super(params.message);
+        this.name = 'BackendInvocationError';
+        this.status = params.status;
+        this.code = params.code;
+        this.requestId = params.requestId;
+    }
+}
+export function createErrorResult(message, structuredContent) {
+    return {
+        content: [{ type: 'text', text: message }],
+        ...(structuredContent ? { structuredContent } : {}),
+        isError: true,
+    };
+}
+export function formatToolError(error) {
+    if (error instanceof BackendInvocationError) {
+        return error.message;
+    }
+    return getErrorMessage(error);
+}
+export function formatZodError(error) {
+    return error.issues
+        .map((issue) => {
+        const path = issue.path.join('.');
+        return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+    })
+        .join('; ');
+}
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function parseJsonResponse(response) {
+    const bodyText = await response.text();
+    if (bodyText.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(bodyText);
+    }
+    catch {
+        return bodyText;
+    }
+}
+export function summarizeResponseBody(responseBody) {
+    if (responseBody === undefined) {
+        return 'empty response body';
+    }
+    const raw = typeof responseBody === 'string'
+        ? responseBody
+        : (() => {
+            try {
+                return JSON.stringify(responseBody);
+            }
+            catch {
+                return String(responseBody);
+            }
+        })();
+    const normalized = raw.replace(/\s+/g, ' ').trim();
+    if (normalized.length === 0) {
+        return 'empty response body';
+    }
+    if (normalized.length <= RESPONSE_BODY_SNIPPET_LIMIT) {
+        return normalized;
+    }
+    return `${normalized.slice(0, RESPONSE_BODY_SNIPPET_LIMIT)}...`;
+}
+export function formatHttpResponseDiagnostic(status, responseBody) {
+    const parsedError = BackendErrorResponseSchema.safeParse(responseBody);
+    if (parsedError.success) {
+        const readableMessage = formatKnownBackendErrorMessage(parsedError.data.error);
+        if (readableMessage) {
+            const codeSuffix = parsedError.data.error.code ? ` (${parsedError.data.error.code})` : '';
+            const requestIdSuffix = parsedError.data.request_id ? ` request_id=${parsedError.data.request_id}` : '';
+            return `${readableMessage}${codeSuffix}${requestIdSuffix}`;
+        }
+        const requestIdSuffix = parsedError.data.request_id ? ` request_id=${parsedError.data.request_id}` : '';
+        return `HTTP ${status} ${parsedError.data.error.code}: ${parsedError.data.error.message}${requestIdSuffix}`;
+    }
+    return `HTTP ${status}; response=${summarizeResponseBody(responseBody)}`;
+}
+export function createBackendInvocationError(status, responseBody) {
+    const parsedError = BackendErrorResponseSchema.safeParse(responseBody);
+    const diagnostic = formatHttpResponseDiagnostic(status, responseBody);
+    if (parsedError.success) {
+        return new BackendInvocationError({
+            status,
+            code: parsedError.data.error.code,
+            message: diagnostic,
+            requestId: parsedError.data.request_id,
+        });
+    }
+    return new BackendInvocationError({
+        status,
+        message: diagnostic,
+    });
+}
+export function createBackendInvocationErrorFromPayload(status, payload) {
+    const code = normalizeBackendErrorToken(payload.code);
+    const message = normalizeBackendErrorToken(payload.message);
+    const readableMessage = formatKnownBackendErrorMessage({ code, message });
+    return new BackendInvocationError({
+        status,
+        message: readableMessage ?? message ?? (code ? `Backend returned ${code}` : 'Backend invocation failed'),
+        ...(code ? { code } : {}),
+    });
+}
+function formatKnownBackendErrorMessage(error) {
+    const code = normalizeBackendErrorToken(error.code);
+    if (code && KNOWN_BACKEND_ERROR_MESSAGES[code]) {
+        return KNOWN_BACKEND_ERROR_MESSAGES[code];
+    }
+    const message = normalizeBackendErrorToken(error.message);
+    if (message && KNOWN_BACKEND_ERROR_MESSAGES[message]) {
+        return KNOWN_BACKEND_ERROR_MESSAGES[message];
+    }
+    return undefined;
+}
+function normalizeBackendErrorToken(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function textContent(text) {
+    return { content: [{ type: 'text', text }] };
+}

package/dist/cli/mcp/progress.d.ts

@@ -0,0 +1,12 @@
+import type { ProgressToken, ServerNotification } from '@modelcontextprotocol/sdk/types.js';
+export type ProgressUpdate = {
+    progress: number;
+    total?: number;
+    message?: string;
+};
+export type ProgressReporter = {
+    report(update: ProgressUpdate): Promise<void>;
+};
+type SendNotification = (notification: ServerNotification) => Promise<void>;
+export declare function createProgressReporter(progressToken: ProgressToken | undefined, sendNotification: SendNotification): ProgressReporter | undefined;
+export {};

package/dist/cli/mcp/progress.js

@@ -0,0 +1,49 @@
+export function createProgressReporter(progressToken, sendNotification) {
+    if (progressToken === undefined) {
+        return undefined;
+    }
+    let disabled = false;
+    let lastProgress = Number.NEGATIVE_INFINITY;
+    return {
+        async report(update) {
+            if (disabled) {
+                return;
+            }
+            const progress = nextMonotonicProgress(update.progress, update.total, lastProgress);
+            if (progress === undefined) {
+                return;
+            }
+            lastProgress = progress;
+            try {
+                await sendNotification({
+                    method: 'notifications/progress',
+                    params: {
+                        progressToken,
+                        progress,
+                        ...(update.total !== undefined ? { total: update.total } : {}),
+                        ...(update.message ? { message: update.message } : {}),
+                    },
+                });
+            }
+            catch {
+                disabled = true;
+            }
+        },
+    };
+}
+function nextMonotonicProgress(progress, total, lastProgress) {
+    if (!Number.isFinite(progress)) {
+        return undefined;
+    }
+    let next = progress;
+    if (next <= lastProgress) {
+        next = lastProgress + 0.001;
+    }
+    if (total !== undefined && next > total) {
+        if (lastProgress >= total) {
+            return undefined;
+        }
+        next = total;
+    }
+    return next;
+}

package/dist/cli/mcp/responses_session.d.ts

@@ -0,0 +1,21 @@
+import { McpSessionStore, type ChatMessage } from './session_store.js';
+import type { ChatToolOutput } from './schemas.js';
+import type { ProgressReporter } from './progress.js';
+import type { ReasoningEffort } from '../types.js';
+type ResponsesChatSessionOptions = {
+    backendBaseUrl: string;
+    apiKey: string;
+    messages: ChatMessage[];
+    sessionID?: string;
+    model?: string;
+    reason?: ReasoningEffort;
+    defaultModel?: string;
+    defaultReason?: ReasoningEffort;
+    sessionStore?: McpSessionStore;
+    fetchImpl?: typeof fetch;
+    compactAfterChars?: number;
+    progressReporter?: ProgressReporter;
+    signal?: AbortSignal;
+};
+export declare function runResponsesChatSession(options: ResponsesChatSessionOptions): Promise<ChatToolOutput>;
+export {};