@bubblebrain-ai/bubble 0.0.33 → 0.0.35

package/dist/types.d.ts

@@ -17,10 +17,19 @@ export type ReasoningEffort = ThinkingLevel;
 export type ProviderRawContentBlock = Record<string, unknown> & {
     type: string;
 };
+export type ProviderMetadataProvider = "anthropic" | "google";
+export interface ProviderContentBlockStore {
+    contentBlocks?: ProviderRawContentBlock[];
+}
 export interface AssistantProviderMetadata {
-    anthropic?: {
-        contentBlocks?: ProviderRawContentBlock[];
-    };
+    anthropic?: ProviderContentBlockStore;
+    /**
+     * Gemini raw parts captured for replay: reasoning/tool-call parts carrying
+     * thoughtSignature so multi-turn thinking round-trips through our own
+     * message rebuild (the SDK's automatic replay assumes appending its
+     * response.messages verbatim, which we don't do).
+     */
+    google?: ProviderContentBlockStore;
 }
 export interface UserMessage {
     role: "user";
@@ -201,38 +210,15 @@ export interface ToolContext {
         }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
         closeSubAgent?: (agentId: string) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
         listSubAgents?: () => import("./agent/subagent-control.js").SubagentThreadSnapshot[];
-        runAgentTeam?: (cwd: string, options: {
-            profile: import("./agent/profiles.js").AgentProfile;
-            category?: string;
-            model?: string;
-            effort?: ThinkingLevel;
-            promptTemplate: string;
-            items: string[];
-            parentToolCallId: string;
-            emitUpdate?: (update: ToolUpdate) => void;
-            abortSignal?: AbortSignal;
-            approval?: "fail" | "disabled";
-        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
-        runAgentBatch?: (cwd: string, options: {
-            specs: Array<{
-                task: string;
-                profile: import("./agent/profiles.js").AgentProfile;
-                category?: string;
-                model?: string;
-                effort?: ThinkingLevel;
-                outputSchema?: unknown;
-            }>;
-            parentToolCallId: string;
-            emitUpdate?: (update: ToolUpdate) => void;
-            abortSignal?: AbortSignal;
-            approval?: "fail" | "disabled";
-        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
         startWorkflow?: (cwd: string, options: {
             script: string;
             args?: unknown;
             title?: string;
             parentToolCallId: string;
             abortSignal?: AbortSignal;
+            ensureProfileTrusted?: (profile: import("./agent/profiles.js").AgentProfile) => Promise<{
+                content: string | unknown;
+            } | undefined>;
         }) => {
             runId: string;
             title: string;
@@ -302,7 +288,7 @@ export type StreamChunk = {
     content: string;
 } | {
     type: "provider_content_block";
-    provider: "anthropic";
+    provider: ProviderMetadataProvider;
     block: ProviderRawContentBlock;
 } | {
     type: "tool_call";

package/dist/variant/variant-resolver.d.ts

@@ -1,4 +1,17 @@
 import type { ThinkingLevel } from "../types.js";
 export declare function getAvailableThinkingLevels(providerId: string, modelId: string): ThinkingLevel[];
 export declare function getDefaultThinkingLevel(providerId: string, modelId: string): ThinkingLevel;
+/**
+ * A single non-"off" level means the model is always in thinking mode with no
+ * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
+ * placeholder and must not be shown to the user as an effort grade.
+ */
+export declare function isThinkingOnlyLevels(levels: readonly ThinkingLevel[]): boolean;
+export declare function isThinkingOnlyModel(providerId?: string, modelId?: string): boolean;
+/**
+ * Some providers expose thinking as a true enabled/disabled switch. We may store
+ * the enabled state as "medium" internally for compatibility with ThinkingLevel,
+ * but it is not a real user-facing effort grade.
+ */
+export declare function isThinkingToggleModel(providerId?: string, modelId?: string): boolean;
 export declare function normalizeThinkingLevel(level: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;

package/dist/variant/variant-resolver.js

@@ -1,5 +1,7 @@
 import { getBuiltinModel, getModelDefaultReasoningLevel } from "../model-catalog.js";
 import { clampThinkingLevel } from "./thinking-level.js";
+const KIMI_TOGGLE_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
+const KIMI_THINKING_TOGGLE_MODELS = new Set(["kimi-k2.5", "kimi-k2.6"]);
 export function getAvailableThinkingLevels(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.reasoningLevels ?? ["off"];
 }
@@ -10,6 +12,30 @@ export function getDefaultThinkingLevel(providerId, modelId) {
         return explicitDefault;
     return levels.includes("medium") ? "medium" : levels[0] || "off";
 }
+/**
+ * A single non-"off" level means the model is always in thinking mode with no
+ * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
+ * placeholder and must not be shown to the user as an effort grade.
+ */
+export function isThinkingOnlyLevels(levels) {
+    return levels.length === 1 && levels[0] !== "off";
+}
+export function isThinkingOnlyModel(providerId = "", modelId = "") {
+    return isThinkingOnlyLevels(getAvailableThinkingLevels(providerId, modelId));
+}
+/**
+ * Some providers expose thinking as a true enabled/disabled switch. We may store
+ * the enabled state as "medium" internally for compatibility with ThinkingLevel,
+ * but it is not a real user-facing effort grade.
+ */
+export function isThinkingToggleModel(providerId = "", modelId = "") {
+    const normalizedProvider = providerId.toLowerCase();
+    const normalizedModel = modelId.toLowerCase();
+    if (normalizedProvider.includes("minimax") || normalizedModel.includes("minimax"))
+        return true;
+    return KIMI_TOGGLE_PROVIDER_IDS.has(normalizedProvider)
+        && KIMI_THINKING_TOGGLE_MODELS.has(normalizedModel);
+}
 export function normalizeThinkingLevel(level, supportedLevels) {
     return clampThinkingLevel(level, supportedLevels);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -24,6 +24,8 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@ai-sdk/google": "^3.0.88",
+    "@ai-sdk/provider": "^3.0.13",
     "@larksuiteoapi/node-sdk": "^1.65.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/react": "^19.2.14",
@@ -43,7 +45,8 @@
     "typescript-language-server": "^5.1.3",
     "undici": "^6.26.0",
     "vscode-jsonrpc": "^8.2.1",
-    "vscode-langservers-extracted": "^4.10.0"
+    "vscode-langservers-extracted": "^4.10.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -56,6 +59,9 @@
   "overrides": {
     "axios": "^1.17.0",
     "postcss": "^8.5.15",
-    "ws": "^8.21.0"
+    "ws": "^8.21.0",
+    "openai": {
+      "zod": "$zod"
+    }
   }
 }