@builder.io/ai-utils 0.81.3 → 0.83.0-dev.202607211718.99c5f9cf8

package/src/connectivity/types.d.ts

@@ -1,5 +1,5 @@
 export type Source = "local" | "cloud" | "static-ip" | "vpc";
-export type TestId = "builder.io" | "builder.codes" | "api.builder.io" | "cdn.builder.io" | "builderio.xyz" | "builderio.xyz:ws" | "builderio.dev" | "builderio.dev:ws" | "fly.dev" | "git-host:http" | "git-host:dns" | "git-host:tcp" | "git-host:tls" | "git-host:ssh";
+export type TestId = "builder.io" | "builder.codes" | "api.builder.io" | "cdn.builder.io" | "builderio.xyz" | "builderio.xyz:ws" | "builderio.dev" | "builderio.dev:ws" | "fly.dev" | "git-host:http" | "git-host:dns" | "git-host:tcp" | "git-host:tls" | "git-host:ssh" | "project:dns" | "project:tcp" | "project:tls" | "project:http" | "project-health:dns" | "project-health:tcp" | "project-health:tls" | "project-health:http";
 export interface Test {
     source: Source;
     testId: TestId;
@@ -25,6 +25,12 @@ export interface RunChecksInput {
      * Typically only needed server-side for static IP routing.
      */
     dispatcher?: object;
+    /**
+     * Treat 4xx HTTP responses as failures (not just 5xx). Used by
+     * `doctor --browser` so a proxy block page (e.g. a 403 from Zscaler) counts
+     * as a failure instead of a reachable-server pass.
+     */
+    strictHttpStatus?: boolean;
     /**
      * Returns a connected socket tunneled through a proxy (via HTTP CONNECT
      * or SOCKS5). Used by TCP and TLS checks for static IP / VPC routing. The
@@ -45,6 +51,16 @@ export interface RunChecksInput {
     dnsResolver?: {
         servers: string[];
     };
+    /**
+     * Full URL of a specific project (e.g. a project's status-v2 endpoint) that the
+     * `project:*` tests probe. Resolved by resolveTarget for those testIds.
+     */
+    projectUrl?: string;
+    /**
+     * URL of the health.builderio.* domain the project is routed through, probed by
+     * the `project-health:*` tests. Derived from projectUrl's kube domain.
+     */
+    projectHealthUrl?: string;
 }
 export type ProgressEvent = {
     type: "test:start";

package/src/editor-ai.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const EDITOR_AI_READ_DEFAULT_LIMIT = 250;
+export declare const EDITOR_AI_READ_MAX_LIMIT = 1500;
+export declare const EditorAiReadRequestSchema: z.ZodObject<{
+    contentId: z.ZodString;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    activeLocale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EditorAiReadRequest = z.infer<typeof EditorAiReadRequestSchema>;
+export declare const EditorAiReadResponseSchema: z.ZodObject<{
+    contentId: z.ZodString;
+    totalLines: z.ZodNumber;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+    activeLocale: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type EditorAiReadResponse = z.infer<typeof EditorAiReadResponseSchema>;
+export declare const EditorAiEditRequestSchema: z.ZodObject<{
+    contentId: z.ZodString;
+    old_str: z.ZodString;
+    new_str: z.ZodString;
+    activeLocale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EditorAiEditRequest = z.infer<typeof EditorAiEditRequestSchema>;
+export declare const EditorAiEditResponseSchema: z.ZodObject<{
+    contentId: z.ZodString;
+    patch: z.ZodString;
+    modifiedBuilderContent: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type EditorAiEditResponse = z.infer<typeof EditorAiEditResponseSchema>;
+export declare const EditorAiWriteRequestSchema: z.ZodObject<{
+    contentId: z.ZodString;
+    content: z.ZodString;
+    activeLocale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EditorAiWriteRequest = z.infer<typeof EditorAiWriteRequestSchema>;
+export declare const EditorAiWriteResponseSchema: z.ZodObject<{
+    contentId: z.ZodString;
+    modifiedBuilderContent: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type EditorAiWriteResponse = z.infer<typeof EditorAiWriteResponseSchema>;
+export type EditorAiErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "NO_MATCH" | "VALIDATION_FAILED" | "INTERNAL";
+export declare const EditorAiErrorBodySchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EditorAiErrorBody = z.infer<typeof EditorAiErrorBodySchema>;

package/src/editor-ai.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+// Request/response contracts for the stateless /editor/read|edit|write
+// endpoints. Shared so the Builder CMS MCP server reuses the same shapes.
+export const EDITOR_AI_READ_DEFAULT_LIMIT = 250;
+export const EDITOR_AI_READ_MAX_LIMIT = 1500;
+export const EditorAiReadRequestSchema = z
+    .object({
+    contentId: z.string().min(1),
+    offset: z.number().int().min(0).optional(),
+    limit: z.number().int().min(1).max(EDITOR_AI_READ_MAX_LIMIT).optional(),
+    // Locale to operate on; defaults to "Default" when omitted.
+    activeLocale: z.string().min(1).optional(),
+})
+    .meta({ title: "EditorAiReadRequest" });
+export const EditorAiReadResponseSchema = z
+    .object({
+    contentId: z.string(),
+    totalLines: z.number().int(),
+    offset: z.number().int(),
+    limit: z.number().int(),
+    activeLocale: z.string(),
+    content: z.string(),
+})
+    .meta({ title: "EditorAiReadResponse" });
+export const EditorAiEditRequestSchema = z
+    .object({
+    contentId: z.string().min(1),
+    old_str: z
+        .string()
+        .min(1)
+        .refine((s) => s.trim().length > 0, {
+        message: "old_str must not be only whitespace",
+    }),
+    new_str: z.string(),
+    // Locale to operate on; defaults to "Default" when omitted.
+    activeLocale: z.string().min(1).optional(),
+})
+    .meta({ title: "EditorAiEditRequest" });
+export const EditorAiEditResponseSchema = z
+    .object({
+    contentId: z.string(),
+    patch: z.string(),
+    modifiedBuilderContent: z.record(z.string(), z.unknown()),
+})
+    .meta({ title: "EditorAiEditResponse" });
+export const EditorAiWriteRequestSchema = z
+    .object({
+    contentId: z.string().min(1),
+    content: z.string().min(1),
+    // Locale to operate on; defaults to "Default" when omitted.
+    activeLocale: z.string().min(1).optional(),
+})
+    .meta({ title: "EditorAiWriteRequest" });
+export const EditorAiWriteResponseSchema = z
+    .object({
+    contentId: z.string(),
+    modifiedBuilderContent: z.record(z.string(), z.unknown()),
+})
+    .meta({ title: "EditorAiWriteResponse" });
+export const EditorAiErrorBodySchema = z
+    .object({
+    error: z.object({
+        code: z.string(),
+        message: z.string(),
+        hint: z.string().optional(),
+        details: z.record(z.string(), z.unknown()).optional(),
+    }),
+})
+    .meta({ title: "EditorAiErrorBody" });

package/src/editor-ai.test.d.ts

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

package/src/editor-ai.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { EditorAiEditRequestSchema } from "./editor-ai.js";
+describe("EditorAiEditRequestSchema", () => {
+    it("accepts an old_str with real content (whitespace preserved)", () => {
+        const parsed = EditorAiEditRequestSchema.parse({
+            contentId: "c1",
+            old_str: '      <Text text="hi" />',
+            new_str: '      <Text text="bye" />',
+        });
+        // Value is not trimmed — exact indentation is preserved for matching.
+        expect(parsed.old_str).toBe('      <Text text="hi" />');
+    });
+    it("rejects an empty old_str", () => {
+        const result = EditorAiEditRequestSchema.safeParse({
+            contentId: "c1",
+            old_str: "",
+            new_str: "x",
+        });
+        expect(result.success).toBe(false);
+    });
+    it("rejects a whitespace-only old_str", () => {
+        const result = EditorAiEditRequestSchema.safeParse({
+            contentId: "c1",
+            old_str: "   \n\t",
+            new_str: "x",
+        });
+        expect(result.success).toBe(false);
+    });
+    it("allows an empty new_str (delete)", () => {
+        const result = EditorAiEditRequestSchema.safeParse({
+            contentId: "c1",
+            old_str: '<Text text="hi" />',
+            new_str: "",
+        });
+        expect(result.success).toBe(true);
+    });
+});

package/src/embeddings.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const BUILDER_EMBEDDING_MODEL = "builder-multimodal-embedding";
+export declare const BUILDER_EMBEDDING_DIMENSIONS = 1024;
+export declare const BUILDER_EMBEDDING_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+export declare const BuilderEmbeddingImageSchema: z.ZodObject<{
+    mimeType: z.ZodEnum<{
+        "image/gif": "image/gif";
+        "image/jpeg": "image/jpeg";
+        "image/png": "image/png";
+        "image/webp": "image/webp";
+    }>;
+    data: z.ZodString;
+}, z.core.$strip>;
+export declare const BuilderEmbeddingInputSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    images: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        mimeType: z.ZodEnum<{
+            "image/gif": "image/gif";
+            "image/jpeg": "image/jpeg";
+            "image/png": "image/png";
+            "image/webp": "image/webp";
+        }>;
+        data: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const BuilderEmbeddingsRequestSchema: z.ZodObject<{
+    model: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        "builder-multimodal-embedding": "builder-multimodal-embedding";
+    }>>;
+    inputType: z.ZodDefault<z.ZodEnum<{
+        document: "document";
+        query: "query";
+    }>>;
+    inputs: z.ZodArray<z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        images: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            mimeType: z.ZodEnum<{
+                "image/gif": "image/gif";
+                "image/jpeg": "image/jpeg";
+                "image/png": "image/png";
+                "image/webp": "image/webp";
+            }>;
+            data: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodObject<{
+        appId: z.ZodOptional<z.ZodString>;
+        feature: z.ZodOptional<z.ZodString>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type BuilderEmbeddingsRequestInput = z.input<typeof BuilderEmbeddingsRequestSchema>;
+export type BuilderEmbeddingsRequest = z.output<typeof BuilderEmbeddingsRequestSchema>;
+export declare const BuilderEmbeddingsResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"list">;
+    model: z.ZodObject<{
+        publicId: z.ZodLiteral<"builder-multimodal-embedding">;
+        provider: z.ZodLiteral<"voyage">;
+        providerModel: z.ZodLiteral<"voyage-multimodal-3.5">;
+        version: z.ZodLiteral<"3.5">;
+        dimensions: z.ZodLiteral<1024>;
+    }, z.core.$strip>;
+    inputType: z.ZodEnum<{
+        document: "document";
+        query: "query";
+    }>;
+    data: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"embedding">;
+        index: z.ZodNumber;
+        embedding: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    usage: z.ZodObject<{
+        textTokens: z.ZodNumber;
+        imagePixels: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BuilderEmbeddingsResponse = z.infer<typeof BuilderEmbeddingsResponseSchema>;

package/src/embeddings.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+export const BUILDER_EMBEDDING_MODEL = "builder-multimodal-embedding";
+export const BUILDER_EMBEDDING_DIMENSIONS = 1024;
+export const BUILDER_EMBEDDING_IMAGE_MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/gif",
+];
+const MAX_IMAGE_BASE64_LENGTH = 14000000;
+const MAX_REQUEST_BASE64_LENGTH = 24000000;
+const MAX_REQUEST_TEXT_LENGTH = 256000;
+export const BuilderEmbeddingImageSchema = z.object({
+    mimeType: z.enum(BUILDER_EMBEDDING_IMAGE_MIME_TYPES),
+    data: z
+        .string()
+        .min(1)
+        .max(MAX_IMAGE_BASE64_LENGTH)
+        .regex(/^[A-Za-z0-9+/]*={0,2}$/, "Image data must be raw base64."),
+});
+export const BuilderEmbeddingInputSchema = z
+    .object({
+    text: z.string().trim().min(1).max(32000).optional(),
+    images: z.array(BuilderEmbeddingImageSchema).max(6).default([]),
+})
+    .superRefine((input, ctx) => {
+    if (!input.text && input.images.length === 0) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Each input must contain text, an image, or both.",
+        });
+    }
+});
+export const BuilderEmbeddingsRequestSchema = z
+    .object({
+    model: z.enum(["auto", BUILDER_EMBEDDING_MODEL]).default("auto"),
+    inputType: z.enum(["query", "document"]).default("document"),
+    inputs: z.array(BuilderEmbeddingInputSchema).min(1).max(32),
+    source: z
+        .object({
+        appId: z.string().max(100).optional(),
+        feature: z.string().max(100).optional(),
+        resourceId: z.string().max(200).optional(),
+        userId: z.string().max(200).optional(),
+    })
+        .optional(),
+    metadata: z.record(z.string().max(100), z.string().max(1000)).optional(),
+})
+    .superRefine((request, ctx) => {
+    var _a;
+    var _b;
+    let base64Length = 0;
+    let textLength = 0;
+    for (const input of request.inputs) {
+        textLength += (_b = (_a = input.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        for (const image of input.images)
+            base64Length += image.data.length;
+    }
+    if (base64Length > MAX_REQUEST_BASE64_LENGTH) {
+        ctx.addIssue({
+            code: "too_big",
+            maximum: MAX_REQUEST_BASE64_LENGTH,
+            origin: "string",
+            inclusive: true,
+            message: "Combined image data is too large.",
+            path: ["inputs"],
+        });
+    }
+    if (textLength > MAX_REQUEST_TEXT_LENGTH) {
+        ctx.addIssue({
+            code: "too_big",
+            maximum: MAX_REQUEST_TEXT_LENGTH,
+            origin: "string",
+            inclusive: true,
+            message: "Combined text input is too large.",
+            path: ["inputs"],
+        });
+    }
+})
+    .meta({
+    description: "Request body for POST /agent-native/embeddings/v1/embeddings.",
+});
+export const BuilderEmbeddingsResponseSchema = z.object({
+    id: z.string(),
+    object: z.literal("list"),
+    model: z.object({
+        publicId: z.literal(BUILDER_EMBEDDING_MODEL),
+        provider: z.literal("voyage"),
+        providerModel: z.literal("voyage-multimodal-3.5"),
+        version: z.literal("3.5"),
+        dimensions: z.literal(BUILDER_EMBEDDING_DIMENSIONS),
+    }),
+    inputType: z.enum(["query", "document"]),
+    data: z.array(z.object({
+        object: z.literal("embedding"),
+        index: z.number().int().nonnegative(),
+        embedding: z
+            .array(z.number().finite())
+            .length(BUILDER_EMBEDDING_DIMENSIONS),
+    })),
+    usage: z.object({
+        textTokens: z.number().int().nonnegative(),
+        imagePixels: z.number().int().nonnegative(),
+        totalTokens: z.number().int().nonnegative(),
+    }),
+});

package/src/embeddings.spec.d.ts

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

package/src/embeddings.spec.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { BUILDER_EMBEDDING_MODEL, BuilderEmbeddingsRequestSchema, } from "./embeddings";
+describe("BuilderEmbeddingsRequestSchema", () => {
+    it("accepts retrieval text and multimodal inputs", () => {
+        var _a;
+        const parsed = BuilderEmbeddingsRequestSchema.parse({
+            model: BUILDER_EMBEDDING_MODEL,
+            inputType: "document",
+            inputs: [
+                { text: "A product launch slide" },
+                {
+                    text: "A warm editorial campaign",
+                    images: [{ mimeType: "image/png", data: "aGVsbG8=" }],
+                },
+            ],
+        });
+        expect(parsed.inputs).toHaveLength(2);
+        expect((_a = parsed.inputs[1]) === null || _a === void 0 ? void 0 : _a.images).toHaveLength(1);
+    });
+    it("rejects empty inputs and data URLs", () => {
+        expect(() => BuilderEmbeddingsRequestSchema.parse({ inputs: [{}] })).toThrow(/text, an image, or both/);
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: [
+                {
+                    images: [
+                        {
+                            mimeType: "image/png",
+                            data: "data:image/png;base64,aGVsbG8=",
+                        },
+                    ],
+                },
+            ],
+        })).toThrow(/raw base64/);
+    });
+    it("rejects unsupported image formats and oversized batches", () => {
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: [{ images: [{ mimeType: "image/svg+xml", data: "PHN2Zz4=" }] }],
+        })).toThrow();
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: Array.from({ length: 33 }, () => ({ text: "text" })),
+        })).toThrow();
+    });
+});

