@builder.io/ai-utils 0.95.0 → 0.97.0

package/src/projects.js

@@ -62,6 +62,43 @@ export const matchesAgentNativeStarter = (repo) => {
         return true;
     return !!((_a = repo.templateRepoUrl) === null || _a === void 0 ? void 0 : _a.includes(AGENT_NATIVE_STARTER_REPO));
 };
+function isStringRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function getManagedDatabasePackageJsonError(content) {
+    let packageJson;
+    try {
+        packageJson = JSON.parse(content);
+    }
+    catch (_a) {
+        return "The managed database root package.json must remain valid JSON.";
+    }
+    if (!isStringRecord(packageJson)) {
+        return "The managed database root package.json must contain a JSON object.";
+    }
+    const dependencies = packageJson.dependencies;
+    const devDependencies = packageJson.devDependencies;
+    const hasDrizzleOrm = isStringRecord(dependencies) &&
+        typeof dependencies["drizzle-orm"] === "string";
+    const hasDrizzleKit = isStringRecord(devDependencies) &&
+        typeof devDependencies["drizzle-kit"] === "string";
+    if (hasDrizzleOrm && hasDrizzleKit) {
+        return undefined;
+    }
+    return ("Managed database projects require drizzle-orm in root dependencies and drizzle-kit " +
+        "in root devDependencies. Preserve both declarations when editing package.json.");
+}
+export function getAgentNativeRootPackageJsonWriteError(args) {
+    if (!matchesAgentNativeStarter(args.repo)) {
+        return undefined;
+    }
+    const normalizePath = (value) => value.replace(/\\/g, "/").replace(/\/$/, "");
+    const rootPackageJsonPath = `${normalizePath(args.repoPath)}/package.json`;
+    if (normalizePath(args.resolvedPath) !== rootPackageJsonPath) {
+        return undefined;
+    }
+    return getManagedDatabasePackageJsonError(args.content);
+}
 export const EXAMPLE_OR_STARTER_REPOS = [
     ...EXAMPLE_REPOS,
     STARTER_REPO,
@@ -234,6 +271,55 @@ export const ListBranchesOptionsSchema = z.object({
         description: "Superuser-only: list branches for a different owner/org.",
     }),
 });
+export const ShapeEffectSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("remove-env"),
+        scope: z.literal("hosting-prod"),
+        key: z.string(),
+    }),
+    z.object({
+        kind: z.literal("attach-design-system"),
+        designSystemId: z.string(),
+    }),
+]);
+export const ShapeOptionEffectSchema = z.object({
+    instruction: z.string().optional(),
+    effects: z.array(ShapeEffectSchema).optional(),
+});
+export const ShapeOptionSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    effect: ShapeOptionEffectSchema.optional(),
+});
+export const ShapeQuestionSchema = z.object({
+    id: z.string(),
+    question: z.string(),
+    kind: z.enum(["select", "figma-upload"]),
+    options: z.array(ShapeOptionSchema),
+    guessOptionId: z.string().optional(),
+});
+export const ShapeAnswerSchema = z.object({
+    questionId: z.string(),
+    optionId: z.string().optional(),
+    designSystemId: z.string().optional(),
+    skipped: z.boolean(),
+    delegated: z.boolean(),
+    resolvedFrom: z.enum(["user", "llm"]),
+    llmOptionId: z.string().optional(),
+    guessOptionId: z.string().optional(),
+});
+export const ShapeSessionSchema = z.object({
+    questionnaireId: z.string(),
+    catalogVersion: z.string().regex(/^\d{4}-\d{2}-\d{2}\.\d+$/),
+    source: z.enum(["static", "agent"]),
+    status: z.enum(["assembling", "pending", "resolved"]),
+    selection: z.enum(["llm", "fallback"]),
+    questions: z.array(ShapeQuestionSchema),
+    initialPromptId: z.string(),
+    answers: z.array(ShapeAnswerSchema).optional(),
+    assembledAt: z.string().optional(),
+    resolvedAt: z.string().optional(),
+});
 export const ProjectRolePermissionsSchema = z
     .object({
     view: z.boolean().optional(),
@@ -721,6 +807,9 @@ export const ProjectSettingsSchema = z
     })
         .optional()
         .meta({ description: "Password-protect the preview URL." }),
