@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/providers/tool-formats.js

@@ -0,0 +1,306 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/** Convert internal ToolDefinitions to OpenAI tools array. */
+export function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+/** Parse OpenAI tool_calls from a response into internal ToolCall[]. */
+export function fromOpenAIToolCalls(calls) {
+    return calls.map((c) => ({
+        id: c.id,
+        name: c.function.name,
+        arguments: parseJson(c.function.arguments),
+    }));
+}
+/** Convert internal ProviderMessages to OpenAI message array. */
+export function toOpenAIMessages(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+        result.push({ role: 'system', content: systemPrompt });
+    }
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            if (Array.isArray(msg.content)) {
+                // ContentPart[] — convert to OpenAI multimodal parts
+                const parts = msg.content.map((part) => {
+                    if (part.type === 'text')
+                        return { type: 'text', text: part.text };
+                    return { type: 'image_url', image_url: { url: `data:${part.mediaType};base64,${part.data}` } };
+                });
+                result.push({ role: 'user', content: parts });
+            }
+            else {
+                result.push({ role: 'user', content: msg.content });
+            }
+        }
+        else if (msg.role === 'assistant') {
+            const m = { role: 'assistant', content: msg.content ?? '' };
+            if (msg.toolCalls && msg.toolCalls.length > 0) {
+                m.tool_calls = msg.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+                }));
+            }
+            result.push(m);
+        }
+        else if (msg.role === 'tool') {
+            result.push({
+                role: 'tool',
+                content: msg.content,
+                tool_call_id: msg.callId,
+            });
+        }
+    }
+    return result;
+}
+/** Convert internal ToolDefinitions to Anthropic tools array. */
+export function toAnthropicTools(tools) {
+    return tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters,
+    }));
+}
+/** Parse Anthropic response content blocks into text + ToolCall[]. */
+export function fromAnthropicContent(content) {
+    let text = '';
+    const toolCalls = [];
+    for (const block of content) {
+        if (block.type === 'text') {
+            text += block.text;
+        }
+        else if (block.type === 'tool_use') {
+            toolCalls.push({ id: block.id, name: block.name, arguments: block.input });
+        }
+    }
+    return { text, toolCalls };
+}
+/** Convert internal ProviderMessages to Anthropic message array. */
+export function toAnthropicMessages(messages) {
+    const result = [];
+    // Collect consecutive tool results to merge into one user message
+    let pendingToolResults = [];
+    function flushToolResults() {
+        if (pendingToolResults.length > 0) {
+            result.push({ role: 'user', content: pendingToolResults });
+            pendingToolResults = [];
+        }
+    }
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            flushToolResults();
+            if (Array.isArray(msg.content)) {
+                // ContentPart[] — convert to Anthropic content blocks
+                const blocks = msg.content.map((part) => {
+                    if (part.type === 'text')
+                        return { type: 'text', text: part.text };
+                    return {
+                        type: 'image',
+                        source: { type: 'base64', media_type: part.mediaType, data: part.data },
+                    };
+                });
+                result.push({ role: 'user', content: blocks });
+            }
+            else {
+                result.push({ role: 'user', content: msg.content });
+            }
+        }
+        else if (msg.role === 'assistant') {
+            flushToolResults();
+            if (msg.toolCalls && msg.toolCalls.length > 0) {
+                const blocks = [];
+                if (msg.content)
+                    blocks.push({ type: 'text', text: msg.content });
+                for (const tc of msg.toolCalls) {
+                    blocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.arguments });
+                }
+                result.push({ role: 'assistant', content: blocks });
+            }
+            else {
+                result.push({ role: 'assistant', content: msg.content });
+            }
+        }
+        else if (msg.role === 'tool') {
+            pendingToolResults.push({
+                type: 'tool_result',
+                tool_use_id: msg.callId,
+                content: msg.content,
+            });
+        }
+    }
+    flushToolResults();
+    return result;
+}
+/** Strip properties that Gemini's API doesn't support (e.g. additionalProperties). */
+function stripUnsupportedProperties(obj) {
+    if (Array.isArray(obj))
+        return obj.map(stripUnsupportedProperties);
+    if (obj !== null && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === 'additionalProperties')
+                continue;
+            result[key] = stripUnsupportedProperties(value);
+        }
+        return result;
+    }
+    return obj;
+}
+/** Convert internal ToolDefinitions to Gemini functionDeclarations. */
+export function toGeminiFunctionDeclarations(tools) {
+    return tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: stripUnsupportedProperties(t.parameters),
+    }));
+}
+/** Parse Gemini response parts into text + ToolCall[]. */
+export function fromGeminiParts(parts) {
+    let text = '';
+    const toolCalls = [];
+    for (const part of parts) {
+        if (part.text) {
+            text += part.text;
+        }
+        else if (part.functionCall) {
+            toolCalls.push({
+                id: crypto.randomUUID(),
+                name: part.functionCall.name,
+                arguments: part.functionCall.args,
+            });
+        }
+    }
+    return { text, toolCalls };
+}
+/** Convert internal ProviderMessages to Gemini contents array. */
+export function toGeminiContents(messages, systemPrompt) {
+    const contents = [];
+    const systemInstruction = systemPrompt
+        ? { parts: [{ text: systemPrompt }] }
+        : undefined;
+    let pendingFunctionResponses = [];
+    function flushFunctionResponses() {
+        if (pendingFunctionResponses.length > 0) {
+            contents.push({ role: 'user', parts: pendingFunctionResponses });
+            pendingFunctionResponses = [];
+        }
+    }
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            flushFunctionResponses();
+            if (Array.isArray(msg.content)) {
+                // ContentPart[] — convert to Gemini parts
+                const parts = msg.content.map((part) => {
+                    if (part.type === 'text')
+                        return { text: part.text };
+                    return { inlineData: { mimeType: part.mediaType, data: part.data } };
+                });
+                contents.push({ role: 'user', parts });
+            }
+            else {
+                contents.push({ role: 'user', parts: [{ text: msg.content }] });
+            }
+        }
+        else if (msg.role === 'assistant') {
+            flushFunctionResponses();
+            const parts = [];
+            if (msg.content)
+                parts.push({ text: msg.content });
+            if (msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    parts.push({ functionCall: { name: tc.name, args: tc.arguments } });
+                }
+            }
+            contents.push({ role: 'model', parts });
+        }
+        else if (msg.role === 'tool') {
+            pendingFunctionResponses.push({
+                functionResponse: {
+                    name: msg.name ?? msg.callId,
+                    response: { content: msg.content },
+                },
+            });
+        }
+    }
+    flushFunctionResponses();
+    return { contents, systemInstruction };
+}
+// ---------------------------------------------------------------------------
+// Text-based tool call extraction (for models that emit tool calls as tokens)
+// ---------------------------------------------------------------------------
+/**
+ * Extracts tool calls from raw text content for models (e.g. kimi-k2-thinking
+ * via ollama-cloud) that emit tool calls as text tokens instead of using the
+ * OpenAI function-calling wire format.
+ *
+ * Supports two delimiter formats (both emitted by kimi variants):
+ *   Without underscores: <|toolcallbegin|>functions.TOOLNAME:INDEX<|toolcallargumentbegin|>JSON_ARGS<|toolcallend|>
+ *   With underscores:    <|tool_call_begin|>functions.TOOLNAME:INDEX<|tool_call_argument_begin|>JSON_ARGS<|tool_call_end|>
+ *
+ * A trailing <|tool_calls_section_end|> or <|toolcallssectionend|> is also
+ * stripped from the cleaned content.
+ *
+ * @returns Extracted ToolCall array and the content with all tool-call tokens
+ * removed (trimmed). Returns empty array when no text-based calls are found.
+ */
+export function extractTextToolCalls(content) {
+    // Fast path: skip regex work when neither sentinel variant is present
+    if (!content.includes('<|toolcallbegin|>') && !content.includes('<|tool_call_begin|>')) {
+        return { toolCalls: [], cleanedContent: content };
+    }
+    // Match both delimiter variants using optional underscores.
+    // The `.*?` lazy match with /s is safe here: backtracking is bounded by
+    // the end delimiter, which appears within kilobytes of the argument-begin
+    // delimiter — the span of a single tool call's JSON args.
+    // kimi is the known model that emits these delimiter formats.
+    const pattern = /<\|tool_?call_?begin\|>functions\.([^:]+):\d+<\|tool_?call_?argument_?begin\|>(.*?)<\|tool_?call_?end\|>/gs;
+    const toolCalls = [];
+    // Build cleaned content in a single pass by collecting match spans,
+    // avoiding a second regex execution over the same string.
+    const segments = [];
+    let lastEnd = 0;
+    let index = 0;
+    for (const match of content.matchAll(pattern)) {
+        const matchStart = match.index;
+        const matchEnd = matchStart + match[0].length;
+        // Collect the text before this match
+        segments.push(content.slice(lastEnd, matchStart));
+        lastEnd = matchEnd;
+        const toolName = match[1];
+        const rawArgs = match[2];
+        toolCalls.push({
+            id: `text-call-${index}`,
+            name: toolName,
+            arguments: parseJson(rawArgs),
+        });
+        index++;
+    }
+    // Append any trailing text after the last match
+    segments.push(content.slice(lastEnd));
+    // Strip section-end sentinels (both variants) and trim
+    const cleanedContent = segments
+        .join('')
+        .replace(/<\|tool_?calls_?section_?end\|>/g, '')
+        .trim();
+    return { toolCalls, cleanedContent };
+}
+// ---------------------------------------------------------------------------
+// Shared helper
+// ---------------------------------------------------------------------------
+function parseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        logger.warn('tool-formats: failed to parse JSON tool arguments', { error: summarizeError(err) });
+        return {};
+    }
+}

