@builder.io/ai-utils 0.29.1 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/ai-utils",
-  "version": "0.29.1",
+  "version": "0.31.0",
   "description": "Builder.io AI utils",
   "type": "module",
   "main": "src/index.js",

package/src/codegen.d.ts

@@ -32,6 +32,8 @@ export interface CustomInstruction {
     allowedTools?: string[];
     hideUI?: boolean;
     isSkill?: boolean;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
 }
 export interface CustomAgentInfo {
     name: string;
@@ -203,7 +205,6 @@ export interface BuilderEditToolInput {
 }
 export interface GetScreenshotToolInput {
     href?: string;
-    url?: string;
     selector?: string;
     width?: number;
     height?: number;
@@ -325,6 +326,7 @@ export interface ExitToolInput {
     isMicrofrontend?: boolean;
     setupNeedsCredentials?: boolean;
     devServerNeedsCredentials?: boolean;
+    needsVPN?: boolean;
     /** A human-readable description of what the project is about (not tech specs), used by fusion to route requests to the right project */
     projectDescription?: string;
 }
@@ -417,6 +419,7 @@ export interface ProposedConfig {
     projectDescription?: string;
     cost?: number;
     durationMs?: number;
+    needsVPN?: boolean;
 }
 /**
  * Parameters for proposing a configuration to the backend
@@ -448,6 +451,7 @@ export interface ProposeConfigParams {
     setupNeedsCredentials?: boolean;
     devServerNeedsCredentials?: boolean;
     projectDescription?: string;
+    needsVPN?: boolean;
 }
 export interface VerifySetupCommandToolInput {
     command: string;
@@ -486,12 +490,15 @@ export interface SendMessageToolInput {
     channelId: string;
     markdown: string;
     status: "starting" | "question" | "will-follow-up" | "done:success" | "done:error";
+    loadingMessage?: string;
 }
 export interface SpawnBranchToolInput {
     projectId: string;
     message: string;
     builderUserId?: string;
     hidden?: boolean;
+    sourceChannelId?: string;
+    sourceDmId?: string;
 }
 export interface ReadBranchToolInput {
     projectId: string;
@@ -1817,6 +1824,7 @@ export interface LaunchServerStatus {
     activeOperations: number;
     diskUsage?: number;
     memoryUsage?: number;
+    sessionId?: string;
 }
 /**
  * VS Code Tunnel status information
@@ -1864,6 +1872,8 @@ export interface FusionStatus {
     diskUsage?: number;
     /** Current memory usage as a ratio (0-1, where 1 is fully used) */
     memoryUsage?: number;
+    /** Session ID of the active codegen session */
+    sessionId?: string;
 }
 export interface FusionMetrics {
     counters?: {
@@ -2123,7 +2133,7 @@ export interface RepoMetrics {
     languages: LanguageInfo[];
     isEmpty: boolean;
     isMonorepo: boolean;
-    monorepoType?: "npm-workspaces" | "yarn-workspaces" | "pnpm-workspaces" | "lerna" | "nx" | "turborepo" | "cargo-workspaces" | "other";
+    monorepoType?: "npm-workspaces" | "yarn-workspaces" | "pnpm-workspaces" | "bun-workspaces" | "lerna" | "nx" | "turborepo" | "rush" | "moon" | "cargo-workspaces" | "go-workspaces" | "other";
     frameworks: FrameworkInfo[];
     setupRequirements: SetupRequirement[];
     packageManagers: string[];

package/src/connectivity/checks/http-check.d.ts

@@ -5,5 +5,7 @@ export interface HttpCheckOptions {
     testId: TestId;
     timeout?: number;
     fetchFn?: ConnectivityFetchFn;
+    /** Fetch dispatcher for proxy routing (e.g. undici ProxyAgent). */
+    dispatcher?: object;
 }
 export declare function httpCheck(options: HttpCheckOptions): Promise<CheckResult>;

package/src/connectivity/checks/http-check.js

@@ -1,17 +1,28 @@
 import { mapHttpStatusToErrorCode, mapFetchErrorToConnectivityCode, } from "../error-codes.js";
+import { isBrowser } from "../environment.js";
 const DEFAULT_TIMEOUT_MS = 30000;
 const LATENCY_THRESHOLD_MS = 5000;
 export async function httpCheck(options) {
-    const { target, source, testId, timeout = DEFAULT_TIMEOUT_MS, fetchFn = fetch, } = options;
+    const { target, source, testId, timeout = DEFAULT_TIMEOUT_MS, fetchFn = fetch, dispatcher, } = options;
     const startTime = Date.now();
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
-        const response = await fetchFn(target, {
-            method: "HEAD",
-            signal: controller.signal,
-            redirect: "follow",
-        });
+        const method = "HEAD";
+        const redirect = isBrowser() ? "follow" : "manual";
+        const signal = controller.signal;
+        /**
+         * The custom fetch fn used in dev tools has proxy handling built-in, so no need
+         * for a custom dispatcher.
+         */
+        const response = dispatcher
+            ? await fetch(target, {
+                method,
+                signal,
+                redirect,
+                dispatcher,
+            })
+            : await fetchFn(target, { method, signal, redirect });
         clearTimeout(timeoutId);
         const durationMs = Date.now() - startTime;
         const errorCode = mapHttpStatusToErrorCode(response.status);

package/src/connectivity/run-checks.js

@@ -6,7 +6,7 @@ import { tcpCheck } from "./checks/tcp-check.js";
 import { tlsCheck } from "./checks/tls-check.js";
 import { sshCheck } from "./checks/ssh-check.js";
 export async function runChecks(input) {
-    const { tests, gitHost, onProgress, fetchFn } = input;
+    const { tests, gitHost, onProgress, fetchFn, dispatcher } = input;
     const results = [];
     const total = tests.length;
     for (let index = 0; index < tests.length; index++) {
@@ -17,7 +17,7 @@ export async function runChecks(input) {
             index,
             total,
         });
-        const result = await runSingleCheck(test, gitHost, fetchFn);
+        const result = await runSingleCheck(test, gitHost, fetchFn, dispatcher);
         results.push(result);
         emitProgress(onProgress, {
             type: "test:complete",
@@ -36,7 +36,7 @@ export async function runChecks(input) {
         results,
     };
 }
-async function runSingleCheck(test, gitHost, fetchFn) {
+async function runSingleCheck(test, gitHost, fetchFn, dispatcher) {
     const { source, testId } = test;
     const checkType = getCheckTypeForTestId(testId);
     if (!isCheckAvailable(checkType)) {
@@ -80,7 +80,7 @@ async function runSingleCheck(test, gitHost, fetchFn) {
     }
     switch (checkType) {
         case "http":
-            return httpCheck({ target, source, testId, fetchFn });
+            return httpCheck({ target, source, testId, fetchFn, dispatcher });
         case "dns":
             return dnsCheck({
                 hostname: extractHostname(target),

package/src/connectivity/types.d.ts

@@ -19,6 +19,12 @@ export interface RunChecksInput {
      * environments.
      */
     fetchFn?: ConnectivityFetchFn;
+    /**
+     * Fetch dispatcher for proxy routing (e.g. undici ProxyAgent).
+     * Passed through to the `dispatcher` option of fetch for HTTP checks.
+     * Typically only needed server-side for static IP routing.
+     */
+    dispatcher?: object;
 }
 export type ProgressEvent = {
     type: "test:start";

package/src/projects.d.ts

@@ -343,6 +343,7 @@ export interface PartialBranchData {
     name?: string;
     createdBy: string;
     friendlyName?: string;
+    description?: string;
     isDefault: boolean;
     isPublic: boolean;
     lockedFusionEnvironment?: FusionExecutionEnvironment;
@@ -357,6 +358,7 @@ export interface PartialBranchData {
     useHomeDir?: boolean;
     agentType?: AgentType;
     checkoutBranch?: string | null;
+    prNumber?: number;
     /** Whether this branch is for a fork PR - affects git operations (read-only, can't push) */
     isFork?: boolean | null;
     /** Whether this branch is for a code review - affects enabled agents and tools*/
@@ -442,6 +444,7 @@ export interface BranchSharedData {
     isPublic?: boolean;
     isDefault?: boolean;
     friendlyName?: string;
+    description?: string;
     useHomeDir?: boolean;
     useCloudHomeDir?: boolean;
     reviewers?: string[] | null;
@@ -927,4 +930,56 @@ export interface MemorySummary extends Pick<MemoryData, (typeof MEMORY_SUMMARY_F
 export interface GetProjectMemoriesResult {
     memories: MemorySummary[];
 }
+interface BaseSendMessageMessage {
+}
+export interface ValidatingBranchMessage extends BaseSendMessageMessage {
+    type: "validating-branch";
+    message: string;
+    projectId: string;
+    branchName: string;
+}
+export interface SettingUpContainerMessage extends BaseSendMessageMessage {
+    type: "setting-up-container";
+    message: string;
+    projectId: string;
+    branchName: string;
+}
+export interface SendingMessageMessage extends BaseSendMessageMessage {
+    type: "sending-message";
+    message: string;
+    projectId: string;
+    branchName: string;
+}
+export interface MessageSentMessage extends BaseSendMessageMessage {
+    type: "message-sent";
+    message: string;
+    projectId: string;
+    branchName: string;
+    url: string;
+}
+export interface SendMessageErrorMessage extends BaseSendMessageMessage {
+    type: "error";
+    message: string;
+    error: string;
+    projectId: string;
+    branchName: string;
+}
+export interface EnsureContainerMessage extends BaseSendMessageMessage {
+    type: "ensure-container";
+    event: ProjectsChunkMessage;
+}
+export interface AiMessage extends BaseSendMessageMessage {
+    type: "ai";
+    event: GenerateCompletionStep;
+}
+export type SendMessageChunkMessage = ValidatingBranchMessage | SettingUpContainerMessage | SendingMessageMessage | MessageSentMessage | SendMessageErrorMessage | EnsureContainerMessage | AiMessage;
+export interface ExitPlanModeData {
+    plan: string;
+    sessionMode?: string;
+}
+/**
+ * Parses an ExitPlanMode tool result from a streaming chunk
+ * Extracts the plan content and sessionMode from the tool's structured result
+ */
+export declare function parseExitPlanMode(chunk: CreateBranchChunkMessage | SendMessageChunkMessage): ExitPlanModeData | null;
 export {};

package/src/projects.js

@@ -92,3 +92,71 @@ export const MEMORY_SUMMARY_FIELDS = [
     "glob",
     "updatedAt",
 ];
+/**
+ * Parses an ExitPlanMode tool result from a streaming chunk
+ * Extracts the plan content and sessionMode from the tool's structured result
+ */
+export function parseExitPlanMode(chunk) {
+    // Check if this is an AI chunk
+    if (chunk.type !== "ai") {
+        return null;
+    }
+    const event = chunk.event;
+    // Look for tool_result events for ExitPlanMode
+    if (event.type === "tool_result") {
+        const result = event.result;
+        // Check if this is the ExitPlanMode tool
+        if (result.tool_name === "ExitPlanMode") {
+            let plan;
+            let sessionMode;
+            // The content should be a JSON string with the structured result
+            if (typeof result.tool_input === "string") {
+                try {
+                    const parsed = JSON.parse(result.tool_input);
+                    if (parsed && typeof parsed.plan === "string" && !plan) {
+                        plan = parsed.plan;
+                    }
+                    if (parsed &&
+                        typeof parsed.sessionMode === "string" &&
+                        !sessionMode) {
+                        sessionMode = parsed.sessionMode;
+                    }
+                }
+                catch (_a) {
+                    // If parsing fails, ignore and return null
+                }
+            }
+            if (typeof result.content === "string") {
+                try {
+                    const parsed = JSON.parse(result.content);
+                    if (parsed && typeof parsed.plan === "string" && !plan) {
+                        plan = parsed.plan;
+                    }
+                    if (parsed &&
+                        typeof parsed.sessionMode === "string" &&
+                        !sessionMode) {
+                        sessionMode = parsed.sessionMode;
+                    }
+                }
+                catch (_b) {
+                    // If parsing fails, ignore and return null
+                }
+            }
+            // Also check structured_result directly (fallback)
+            if (result.structured_result &&
+                typeof result.structured_result.plan === "string" &&
+                !plan) {
+                plan = result.structured_result.plan;
+            }
+            if (result.structured_result &&
+                typeof result.structured_result.sessionMode === "string" &&
+                !sessionMode) {
+                sessionMode = result.structured_result.sessionMode;
+            }
+            if (plan) {
+                return { plan, sessionMode };
+            }
+        }
+    }
+    return null;
+}