@bubblebrain-ai/bubble 0.0.35 → 0.0.37

package/dist/external-runtime/grok-provider.js

@@ -0,0 +1,41 @@
+/** Canonical product/picker identity for the subscription-backed runtime. */
+export const GROK_SUBSCRIPTION_PROVIDER_ID = "grok-subscription";
+/** Short command alias accepted by `/provider`, `/login`, and `/logout`. */
+export const GROK_SUBSCRIPTION_COMMAND_ALIAS = "grok";
+export const GROK_SUBSCRIPTION_PROVIDER_NAME = "Grok Subscription";
+export const GROK_SUBSCRIPTION_PROVIDER_LABEL = "Grok Subscription [OAuth]";
+export const GROK_SUBSCRIPTION_PROVIDER = Object.freeze({
+    id: GROK_SUBSCRIPTION_PROVIDER_ID,
+    commandAlias: GROK_SUBSCRIPTION_COMMAND_ALIAS,
+    name: GROK_SUBSCRIPTION_PROVIDER_NAME,
+    label: GROK_SUBSCRIPTION_PROVIDER_LABEL,
+});
+/** Normalize only Grok's public command alias; unrelated provider IDs pass through. */
+export function normalizeGrokSubscriptionProviderId(providerId) {
+    const candidate = providerId.trim().toLowerCase();
+    if (candidate === GROK_SUBSCRIPTION_COMMAND_ALIAS || candidate === GROK_SUBSCRIPTION_PROVIDER_ID) {
+        return GROK_SUBSCRIPTION_PROVIDER_ID;
+    }
+    return providerId;
+}
+export function isGrokSubscriptionProviderId(providerId) {
+    return providerId !== undefined
+        && normalizeGrokSubscriptionProviderId(providerId) === GROK_SUBSCRIPTION_PROVIDER_ID;
+}
+/**
+ * Append one canonical Grok row after native provider rows. Existing canonical
+ * or command-alias rows are replaced, so independently composed picker lists
+ * cannot show Grok twice. This helper is intentionally independent from
+ * ProviderRegistry: Grok Subscription remains an external runtime.
+ */
+export function withGrokSubscriptionProvider(entries, options = {}) {
+    const withoutGrok = entries.filter((entry) => !isGrokSubscriptionProviderId(entry.id));
+    return [
+        ...withoutGrok,
+        {
+            id: GROK_SUBSCRIPTION_PROVIDER_ID,
+            name: options.label ?? GROK_SUBSCRIPTION_PROVIDER_LABEL,
+            enabled: options.enabled ?? true,
+        },
+    ];
+}

package/dist/external-runtime/grok-runtime.d.ts

@@ -0,0 +1,91 @@
+import type { AgentEvent } from "../types.js";
+import type { ThinkingLevel } from "../types.js";
+import type { PermissionMode } from "../types.js";
+import type { ApprovalController } from "../approval/types.js";
+import type { ExternalRuntimeManager, ExternalRuntimeRunOptions, ExternalRuntimeSession, ExternalRuntimeModel, ExternalRuntimeModelSelection, ExternalRuntimeStatus } from "./types.js";
+import type { GrokBinaryDependencies } from "./grok-binary.js";
+import { type GrokSpawn } from "./grok-process.js";
+import { type GrokAcpFactory } from "./grok-acp.js";
+import { type GrokNetworkRoute } from "./grok-network.js";
+export declare const GROK_RUNTIME_CAPABILITIES: Readonly<{
+    chat: true;
+    tools: true;
+    memory: false;
+    subagents: false;
+    plan: false;
+    web: false;
+    sessionLoad: true;
+    workspace: true;
+    modelControl: true;
+    reasoningControl: true;
+}>;
+export interface GrokRuntimeDependencies extends GrokBinaryDependencies {
+    bubbleHome?: string;
+    parentEnv?: NodeJS.ProcessEnv;
+    spawn?: GrokSpawn;
+    acpFactory?: GrokAcpFactory;
+    oauthOpener?: GrokOAuthOpener;
+    networkResolver?: () => Promise<GrokNetworkRoute>;
+    workspace?: string;
+    approvalController?: ApprovalController;
+    getPermissionMode?: () => PermissionMode;
+}
+export type GrokOAuthOpener = (url: string, signal: AbortSignal) => Promise<void>;
+export declare function grokLoginFailureMessage(diagnostic: string): string;
+export declare class GrokRuntimeManager implements ExternalRuntimeManager {
+    private readonly deps;
+    private readonly spawn;
+    private readonly acpFactory;
+    private readonly oauthOpener;
+    private readonly profile;
+    private readonly workspace;
+    private binary?;
+    private acp?;
+    private lock?;
+    private state;
+    private currentSessionId?;
+    private attachedSessionId?;
+    private activeTurn?;
+    private nextGeneration;
+    private closingSidecar?;
+    private loginController?;
+    private loginOperation?;
+    private sessionLifecyclePhase;
+    private networkRoute?;
+    private networkRouteOperation?;
+    private modelId?;
+    private reasoningEffort;
+    private modelCache?;
+    private readonly activeTools;
+    constructor(deps?: GrokRuntimeDependencies);
+    private status;
+    private ensureNetworkRoute;
+    private prepareAndVerify;
+    private acquireProfileLock;
+    inspect(): Promise<ExternalRuntimeStatus>;
+    login(signal?: AbortSignal, onBrowserOpened?: () => void): Promise<void>;
+    private performLogin;
+    logout(): Promise<void>;
+    private ensureConnected;
+    private applyAcpModels;
+    newSession(): Promise<ExternalRuntimeSession>;
+    loadSession(id: string): Promise<ExternalRuntimeSession>;
+    hydrateSession(id: string, modelId?: string, reasoningEffort?: ThinkingLevel): Promise<ExternalRuntimeSession>;
+    listModels(): Promise<ExternalRuntimeModel[]>;
+    getModelSelection(): ExternalRuntimeModelSelection;
+    setModel(modelId: string, reasoningEffort?: ThinkingLevel): Promise<ExternalRuntimeModelSelection>;
+    private ensureSession;
+    run(prompt: string, options?: ExternalRuntimeRunOptions): AsyncIterable<AgentEvent>;
+    cancel(sessionId?: string | undefined): Promise<void>;
+    private handlePolicyViolation;
+    private handleSessionUpdate;
+    private handleCrash;
+    private closeSidecar;
+    private disconnect;
+    /**
+     * Closes the current sidecar and releases the profile lock. The manager is
+     * intentionally reusable: a later new/load/run call starts a fresh sidecar.
+     */
+    dispose(): Promise<void>;
+}
+export declare function createGrokRuntimeManager(deps?: GrokRuntimeDependencies): GrokRuntimeManager;