package/dist/_internal/platform/runtime/auth/inspection.d.ts

@@ -0,0 +1,35 @@
+import { SecretsManager } from '../../config/secrets.js';
+import { ServiceRegistry } from '../../config/service-registry.js';
+import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
+export type AuthInspectionFreshness = 'healthy' | 'expiring' | 'expired' | 'pending' | 'available' | 'unconfigured';
+export interface ProviderAuthInspection {
+    readonly provider: string;
+    readonly configured: boolean;
+    readonly source?: 'service' | 'builtin';
+    readonly freshness: AuthInspectionFreshness;
+    readonly redirectUri?: string;
+    readonly callbackMode: 'local' | 'manual';
+    readonly localCallback?: string;
+    readonly activeSubscription: boolean;
+    readonly pendingLogin: boolean;
+    readonly overrideAmbientApiKeys: boolean;
+    readonly tokenType?: string;
+    readonly expiresAt?: number;
+    readonly issues: readonly string[];
+    readonly nextActions: readonly string[];
+}
+export interface AuthInspectionSnapshot {
+    readonly generatedAt: number;
+    readonly secretKeyCount: number;
+    readonly activeSubscriptions: number;
+    readonly pendingSubscriptions: number;
+    readonly providers: readonly ProviderAuthInspection[];
+}
+export interface AuthInspectionDeps {
+    readonly serviceRegistry: Pick<ServiceRegistry, 'get' | 'getAll'>;
+    readonly subscriptionManager: Pick<SubscriptionManager, 'get' | 'getPending' | 'list' | 'listPending'>;
+    readonly secretsManager: Pick<SecretsManager, 'list'>;
+}
+export declare function inspectProviderAuth(provider: string, deps: AuthInspectionDeps): Promise<ProviderAuthInspection>;
+export declare function buildAuthInspectionSnapshot(deps: AuthInspectionDeps): Promise<AuthInspectionSnapshot>;
+//# sourceMappingURL=inspection.d.ts.map