+    shapeSession: ShapeSessionSchema.optional().meta({
+        description: "@internal Guided-onboarding questionnaire issued for this project.",
+    }),
 })
     .meta({ title: "ProjectSettings" });
 /**
@@ -744,6 +833,7 @@ const INTERNAL_PROJECT_SETTINGS_MASK = {
     commitInstructions: true,
     skipCommandSecurity: true,
     autoCloseBranchOnMerge: true,
+    shapeSession: true,
 };
 /**
  * Runtime schema for the client-writable subset of {@link Project.settings},
@@ -848,6 +938,13 @@ export const CreateProjectRequestSchema = z.object({
     /** Design system ids to seed into project settings at creation. */
     designSystems: z.array(z.string()).optional(),
 });
+export function resolveBranchIsPublic(isPublic, defaultBranchType) {
+    if (isPublic !== undefined)
+        return isPublic;
+    if (defaultBranchType === undefined)
+        return true;
+    return defaultBranchType === "shared";
+}
 export const MEMORY_PICKED_FIELDS = [
     "id",
     "updatedAt",
@@ -1193,6 +1290,44 @@ export const UpdateProjectOptionsSchema = z.object({
 /**
  * A single deploy record, stored at `deploys/{deployId}`. The Deploy.id is the document key.
  */
+/**
+ * Pipeline step a deploy died at. Set by the pod, the only place that still
+ * knows, so the server can attribute the failure without reading log text.
+ */
+export const DeployFailureStageSchema = z.enum([
+    "init",
+    "setup",
+    "migrate",
+    "build",
+    "package",
+    "upload",
+]);
+/** `app` is the only value that reaches the agent, so unknowns resolve away from it. */
+export const DeployFailureOwnerSchema = z.enum(["app", "platform", "unknown"]);
+/** What the deploy pod reports about a failure. All optional: older pods send none of it. */
+export const DeployFailureReportSchema = z.object({
+    stage: DeployFailureStageSchema.optional(),
+    exitCode: z.number().optional(),
+    signal: z.string().optional(),
+    excerpt: z.string().optional().meta({
+        description: "Head-and-tail excerpt of the failing output, cut on line boundaries. Event only, never persisted.",
+    }),
+});
+export const DeployFailureSchema = z.object({
+    stage: DeployFailureStageSchema.optional(),
+    owner: DeployFailureOwnerSchema,
+    code: z.string().meta({
+        description: "Classifier rule that produced the verdict, e.g. build-command-failed, build-killed, install-network.",
+    }),
+    summary: z.string().meta({
+        description: "One line naming the failure, safe to render in a list row.",
+    }),
+    exitCode: z.number().optional(),
+    signal: z.string().optional(),
+    fixRequested: z.boolean().optional().meta({
+        description: "Whether a Fusion agent fix was dispatched for this failure.",
+    }),
+});
 export const DeploySchema = z.object({
     id: z.string(),
     projectId: z.string(),
@@ -1247,7 +1382,10 @@ export const DeploySchema = z.object({
         description: "Whether Drizzle migrations were applied during this deploy. Absent when no migration ran.",
     }),
     error: z.string().optional().meta({
-        description: "Single human-readable line on failure; raw build logs not surfaced in v0",
+        description: "Head-and-tail excerpt of the failing step's output, ANSI stripped. Bounded because it rides in every deploy-list response.",
+    }),
+    failure: DeployFailureSchema.optional().meta({
+        description: "Structured verdict for a failed deploy: which stage failed and whether the failure is the app's or ours. Absent on deploys from pods that predate it.",
     }),
     createdAt: z.number(),
     completedAt: z.number().optional(),
@@ -1255,6 +1393,19 @@ export const DeploySchema = z.object({
         description: 'user ID for manual publish, or "auto-deploy" (v1)',
     }),
 });
+/** Values of `Deploy.triggeredBy` that name no real user. */
+const UNATTENDED_DEPLOY_TRIGGERS = new Set(["auto-deploy", "unknown"]);
+/**
+ * The user who asked for this deploy, or `undefined` when nobody did. Lives
+ * with the schema so every caller that needs a real user agrees on what counts.
+ */
+export function deployTriggeringUser(deploy) {
+    var _a;
+    const triggered = (_a = deploy.triggeredBy) === null || _a === void 0 ? void 0 : _a.trim();
+    return triggered && !UNATTENDED_DEPLOY_TRIGGERS.has(triggered)
+        ? triggered
+        : undefined;
+}
 /**
  * Permanent slug reservation, stored at `hosting-slugs/{slug}` (slug is the document key).
  *
@@ -1348,6 +1499,7 @@ export const DeployListItemSchema = DeploySchema.pick({
     createdAt: true,
     completedAt: true,
     error: true,
+    failure: true,
     checkoutBranch: true,
     checkoutCommit: true,
     builtCommit: true,
@@ -1482,6 +1634,60 @@ export function hasResolvableHostingBuildConfig(overrides) {
     }
     return false;
 }
+/**
+ * Env vars every hosted deploy gets unless the project sets them itself.
+ *
+ * Recurring jobs default off because Agent Native ships a Netlify scheduled function
+ * that wakes a background sweep every minute for the life of the deploy, even when the
+ * app defines no jobs — enough to keep a scale-to-zero database from ever suspending.
+ * Set `AGENT_NATIVE_DISABLE_RECURRING_JOBS=false` in the build env to opt back in.
+ */
+export const HOSTED_DEPLOY_ENV_DEFAULTS = {
+    AGENT_NATIVE_DISABLE_RECURRING_JOBS: "true",
+};
+/**
+ * Layer `HOSTED_DEPLOY_ENV_DEFAULTS` under a build config's env, project values winning.
+ *
+ * Call only after `hasResolvableHostingBuildConfig` — the defaults would otherwise make
+ * a project with no hosting config look deployable. Keys are trimmed so a padded project
+ * key still wins instead of sitting beside the default the build actually reads.
+ */
+export function applyHostedBuildEnvDefaults(overrides) {
+    return {
+        ...overrides,
+        environment: {
+            ...HOSTED_DEPLOY_ENV_DEFAULTS,
+            ...normalizeEnvRecordKeys(overrides.environment),
+        },
+    };
+}
+/** Trim env keys and drop blank ones, so both env scopes compare keys the same way. */
+function normalizeEnvRecordKeys(environment) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(environment !== null && environment !== void 0 ? environment : {})) {
+        const trimmed = key.trim();
+        if (trimmed) {
+            normalized[trimmed] = value;
+        }
+    }
+    return normalized;
+}
+/**
+ * What a build env resolved each `HOSTED_DEPLOY_ENV_DEFAULTS` key to. The deploy pod
+ * sends this to the service so the runtime env matches what the build compiled against.
+ *
+ * Keys outside `HOSTED_DEPLOY_ENV_DEFAULTS` are dropped, so this is safe to call on an
+ * env record that arrived in an event payload.
+ */
+export function resolveHostedEnvDefaults(environment) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(normalizeEnvRecordKeys(environment))) {
+        if (Object.hasOwn(HOSTED_DEPLOY_ENV_DEFAULTS, key)) {
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}
 /**
  * Request body for `POST /_builder.io/api/build-and-upload` on the deploy pod.
  */
@@ -1751,6 +1957,24 @@ export const CloneProjectOptionsSchema = z.object({
         description: "Whether to provision on cloud-v2 (Kubernetes). Defaults to false.",
     }),
 });