package/src/events.d.ts

@@ -1296,7 +1296,33 @@ export declare const McpPrototypePulledV1: {
     eventName: "mcp.prototype.pulled";
     version: "1";
 };
-export type FusionEvent = ClientDevtoolsSessionStartedEvent | ClientDevtoolsSessionIdleEventV1 | ClientDevtoolsToolCallRequestV1 | ClientDevtoolsToolCallV1 | ClientDevtoolsToolResultV1 | ClientDevtoolsBuildMigratedV1 | ClientDevtoolsBuildCompletedV1 | ClientDevtoolsBuildUploadedV1 | ClientDevtoolsBuildFailedV1 | FusionProjectCreatedV1 | SetupAgentCompletedV1 | GitPrMergedV1 | GitPrCreatedV1 | GitPrClosedV1 | ForceSetupAgentV1 | ClawMessageSentV1 | CodegenCompletionV1 | CodegenUserPromptV1 | GitWebhooksRegisterV1 | FusionProjectSettingsUpdatedV1 | VideoRecordingCompletedV1 | TimelineRecordingReadyV1 | FusionBranchCreatedV1 | FusionContainerStartedV1 | FusionContainerFailedV1 | FusionBranchFailedV1 | BotMentionGitHubExternalPrV1 | BotMentionGitHubInternalPrV1 | BotMentionGitLabPrV1 | BotMentionBitbucketPrV1 | BotMentionAzurePrV1 | ReviewSubmittedV1 | PrReviewRequestedV1 | FigmaDecodeJobV1 | ProjectSnapshotRefreshV1 | ProjectSnapshotCapturedV1 | ProjectSnapshotCreatedV1 | ProjectSnapshotFailedV1 | ProjectSnapshotReadyCheckV1 | ProjectSnapshotPodWatchV1 | McpPrototypePulledV1;
+export type HostingCustomDomainCertCheckV1 = FusionEventVariant<"hosting.custom-domain.cert-check", {
+    domain: string;
+    projectId: string;
+    certId: string;
+    startedAtMs: number;
+    timeoutMs: number;
+}, {
+    projectId: string;
+}, 1>;
+export declare const HostingCustomDomainCertCheckV1: {
+    eventName: "hosting.custom-domain.cert-check";
+    version: "1";
+};
+export type HostingCustomDomainDelegationCheckV1 = FusionEventVariant<"hosting.custom-domain.delegation-check", {
+    domain: string;
+    projectId: string;
+    attemptId: string;
+    startedAtMs: number;
+    timeoutMs: number;
+}, {
+    projectId: string;
+}, 1>;
+export declare const HostingCustomDomainDelegationCheckV1: {
+    eventName: "hosting.custom-domain.delegation-check";
+    version: "1";
+};
+export type FusionEvent = ClientDevtoolsSessionStartedEvent | ClientDevtoolsSessionIdleEventV1 | ClientDevtoolsToolCallRequestV1 | ClientDevtoolsToolCallV1 | ClientDevtoolsToolResultV1 | ClientDevtoolsBuildMigratedV1 | ClientDevtoolsBuildCompletedV1 | ClientDevtoolsBuildUploadedV1 | ClientDevtoolsBuildFailedV1 | FusionProjectCreatedV1 | SetupAgentCompletedV1 | GitPrMergedV1 | GitPrCreatedV1 | GitPrClosedV1 | ForceSetupAgentV1 | ClawMessageSentV1 | CodegenCompletionV1 | CodegenUserPromptV1 | GitWebhooksRegisterV1 | FusionProjectSettingsUpdatedV1 | VideoRecordingCompletedV1 | TimelineRecordingReadyV1 | FusionBranchCreatedV1 | FusionContainerStartedV1 | FusionContainerFailedV1 | FusionBranchFailedV1 | BotMentionGitHubExternalPrV1 | BotMentionGitHubInternalPrV1 | BotMentionGitLabPrV1 | BotMentionBitbucketPrV1 | BotMentionAzurePrV1 | ReviewSubmittedV1 | PrReviewRequestedV1 | FigmaDecodeJobV1 | ProjectSnapshotRefreshV1 | ProjectSnapshotCapturedV1 | ProjectSnapshotCreatedV1 | ProjectSnapshotFailedV1 | ProjectSnapshotReadyCheckV1 | ProjectSnapshotPodWatchV1 | McpPrototypePulledV1 | HostingCustomDomainCertCheckV1 | HostingCustomDomainDelegationCheckV1;
 export interface ModelPermissionRequiredEvent {
     type: "assistant.model.permission.required";
     data: {

package/src/events.js

@@ -162,3 +162,11 @@ export const McpPrototypePulledV1 = {
     eventName: "mcp.prototype.pulled",
     version: "1",
 };
+export const HostingCustomDomainCertCheckV1 = {
+    eventName: "hosting.custom-domain.cert-check",
+    version: "1",
+};
+export const HostingCustomDomainDelegationCheckV1 = {
+    eventName: "hosting.custom-domain.delegation-check",
+    version: "1",
+};

package/src/index.d.ts

@@ -19,4 +19,7 @@ export * from "./connectivity/types.js";
 export * from "./connectivity/classify.js";
 export * from "./single-tenancy.js";
 export * from "./design-systems.js";
+export * from "./editor-ai.js";
+export * from "./realtime.js";
+export * from "./embeddings.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/index.js

@@ -19,4 +19,7 @@ export * from "./connectivity/types.js";
 export * from "./connectivity/classify.js";
 export * from "./single-tenancy.js";
 export * from "./design-systems.js";
+export * from "./editor-ai.js";
+export * from "./realtime.js";
+export * from "./embeddings.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/messages.d.ts

@@ -93,6 +93,14 @@ export interface MCPServerURLDefinition {
     serverId: string;
     disabled: boolean;
     clientName?: string;
+    /**
+     * Per-server opt-in to the LLM-driven `mcp__<name>__authenticate` flow,
+     * independent of the `codegen-tool-mcp-authenticate` LD flag. Set on the
+     * Firestore `mcpServers` doc to roll the tool out to one server at a time;
+     * the LD flag remains the org-wide switch. Either being true opts the
+     * server in, so the flag can still turn it on everywhere at once.
+     */
+    useAuthenticateTool?: boolean;
 }
 export interface MCPServerToolConfiguration {
     allowed_tools?: Array<string> | null;
@@ -119,6 +127,13 @@ export interface MCPServerDoc<TCreateDate = unknown, TLegacyTokenExpiresAt = nev
     disabled?: boolean;
     clientName: string | undefined;
     tool_configuration?: MCPServerToolConfiguration | null;
+    /**
+     * Opt this server in to the LLM-driven `mcp__<name>__authenticate` tool
+     * instead of the blocking `mcp-auth-required` event, without turning on the
+     * org-wide `codegen-tool-mcp-authenticate` LD flag. Lets a single MCP server
+     * ship on the tool path ahead of the rest.
+     */
+    useAuthenticateTool?: boolean;
     oauthMetadata?: MCPServerOAuthMetadata | null;
     authorizationToken?: string;
     refreshToken?: string | null;

package/src/organization.d.ts

@@ -1,5 +1,11 @@
 import type { PrivacyMode, ReviewEffort } from "./codegen";
 import type { EnvironmentVariable } from "./common-schemas";
+export interface GitlabEnterpriseSetupValue {
+    host: string;
+    secondaryHost?: string;
+    setupType: "oauth" | "pat";
+    clientId?: string;
+}
 export interface GithubEnterpriseSetupValue {
     host: string;
     clientId: string;
@@ -19,6 +25,8 @@ export interface GitlabEnterprisePATValue {
     host: string;
     botUsername: string;
     secondaryHost?: string;
+    createdBy?: string;
+    createdAt?: number;
 }
 export interface GitlabCloudFallbackToken {
     token: string;
@@ -79,6 +87,7 @@ interface OrganizationSettings {
     isUserPluginIntegrationRequestGranted?: boolean;
     shopify?: boolean;
     githubEnterpriseSetupValue?: GithubEnterpriseSetupValue;
+    gitlabEnterpriseSetupValue?: GitlabEnterpriseSetupValue;
     gitlabEnterprisePAT?: GitlabEnterprisePATValue;
     gitlabCloudFallbackToken?: GitlabCloudFallbackToken;
     azureCloudFallbackToken?: AzureCloudFallbackToken;