package/dist/_internal/platform/runtime/auth/inspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/auth/inspection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAA6B,MAAM,qDAAqD,CAAC;AAGrH,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,CAAC;AAEpH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,uBAAuB,CAAC;IAC5C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACvD;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;IAClE,QAAQ,CAAC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,EAAE,KAAK,GAAG,YAAY,GAAG,MAAM,GAAG,aAAa,CAAC,CAAC;IACvG,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;CACvD;AAWD,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,sBAAsB,CAAC,CAgDjC;AAED,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,sBAAsB,CAAC,CAsBjC"}

package/dist/_internal/platform/runtime/auth/inspection.js

@@ -0,0 +1,87 @@
+import { SecretsManager } from '../../config/secrets.js';
+import { ServiceRegistry } from '../../config/service-registry.js';
+import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
+import { getSubscriptionProviderConfig } from '../../config/subscription-providers.js';
+function determineFreshness(subscription, pending, configured) {
+    if (pending)
+        return 'pending';
+    if (!subscription)
+        return configured ? 'available' : 'unconfigured';
+    if (typeof subscription.expiresAt !== 'number' || !Number.isFinite(subscription.expiresAt))
+        return 'healthy';
+    if (subscription.expiresAt <= Date.now())
+        return 'expired';
+    if (subscription.expiresAt <= Date.now() + 24 * 60 * 60 * 1000)
+        return 'expiring';
+    return 'healthy';
+}
+export async function inspectProviderAuth(provider, deps) {
+    const service = deps.serviceRegistry.get(provider);
+    const resolved = getSubscriptionProviderConfig(provider, service);
+    const subscription = deps.subscriptionManager.get(provider);
+    const pending = deps.subscriptionManager.getPending(provider);
+    const configured = resolved != null;
+    const freshness = determineFreshness(subscription, pending != null, configured);
+    const issues = [];
+    const nextActions = [];
+    if (!configured) {
+        issues.push('No provider OAuth configuration is available.');
+        nextActions.push(`Add provider OAuth config or a built-in adapter before using /subscription login ${provider} start.`);
+    }
+    if (freshness === 'expired') {
+        issues.push('Stored provider session is expired.');
+        nextActions.push(`Refresh or replace the stored ${provider} session.`);
+    }
+    else if (freshness === 'expiring') {
+        issues.push('Stored provider session expires within 24 hours.');
+        nextActions.push(`Verify or renew the stored ${provider} session soon.`);
+    }
+    else if (freshness === 'pending') {
+        issues.push('OAuth login has started but has not been completed.');
+        nextActions.push(`Finish /subscription login ${provider} finish <code-or-url>.`);
+    }
+    else if (freshness === 'available') {
+        nextActions.push(`Start /subscription login ${provider} start to create a stored session.`);
+    }
+    const callbackMode = resolved?.oauth.localCallback ? 'local' : 'manual';
+    const localCallback = resolved?.oauth.localCallback
+        ? `${resolved.oauth.localCallback.host ?? 'localhost'}:${resolved.oauth.localCallback.port ?? 80}${resolved.oauth.localCallback.path ?? '/'}`
+        : undefined;
+    return Object.freeze({
+        provider,
+        configured,
+        ...(resolved ? { source: resolved.source } : {}),
+        freshness,
+        ...(resolved ? { redirectUri: resolved.oauth.redirectUri } : {}),
+        callbackMode,
+        ...(localCallback ? { localCallback } : {}),
+        activeSubscription: subscription != null,
+        pendingLogin: pending != null,
+        overrideAmbientApiKeys: subscription?.overrideAmbientApiKeys ?? false,
+        ...(subscription?.tokenType ? { tokenType: subscription.tokenType } : {}),
+        ...(subscription?.expiresAt ? { expiresAt: subscription.expiresAt } : {}),
+        issues,
+        nextActions,
+    });
+}
+export async function buildAuthInspectionSnapshot(deps) {
+    const secrets = await deps.secretsManager.list();
+    const services = deps.serviceRegistry.getAll();
+    const providerIds = new Set([
+        ...Object.values(services)
+            .filter((service) => service.authType === 'oauth' && service.oauth)
+            .map((service) => service.providerId ?? service.name),
+        ...deps.subscriptionManager.list().map((entry) => entry.provider),
+        ...deps.subscriptionManager.listPending().map((entry) => entry.provider),
+    ]);
+    const providers = await Promise.all([...providerIds]
+        .sort((a, b) => a.localeCompare(b))
+        .map((provider) => inspectProviderAuth(provider, deps)));
+    return Object.freeze({
+        generatedAt: Date.now(),
+        secretKeyCount: secrets.length,
+        activeSubscriptions: deps.subscriptionManager.list().length,
+        pendingSubscriptions: deps.subscriptionManager.listPending().length,
+        providers,
+    });
+}