+export const GetPreferredProjectForRepoOptionsSchema = z.object({
+    repoUrl: z.string().min(1).meta({
+        description: "Full clone URL of the repository to look up.",
+    }),
+    repoFullName: z.string().optional().meta({
+        description: 'Repo in "owner/repo" form; derived from `repoUrl` when omitted.',
+    }),
+});
+/** Identity only — this powers a "currently preferred: X" label, not a project read. */
+export const GetPreferredProjectForRepoResultSchema = z.object({
+    status: z.literal("success"),
+    project: z
+        .object({
+        id: z.string(),
+        name: z.string(),
+    })
+        .nullable(),
+});
 /**
  * Write-time contract for a single hosted-site access rule. Mirrors the stored
  * {@link SiteAccessRule} in `organization.ts`, except a password rule carries a
@@ -1893,6 +2117,7 @@ export const ProjectTemplateOverridesSchema = z.object({
         sourceProjectId: true,
         sourceBranchName: true,
     }).partial().shape,
+    settings: ProjectSettingsExternalSchema.partial().optional(),
     hosting: ProjectHostingExternalSchema.optional(),
 });
 export const CreateProjectTemplateFromProjectOptionsSchema = z.object({

package/src/projects.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { AGENT_NATIVE_STARTER_REPO, matchesAgentNativeStarter, ProjectHostingExternalSchema, ProjectHostingSchema, } from "./projects";
+import { AGENT_NATIVE_STARTER_REPO, getAgentNativeRootPackageJsonWriteError, getManagedDatabasePackageJsonError, matchesAgentNativeStarter, ProjectHostingExternalSchema, ProjectHostingSchema, ProjectSettingsExternalSchema, ProjectSettingsSchema, ProjectTemplateOverridesSchema, ShapeSessionSchema, } from "./projects";
 describe("project hosting schemas", () => {
     it("accepts the canonical published branch route", () => {
         expect(ProjectHostingSchema.parse({ publishedBranchId: "branch-live" })).toEqual({ publishedBranchId: "branch-live" });
@@ -11,6 +11,55 @@ describe("project hosting schemas", () => {
         })).toEqual({ enabled: true });
     });
 });
+describe("guided onboarding project settings", () => {
+    const shapeSession = {
+        questionnaireId: "questionnaire-1",
+        catalogVersion: "2026-09-03.1",
+        source: "static",
+        status: "pending",
+        selection: "llm",
+        questions: [
+            {
+                id: "authentication",
+                question: "Will users need to login to use your app?",
+                kind: "select",
+                options: [
+                    {
+                        id: "required",
+                        label: "Yes",
+                        effect: {
+                            instruction: "Require users to sign in.",
+                            effects: [
+                                {
+                                    kind: "remove-env",
+                                    scope: "hosting-prod",
+                                    key: "AUTH_DISABLED",
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        ],
+        initialPromptId: "prompt-1",
+    };
+    it("parses a snapshotted questionnaire session", () => {
+        expect(ShapeSessionSchema.parse(shapeSession)).toEqual(shapeSession);
+        expect(ProjectSettingsSchema.parse({ shapeSession })).toEqual({
+            shapeSession,
+        });
+    });
+    it("requires a dated catalog version", () => {
+        expect(() => ShapeSessionSchema.parse({
+            ...shapeSession,
+            catalogVersion: "v1",
+        })).toThrow();
+    });
+    it("does not allow clients to write a shape session", () => {
+        expect(ProjectSettingsExternalSchema.parse({ shapeSession })).toEqual({});
+        expect(ProjectTemplateOverridesSchema.parse({ settings: { shapeSession } })).toEqual({ settings: {} });
+    });
+});
 describe("matchesAgentNativeStarter", () => {
     it("matches when repoName is the starter", () => {
         expect(matchesAgentNativeStarter({ repoName: AGENT_NATIVE_STARTER_REPO })).toBe(true);
@@ -31,3 +80,59 @@ describe("matchesAgentNativeStarter", () => {
         expect(matchesAgentNativeStarter({})).toBe(false);
     });
 });
+describe("getManagedDatabasePackageJsonError", () => {
+    it("accepts the required root Drizzle dependencies", () => {
+        expect(getManagedDatabasePackageJsonError(JSON.stringify({
+            dependencies: { "drizzle-orm": "0.45.2" },
+            devDependencies: { "drizzle-kit": "0.31.10" },
+        }))).toBeUndefined();
+    });
+    it.each([
+        {
+            dependencies: {},
+            devDependencies: { "drizzle-kit": "0.31.10" },
+        },
+        {
+            dependencies: { "drizzle-orm": "0.45.2", "drizzle-kit": "0.31.10" },
+            devDependencies: {},
+        },
+        {
+            dependencies: {},
+            devDependencies: {
+                "drizzle-orm": "0.45.2",
+                "drizzle-kit": "0.31.10",
+            },
+        },
+    ])("rejects missing or misplaced dependencies", (packageJson) => {
+        expect(getManagedDatabasePackageJsonError(JSON.stringify(packageJson))).toContain("Preserve both declarations");
+    });
+    it("rejects invalid package.json content", () => {
+        expect(getManagedDatabasePackageJsonError("not json")).toContain("valid JSON");
+    });
+});
+describe("getAgentNativeRootPackageJsonWriteError", () => {
+    const repo = { repoName: AGENT_NATIVE_STARTER_REPO };
+    const invalidManifest = JSON.stringify({ dependencies: {} });
+    it("rejects an invalid resolved root manifest", () => {
+        expect(getAgentNativeRootPackageJsonWriteError({
+            repo,
+            repoPath: "/workspace",
+            resolvedPath: "/workspace/package.json",
+            content: invalidManifest,
+        })).toContain("drizzle-orm");
+    });
+    it("allows nested and unrelated repository manifests", () => {
+        expect(getAgentNativeRootPackageJsonWriteError({
+            repo,
+            repoPath: "/workspace",
+            resolvedPath: "/workspace/apps/web/package.json",
+            content: invalidManifest,
+        })).toBeUndefined();
+        expect(getAgentNativeRootPackageJsonWriteError({
+            repo: { repoName: "acme/dashboard" },
+            repoPath: "/workspace",
+            resolvedPath: "/workspace/package.json",
+            content: invalidManifest,
+        })).toBeUndefined();
+    });
+});

package/src/publish-agent.d.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+export declare const PublishAgentSessionCursorSchema: z.ZodObject<{
+    updatedAt: z.ZodNumber;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type PublishAgentSessionCursor = z.infer<typeof PublishAgentSessionCursorSchema>;
+export declare const PublishAgentSessionsQuerySchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    completionIdCursor: z.ZodOptional<z.ZodString>;
+    archived: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+}, z.core.$strip>;
+export type PublishAgentSessionsQuery = z.infer<typeof PublishAgentSessionsQuerySchema>;
+/**
+ * Body of a session rename and/or archive. The space stays in `?apiKey=` /
+ * `x-builder-api-key`, where the request middleware binds it from.
+ */
+export declare const PublishAgentSessionUpdateRequestSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PublishAgentSessionUpdateRequest = z.infer<typeof PublishAgentSessionUpdateRequestSchema>;
+export declare const PublishAgentAttachmentReferenceSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PublishAgentAttachmentReference = z.infer<typeof PublishAgentAttachmentReferenceSchema>;
+export declare const PublishAgentToolReferenceSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        requested: "requested";
+    }>;
+}, z.core.$strip>;
+export type PublishAgentToolReference = z.infer<typeof PublishAgentToolReferenceSchema>;
+export declare const PublishAgentSessionMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    senderId: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    status: z.ZodEnum<{
+        completed: "completed";
+        error: "error";
+        running: "running";
+    }>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            requested: "requested";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PublishAgentSessionMessage = z.infer<typeof PublishAgentSessionMessageSchema>;
+export declare const PublishAgentSessionSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    spaceId: z.ZodString;
+    createdBy: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    preview: z.ZodNullable<z.ZodString>;
+    archived: z.ZodBoolean;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    lastCompletionId: z.ZodNullable<z.ZodString>;
+    totalCompletions: z.ZodNumber;
+    numUserMessages: z.ZodNumber;
+}, z.core.$strip>;
+export type PublishAgentSessionSummary = z.infer<typeof PublishAgentSessionSummarySchema>;
+export declare const PublishAgentSessionListResponseSchema: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        spaceId: z.ZodString;
+        createdBy: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        preview: z.ZodNullable<z.ZodString>;
+        archived: z.ZodBoolean;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        lastCompletionId: z.ZodNullable<z.ZodString>;
+        totalCompletions: z.ZodNumber;
+        numUserMessages: z.ZodNumber;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PublishAgentSessionListResponse = z.infer<typeof PublishAgentSessionListResponseSchema>;
+export declare const PublishAgentSessionDetailResponseSchema: z.ZodObject<{
+    session: z.ZodObject<{
+        id: z.ZodString;
+        spaceId: z.ZodString;
+        createdBy: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        preview: z.ZodNullable<z.ZodString>;
+        archived: z.ZodBoolean;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        lastCompletionId: z.ZodNullable<z.ZodString>;
+        totalCompletions: z.ZodNumber;
+        numUserMessages: z.ZodNumber;
+    }, z.core.$strip>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            user: "user";
+        }>;
+        senderId: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        status: z.ZodEnum<{
+            completed: "completed";
+            error: "error";
+            running: "running";
+        }>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                requested: "requested";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    messagesCanLoadMore: z.ZodBoolean;
+    messagesNextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PublishAgentSessionDetailResponse = z.infer<typeof PublishAgentSessionDetailResponseSchema>;

