@builder.io/ai-utils 0.46.0 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/ai-utils",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "Builder.io AI utils",
   "files": [
     "src"

package/src/codegen.d.ts

@@ -43,11 +43,17 @@ export interface CustomAgentInfo {
 }
 /** Per-agent model overrides. String = fixed model, string[] = round-robin. */
 export type AgentModelOverrides = Record<string, string | string[]>;
-export type ReviewEffort = "medium" | "high";
+export type ReviewEffort = "medium" | "high" | "low";
 export interface CustomAgentDefinition {
     name: string;
     description?: string;
-    systemPrompt?: string;
+    /**
+     * When provided as an array, the first element must be the static prompt and
+     * subsequent elements should be dynamic content (e.g. env var placeholders).
+     * Only the first element is marked as cacheable — placing dynamic content
+     * first would invalidate the prompt cache on every request.
+     */
+    systemPrompt?: string | string[];
     tools?: string[];
     model?: string;
     roundRobinModels?: string[];
@@ -416,7 +422,7 @@ export interface UpdateSetupValueToolInput {
     };
     reason: string;
 }
-export type ExitState = "verified" | "no-frontend" | "empty-project" | "mobile-project" | "user-question" | "other" | "started";
+export type ExitState = "verified" | "no-frontend" | "empty-project" | "mobile-project" | "user-question" | "code-change-required" | "other" | "started";
 export interface ExitToolInput {
     state: ExitState;
     summary: string;
@@ -771,7 +777,7 @@ export interface CodeGenInputOptions {
     planningPrompt?: boolean;
     customInstructions?: CustomInstruction[];
     customAgents?: CustomAgentInfo[];
-    systemPromptOverride?: string;
+    systemPromptOverride?: string | string[];
     userPrompt?: string;
     systemReminders?: SystemReminder[];
     ephemeralUserPrompt?: string;

package/src/connectivity/run-checks.js

@@ -1,4 +1,4 @@
-import { resolveTarget, extractHostname, extractPort } from "./targets.js";
+import { resolveTarget, extractHostname, extractPort, extractExplicitPort, } from "./targets.js";
 import { getCheckTypeForTestId, isCheckAvailable, getUnavailabilityReason, } from "./environment.js";
 import { httpCheck } from "./checks/http-check.js";
 import { dnsCheck } from "./checks/dns-check.js";
@@ -106,7 +106,7 @@ async function runSingleCheck(test, gitHost, fetchFn, dispatcher, connectFn) {
         case "ssh":
             return sshCheck({
                 hostname: extractHostname(target),
-                port: 22,
+                port: extractExplicitPort(target, 22),
                 source,
                 testId,
             });

package/src/connectivity/targets.d.ts

@@ -3,4 +3,13 @@ export declare const BUILDER_TARGETS: Record<string, string>;
 export declare const DEFAULT_PORTS: Record<string, number>;
 export declare function resolveTarget(testId: TestId, gitHost?: string): string;
 export declare function extractHostname(target: string): string;
+/**
+ * Extract only an explicitly specified port from a URL, ignoring protocol-specific defaults.
+ * Returns defaultPort when no port is present in the URL string.
+ */
+export declare function extractExplicitPort(target: string, defaultPort: number): number;
+/**
+ * Extract port from a URL, with protocol-aware defaults.
+ * Returns 80 for http:// URLs without an explicit port, otherwise falls back to defaultPort.
+ */
 export declare function extractPort(target: string, defaultPort?: number): number;

package/src/connectivity/targets.js

@@ -36,14 +36,22 @@ export function extractHostname(target) {
         return target;
     }
 }
-export function extractPort(target, defaultPort = 443) {
+/**
+ * Extract only an explicitly specified port from a URL, ignoring protocol-specific defaults.
+ * Returns defaultPort when no port is present in the URL string.
+ */
+export function extractExplicitPort(target, defaultPort) {
     try {
         const url = new URL(target);
         if (url.port) {
             return parseInt(url.port, 10);
         }
-        if (url.protocol === "http:") {
-            return 80;
+        // URL API strips scheme-default ports (:443 for https, :80 for http).
+        // Check the authority portion only to avoid false positives from paths/query strings.
+        const schemeDefault = url.protocol === "https:" ? 443 : url.protocol === "http:" ? 80 : null;
+        const authority = target.slice(target.indexOf("://") + 3).split(/[/?#]/)[0];
+        if (schemeDefault !== null && authority.endsWith(`:${schemeDefault}`)) {
+            return schemeDefault;
         }
         return defaultPort;
     }
@@ -51,3 +59,19 @@ export function extractPort(target, defaultPort = 443) {
         return defaultPort;
     }
 }
+/**
+ * Extract port from a URL, with protocol-aware defaults.
+ * Returns 80 for http:// URLs without an explicit port, otherwise falls back to defaultPort.
+ */
+export function extractPort(target, defaultPort = 443) {
+    try {
+        const url = new URL(target);
+        if (url.protocol === "http:" && !url.port) {
+            return 80;
+        }
+    }
+    catch (_a) {
+        // fall through
+    }
+    return extractExplicitPort(target, defaultPort);
+}

package/src/connectivity/targets.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/connectivity/targets.spec.js

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { extractPort, extractExplicitPort } from "./targets";
+describe("extractPort", () => {
+    it("returns explicit port from URL", () => {
+        expect(extractPort("https://git.amazon.com:2222", 443)).toBe(2222);
+    });
+    it("returns 80 for http:// URLs without explicit port", () => {
+        expect(extractPort("http://git.example.com", 443)).toBe(80);
+    });
+    it("returns default port for https:// URLs without explicit port", () => {
+        expect(extractPort("https://github.com", 443)).toBe(443);
+    });
+    it("returns default port for invalid URLs", () => {
+        expect(extractPort("not-a-url", 443)).toBe(443);
+    });
+});
+describe("extractExplicitPort", () => {
+    it("returns explicit port from URL", () => {
+        expect(extractExplicitPort("https://git.amazon.com:2222", 22)).toBe(2222);
+    });
+    it("returns default for https:// URL without explicit port", () => {
+        expect(extractExplicitPort("https://github.com", 22)).toBe(22);
+    });
+    it("returns default for http:// URL without explicit port (does NOT return 80)", () => {
+        expect(extractExplicitPort("http://git.example.com", 22)).toBe(22);
+    });
+    it("returns 443 when https URL explicitly specifies :443", () => {
+        expect(extractExplicitPort("https://host:443", 22)).toBe(443);
+        expect(extractExplicitPort("https://host:443/path", 22)).toBe(443);
+    });
+    it("returns 80 when http URL explicitly specifies :80", () => {
+        expect(extractExplicitPort("http://host:80", 22)).toBe(80);
+        expect(extractExplicitPort("http://host:80/path", 22)).toBe(80);
+    });
+    it("ignores scheme-default port in path or query string", () => {
+        expect(extractExplicitPort("https://host/path?next=host:443", 22)).toBe(22);
+        expect(extractExplicitPort("https://host/host:443", 22)).toBe(22);
+    });
+    it("detects explicit :443 with userinfo in URL", () => {
+        expect(extractExplicitPort("https://user:password@host:443", 22)).toBe(443);
+    });
+    it("returns default for invalid URLs", () => {
+        expect(extractExplicitPort("not-a-url", 22)).toBe(22);
+    });
+});