package/dist/_internal/platform/runtime/bootstrap-background.d.ts

@@ -0,0 +1,32 @@
+import type { ConfigManager } from '../config/manager.js';
+import type { ProviderRegistry } from '../providers/registry.js';
+import type { McpRegistry } from '../mcp/registry.js';
+import type { ShellPathService } from './shell-paths.js';
+export interface RuntimeSelectionState {
+    model: string;
+    provider: string;
+}
+export interface HostSystemMessageSink {
+    low(message: string): void;
+    high(message: string): void;
+}
+export interface BackgroundProviderDiscoveryOptions {
+    configManager: ConfigManager;
+    providerRegistry: ProviderRegistry;
+    runtime: RuntimeSelectionState;
+    requestRender: () => void;
+    restoreSavedModel: (providerRegistry: ProviderRegistry, savedModel: string, savedProvider: string, runtime: RuntimeSelectionState) => void;
+    systemMessageRouter: HostSystemMessageSink;
+    shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>;
+}
+export declare function startBackgroundProviderDiscovery(options: BackgroundProviderDiscoveryOptions): void;
+export interface BackgroundMcpDiscoveryOptions {
+    mcpRegistry: McpRegistry;
+    systemMessageRouter: HostSystemMessageSink;
+    requestRender: () => void;
+    shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>;
+}
+export declare function scheduleBackgroundMcpDiscovery(options: BackgroundMcpDiscoveryOptions): void;
+export declare const startBackgroundProviderRegistration: typeof startBackgroundProviderDiscovery;
+export declare const scheduleMcpAutodiscovery: typeof scheduleBackgroundMcpDiscovery;
+//# sourceMappingURL=bootstrap-background.d.ts.map