package/src/publish-agent.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+export const PublishAgentSessionCursorSchema = z
+    .object({
+    updatedAt: z.number().int(),
+    id: z.string().min(1),
+})
+    .meta({ title: "PublishAgentSessionCursor" });
+export const PublishAgentSessionsQuerySchema = z
+    .object({
+    apiKey: z.string().min(1).max(256),
+    sessionId: z.string().min(1).max(256).optional(),
+    limit: z.coerce.number().int().min(1).max(50).default(20),
+    cursor: z.string().min(1).max(2048).optional(),
+    completionIdCursor: z.string().min(1).max(256).optional(),
+    /** Lists archived sessions instead of active ones. Ignored for a detail read. */
+    archived: z.stringbool().default(false),
+})
+    .meta({ title: "PublishAgentSessionsQuery" });
+/**
+ * Body of a session rename and/or archive. The space stays in `?apiKey=` /
+ * `x-builder-api-key`, where the request middleware binds it from.
+ */
+export const PublishAgentSessionUpdateRequestSchema = z
+    .object({
+    sessionId: z.string().min(1).max(256),
+    title: z.string().trim().min(1).max(200).optional(),
+    archived: z.boolean().optional(),
+})
+    .refine((body) => body.title !== undefined || body.archived !== undefined, {
+    message: "Provide title, archived, or both.",
+})
+    .meta({ title: "PublishAgentSessionUpdateRequest" });
+export const PublishAgentAttachmentReferenceSchema = z
+    .object({
+    id: z.string().optional(),
+    type: z.string(),
+    name: z.string().optional(),
+    size: z.number().optional(),
+})
+    .meta({ title: "PublishAgentAttachmentReference" });
+export const PublishAgentToolReferenceSchema = z
+    .object({
+    id: z.string().optional(),
+    name: z.string(),
+    status: z.enum(["requested", "completed"]),
+})
+    .meta({ title: "PublishAgentToolReference" });
+export const PublishAgentSessionMessageSchema = z
+    .object({
+    id: z.string(),
+    role: z.enum(["user", "assistant"]),
+    senderId: z.string().optional(),
+    content: z.string().optional(),
+    createdAt: z.number(),
+    status: z.enum(["completed", "running", "error"]),
+    attachments: z.array(PublishAgentAttachmentReferenceSchema).optional(),
+    tools: z.array(PublishAgentToolReferenceSchema).optional(),
+})
+    .meta({ title: "PublishAgentSessionMessage" });
+export const PublishAgentSessionSummarySchema = z
+    .object({
+    id: z.string(),
+    spaceId: z.string(),
+    createdBy: z.string(),
+    title: z.string().nullable(),
+    preview: z.string().nullable(),
+    archived: z.boolean(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    lastCompletionId: z.string().nullable(),
+    totalCompletions: z.number(),
+    numUserMessages: z.number(),
+})
+    .meta({ title: "PublishAgentSessionSummary" });
+export const PublishAgentSessionListResponseSchema = z
+    .object({
+    sessions: z.array(PublishAgentSessionSummarySchema),
+    nextCursor: z.string().nullable(),
+})
+    .meta({ title: "PublishAgentSessionListResponse" });
+export const PublishAgentSessionDetailResponseSchema = z
+    .object({
+    session: PublishAgentSessionSummarySchema,
+    messages: z.array(PublishAgentSessionMessageSchema),
+    messagesCanLoadMore: z.boolean(),
+    messagesNextCursor: z.string().nullable(),
+})
+    .meta({ title: "PublishAgentSessionDetailResponse" });

package/src/repo-indexing.d.ts

@@ -132,6 +132,8 @@ export type LastIndexInput = {
 export interface DesignSystem {
     id: string;
     spaceId: string;
+    /** Additional spaces a space-scoped design system is shared with, beyond spaceId. */
+    spaceIds?: string[];
     rootOrgId: string;
     createdDate: Date;
     createdByUserId: string;