package/dist/_internal/platform/runtime/bootstrap-background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-background.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/bootstrap-background.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGzD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,kCAAkC;IACjD,aAAa,EAAE,aAAa,CAAC;IAC7B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,iBAAiB,EAAE,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAC3I,mBAAmB,EAAE,qBAAqB,CAAC;IAC3C,UAAU,EAAE,IAAI,CAAC,gBAAgB,EAAE,kBAAkB,GAAG,eAAe,CAAC,CAAC;CAC1E;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,kCAAkC,GAC1C,IAAI,CA6FN;AAED,MAAM,WAAW,6BAA6B;IAC5C,WAAW,EAAE,WAAW,CAAC;IACzB,mBAAmB,EAAE,qBAAqB,CAAC;IAC3C,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,UAAU,EAAE,IAAI,CAAC,gBAAgB,EAAE,kBAAkB,GAAG,eAAe,CAAC,CAAC;CAC1E;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,6BAA6B,GAAG,IAAI,CAqB3F;AAED,eAAO,MAAM,mCAAmC,yCAAmC,CAAC;AACpF,eAAO,MAAM,wBAAwB,uCAAiC,CAAC"}

package/dist/_internal/platform/runtime/bootstrap-background.js

@@ -0,0 +1,96 @@
+import { logger } from '../utils/logger.js';
+import { autoRegisterProviders } from '../providers/auto-register.js';
+import { scan, loadPersistedProviders, persistProviders, removePersistedProviders, scanMcpServers } from '../discovery/index.js';
+import { summarizeError } from '../utils/error-display.js';
+export function startBackgroundProviderDiscovery(options) {
+    const { configManager, providerRegistry, runtime, requestRender, restoreSavedModel, systemMessageRouter, shellPaths } = options;
+    autoRegisterProviders(providerRegistry);
+    const persisted = loadPersistedProviders(shellPaths);
+    if (persisted.length > 0) {
+        try {
+            providerRegistry.registerDiscoveredProviders(persisted);
+            restoreSavedModel(providerRegistry, configManager.get('provider.model'), configManager.get('provider.provider'), runtime);
+            for (const server of persisted) {
+                systemMessageRouter.low(`[Local] ${server.name} at ${server.host}:${server.port} (${server.models.length} model${server.models.length !== 1 ? 's' : ''}) — from last session`);
+            }
+            requestRender();
+        }
+        catch (err) {
+            logger.debug('[bootstrap] Non-fatal error during persisted provider registration', {
+                error: summarizeError(err),
+            });
+        }
+    }
+    scan().then((result) => {
+        const currentModel = configManager.get('provider.model');
+        const foundKeys = new Set(result.servers.map((server) => `${server.host}:${server.port}`));
+        const persistedKeys = new Set(persisted.map((server) => `${server.host}:${server.port}`));
+        const newServers = result.servers.filter((server) => !persistedKeys.has(`${server.host}:${server.port}`));
+        const removedServers = persisted.filter((server) => !foundKeys.has(`${server.host}:${server.port}`));
+        if (result.servers.length > 0) {
+            try {
+                providerRegistry.registerDiscoveredProviders(result.servers);
+                restoreSavedModel(providerRegistry, configManager.get('provider.model'), configManager.get('provider.provider'), runtime);
+            }
+            catch (err) {
+                logger.debug('[bootstrap] Non-fatal error during scan provider registration', {
+                    error: summarizeError(err),
+                });
+            }
+        }
+        for (const server of newServers) {
+            systemMessageRouter.low(`[Scan] Found ${server.name} at ${server.host}:${server.port} (${server.models.length} model${server.models.length !== 1 ? 's' : ''})`);
+        }
+        if (result.servers.length > 0 && removedServers.length > 0) {
+            removePersistedProviders(shellPaths, removedServers);
+            for (const server of removedServers) {
+                systemMessageRouter.low(`[Scan] ${server.name} at ${server.host}:${server.port} is no longer reachable — removed`);
+                const wasActive = server.models.includes(currentModel);
+                if (wasActive) {
+                    configManager.set('provider.model', 'openrouter/free');
+                    configManager.set('provider.provider', 'openrouter');
+                    try {
+                        providerRegistry.setCurrentModel('openrouter/free');
+                        runtime.model = 'openrouter/free';
+                        runtime.provider = 'openrouter';
+                    }
+                    catch (err) {
+                        logger.debug('[bootstrap] Non-fatal error switching model after server removal', {
+                            error: summarizeError(err),
+                        });
+                    }
+                    systemMessageRouter.high(`[Scan] Active model was on ${server.name} — switched to openrouter/free`);
+                }
+            }
+        }
+        if (result.servers.length > 0) {
+            persistProviders(shellPaths, result.servers);
+        }
+        if (newServers.length > 0 || removedServers.length > 0) {
+            requestRender();
+        }
+    }).catch(() => {
+        // Non-fatal: scan failure expected when no local LLMs are running
+    });
+}
+export function scheduleBackgroundMcpDiscovery(options) {
+    const { mcpRegistry, systemMessageRouter, requestRender, shellPaths } = options;
+    mcpRegistry.connectAll(shellPaths).catch((err) => {
+        logger.debug('MCP auto-connect failed (non-fatal)', { error: summarizeError(err) });
+    });
+    setTimeout(() => {
+        const registeredNames = new Set(mcpRegistry.serverNames);
+        scanMcpServers(shellPaths, registeredNames).then((result) => {
+            if (result.suggestions.length === 0)
+                return;
+            for (const suggestion of result.suggestions) {
+                systemMessageRouter.low(`[MCP] Discovered server '${suggestion.name}' (${suggestion.command} ${(suggestion.args ?? []).join(' ')}). Add it to .goodvibes/mcp.json or ~/.config/mcp/mcp.json to enable it.`);
+            }
+            requestRender();
+        }).catch((err) => {
+            logger.debug('MCP auto-discovery scan failed (non-fatal)', { error: summarizeError(err) });
+        });
+    }, 2000);
+}
+export const startBackgroundProviderRegistration = startBackgroundProviderDiscovery;
+export const scheduleMcpAutodiscovery = scheduleBackgroundMcpDiscovery;

package/dist/_internal/platform/runtime/bootstrap-helpers.d.ts

@@ -0,0 +1,15 @@
+import type { ConfigManager } from '../config/manager.js';
+import type { ServiceRegistry } from '../config/service-registry.js';
+import type { ProviderRegistry } from '../providers/registry.js';
+import type { IntegrationRecord } from './store/domains/integrations.js';
+export interface RuntimeModelSelectionState {
+    model: string;
+    provider: string;
+}
+export declare function loadRuntimeSystemPrompt(configManager: ConfigManager): string;
+export declare function synchronizeConfiguredServices(syncIntegration: (record: IntegrationRecord, source?: string) => void, serviceRegistry: ServiceRegistry): Promise<void>;
+export declare function restoreRuntimeModel(providerRegistry: ProviderRegistry, savedModel: string, savedProvider: string, runtime: RuntimeModelSelectionState): void;
+export declare const loadBootstrapSystemPrompt: typeof loadRuntimeSystemPrompt;
+export declare const syncConfiguredServices: typeof synchronizeConfiguredServices;
+export declare const restoreSavedModel: typeof restoreRuntimeModel;
+//# sourceMappingURL=bootstrap-helpers.d.ts.map

package/dist/_internal/platform/runtime/bootstrap-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-helpers.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/bootstrap-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAMzE,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAUD,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,aAAa,GAAG,MAAM,CAiB5E;AAED,wBAAsB,6BAA6B,CACjD,eAAe,EAAE,CAAC,MAAM,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,EACrE,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,IAAI,CAAC,CAyBf;AAED,wBAAgB,mBAAmB,CACjC,gBAAgB,EAAE,gBAAgB,EAClC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,0BAA0B,GAClC,IAAI,CAeN;AAED,eAAO,MAAM,yBAAyB,gCAA0B,CAAC;AACjE,eAAO,MAAM,sBAAsB,sCAAgC,CAAC;AACpE,eAAO,MAAM,iBAAiB,4BAAsB,CAAC"}

package/dist/_internal/platform/runtime/bootstrap-helpers.js

@@ -0,0 +1,74 @@
+import { logger } from '../utils/logger.js';
+import { loadSystemPrompt as _loadSystemPrompt } from '../utils/prompt-loader.js';
+import { isAbsolute, resolve } from 'node:path';
+import { summarizeError } from '../utils/error-display.js';
+function requireOwnedPromptRoot(path, name) {
+    const trimmed = path?.trim();
+    if (!trimmed) {
+        throw new Error(`loadRuntimeSystemPrompt requires ConfigManager with explicit ${name}.`);
+    }
+    return trimmed;
+}
+export function loadRuntimeSystemPrompt(configManager) {
+    const workingDirectory = requireOwnedPromptRoot(configManager.getWorkingDirectory(), 'workingDirectory');
+    const homeDirectory = requireOwnedPromptRoot(configManager.getHomeDirectory(), 'homeDirectory');
+    return _loadSystemPrompt({
+        workingDirectory,
+        homeDirectory,
+        getConfigPath: () => {
+            const configuredPath = configManager.get('provider.systemPromptFile');
+            if (typeof configuredPath !== 'string' || !configuredPath.trim())
+                return undefined;
+            return isAbsolute(configuredPath)
+                ? resolve(configuredPath)
+                : resolve(workingDirectory, configuredPath);
+        },
+        argv: process.argv,
+    });
+}
+export async function synchronizeConfiguredServices(syncIntegration, serviceRegistry) {
+    const services = serviceRegistry.getAll();
+    await Promise.all(Object.entries(services).map(async ([id, config]) => {
+        const inspection = await serviceRegistry.inspect(id);
+        if (!inspection)
+            return;
+        syncIntegration({
+            id,
+            displayName: config.name || id,
+            category: 'custom',
+            status: inspection.hasPrimaryCredential ? 'healthy' : 'unconfigured',
+            enabled: true,
+            successCount: 0,
+            errorCount: 0,
+            meta: {
+                authType: config.authType,
+                baseUrl: config.baseUrl ?? null,
+                hasPrimaryCredential: inspection.hasPrimaryCredential,
+                hasWebhookUrl: inspection.hasWebhookUrl,
+                hasSigningSecret: inspection.hasSigningSecret,
+                hasPublicKey: inspection.hasPublicKey,
+            },
+        }, 'bootstrap.services');
+    }));
+}
+export function restoreRuntimeModel(providerRegistry, savedModel, savedProvider, runtime) {
+    const registry = providerRegistry.listModels();
+    const modelDef = savedModel.includes(':')
+        ? (registry.find((m) => m.registryKey === savedModel) ?? registry.find((m) => m.id === savedModel))
+        : registry.find((m) => m.id === savedModel && (!savedProvider || m.provider === savedProvider))
+            ?? registry.find((m) => m.id === savedModel);
+    if (!modelDef)
+        return;
+    try {
+        const key = modelDef.registryKey ?? `${modelDef.provider}:${modelDef.id}`;
+        providerRegistry.setCurrentModel(key);
+        runtime.model = key;
+        runtime.provider = modelDef.provider;
+    }
+    catch (err) {
+        logger.debug('Model restore failed (non-fatal)', { error: summarizeError(err) });
+    }
+}
+export const loadBootstrapSystemPrompt = loadRuntimeSystemPrompt;
+export const syncConfiguredServices = synchronizeConfiguredServices;
+export const restoreSavedModel = restoreRuntimeModel;