forge-openclaw-plugin 0.2.24 → 0.2.26

package/dist/server/{types.js → server/src/types.js}

@@ -93,6 +93,12 @@ export const activityEntityTypeSchema = z.enum([
     "mode_profile",
     "mode_guide_session",
     "trigger_report",
+    "preference_catalog",
+    "preference_catalog_item",
+    "preference_context",
+    "preference_item",
+    "questionnaire_instrument",
+    "questionnaire_run",
     "note",
     "event_type",
     "emotion_definition",
@@ -199,7 +205,12 @@ export const crudEntityTypeSchema = z.enum([
     "mode_guide_session",
     "event_type",
     "emotion_definition",
-    "trigger_report"
+    "trigger_report",
+    "preference_catalog",
+    "preference_catalog_item",
+    "preference_context",
+    "preference_item",
+    "questionnaire_instrument"
 ]);
 export const rewardableEntityTypeSchema = z.enum([
     "system",
@@ -235,6 +246,11 @@ export const rewardRuleFamilySchema = z.enum([
     "ambient"
 ]);
 export const appLocaleSchema = z.enum(["en", "fr"]);
+export const surfaceWidgetDensitySchema = z.enum([
+    "dense",
+    "compact",
+    "comfortable"
+]);
 const trimmedString = z.string().trim();
 const nonEmptyTrimmedString = trimmedString.min(1);
 const rewardConfigValueSchema = z.union([
@@ -876,7 +892,7 @@ export const activityEventSchema = z.object({
     description: z.string(),
     actor: z.string().nullable(),
     source: activitySourceSchema,
-    metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])),
+    metadata: z.record(z.string(), z.unknown()),
     createdAt: z.string(),
     ...ownershipShape
 });
@@ -1195,7 +1211,32 @@ export const notificationPreferencesSchema = z.object({
     dailyQuestReminders: z.boolean(),
     achievementCelebrations: z.boolean()
 });
-export const themePreferenceSchema = z.enum(["obsidian", "solar", "system"]);
+const hexColorSchema = z
+    .string()
+    .trim()
+    .regex(/^#[0-9a-fA-F]{6}$/, "Use a 6-digit hex color");
+export const themePreferenceSchema = z.enum([
+    "obsidian",
+    "solar",
+    "aurora",
+    "ember",
+    "paper",
+    "dawn",
+    "atelier",
+    "custom",
+    "system"
+]);
+export const customThemeSchema = z.object({
+    label: z.string().trim().min(1).max(40),
+    primary: hexColorSchema,
+    secondary: hexColorSchema,
+    tertiary: hexColorSchema,
+    canvas: hexColorSchema,
+    panel: hexColorSchema,
+    panelHigh: hexColorSchema,
+    panelLow: hexColorSchema,
+    ink: hexColorSchema
+});
 export const executionSettingsSchema = z.object({
     maxActiveTasks: z.number().int().min(1).max(8),
     timeAccountingMode: timeAccountingModeSchema
@@ -1211,6 +1252,384 @@ export const microsoftCalendarAuthSettingsSchema = z.object({
     isReadyForSignIn: z.boolean(),
     setupMessage: z.string()
 });
+export const googleCalendarAuthSettingsSchema = z.object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+    storedClientId: z.string(),
+    storedClientSecret: z.string(),
+    appBaseUrl: z.string(),
+    redirectUri: z.string(),
+    allowedOrigins: z.array(z.string()),
+    usesPkce: z.literal(true),
+    requiresServerClientSecret: z.literal(false),
+    oauthClientType: z.literal("desktop_app"),
+    authMode: z.literal("localhost_pkce"),
+    isConfigured: z.boolean(),
+    isReadyForPairing: z.boolean(),
+    isLocalOnly: z.literal(true),
+    runtimeOrigin: z.string(),
+    setupMessage: z.string()
+});
+export const aiModelProviderSchema = z.enum([
+    "openai-api",
+    "openai-codex",
+    "openai-compatible"
+]);
+export const aiModelAuthModeSchema = z.enum(["api_key", "oauth"]);
+export const aiModelConnectionStatusSchema = z.enum([
+    "connected",
+    "needs_attention"
+]);
+export const aiModelConnectionSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    provider: aiModelProviderSchema,
+    authMode: aiModelAuthModeSchema,
+    baseUrl: z.string(),
+    model: z.string(),
+    accountLabel: z.string().nullable(),
+    enabled: z.boolean(),
+    status: aiModelConnectionStatusSchema,
+    hasStoredCredential: z.boolean(),
+    usesOAuth: z.boolean(),
+    supportsCustomBaseUrl: z.boolean(),
+    agentId: z.string(),
+    agentLabel: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const forgeAgentModelSlotSchema = z.object({
+    connectionId: z.string().nullable(),
+    connectionLabel: z.string().nullable(),
+    provider: aiModelProviderSchema.nullable(),
+    baseUrl: z.string().nullable(),
+    model: z.string()
+});
+export const modelSettingsPayloadSchema = z.object({
+    forgeAgent: z.object({
+        basicChat: forgeAgentModelSlotSchema,
+        wiki: forgeAgentModelSlotSchema
+    }),
+    connections: z.array(aiModelConnectionSchema),
+    oauth: z.object({
+        openAiCodex: z.object({
+            authorizeUrl: z.string(),
+            callbackUrl: z.string(),
+            setupMessage: z.string()
+        })
+    })
+});
+export const aiProcessorTriggerModeSchema = z.enum([
+    "manual",
+    "route",
+    "cron"
+]);
+export const aiProcessorCapabilityModeSchema = z.enum([
+    "content",
+    "tool",
+    "mcp",
+    "processor"
+]);
+export const aiProcessorAccessModeSchema = z.enum([
+    "read",
+    "write",
+    "read_write",
+    "exec"
+]);
+export const aiProcessorMachineAccessSchema = z.object({
+    read: z.boolean().default(false),
+    write: z.boolean().default(false),
+    exec: z.boolean().default(false)
+});
+export const aiProcessorAgentConfigSchema = z.object({
+    agentId: nonEmptyTrimmedString,
+    connectionId: trimmedString.nullable().default(null),
+    model: trimmedString.default("")
+});
+export const aiProcessorToolSchema = z.object({
+    key: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    endpoint: trimmedString.default(""),
+    mode: aiProcessorCapabilityModeSchema.default("tool")
+});
+export const surfaceWidgetPreferencesSchema = z.object({
+    hidden: z.boolean().default(false),
+    fullWidth: z.boolean().default(false),
+    titleVisible: z.boolean().default(true),
+    descriptionVisible: z.boolean().default(true)
+});
+export const surfaceLayoutPayloadSchema = z.object({
+    surfaceId: nonEmptyTrimmedString,
+    order: z.array(nonEmptyTrimmedString).default([]),
+    widgets: z.record(z.string(), surfaceWidgetPreferencesSchema).default({}),
+    updatedAt: z.string()
+});
+export const writeSurfaceLayoutSchema = z.object({
+    order: z.array(nonEmptyTrimmedString).default([]),
+    widgets: z.record(z.string(), surfaceWidgetPreferencesSchema).default({})
+});
+export const aiProcessorSchema = z.object({
+    id: z.string(),
+    slug: z.string(),
+    surfaceId: z.string(),
+    title: z.string(),
+    promptFlow: z.string(),
+    contextInput: z.string(),
+    toolConfig: z.array(aiProcessorToolSchema),
+    agentIds: z.array(z.string()),
+    agentConfigs: z.array(aiProcessorAgentConfigSchema),
+    triggerMode: aiProcessorTriggerModeSchema,
+    cronExpression: z.string(),
+    machineAccess: aiProcessorMachineAccessSchema,
+    endpointEnabled: z.boolean(),
+    lastRunAt: z.string().nullable(),
+    lastRunStatus: z.enum(["idle", "running", "completed", "failed"]).nullable(),
+    lastRunOutput: z
+        .object({
+        concatenated: z.string(),
+        byAgent: z.record(z.string(), z.string())
+    })
+        .nullable(),
+    runHistory: z.array(z.object({
+        id: z.string(),
+        trigger: z.enum(["manual", "route", "cron"]),
+        startedAt: z.string(),
+        completedAt: z.string().nullable(),
+        status: z.enum(["running", "completed", "failed"]),
+        input: z.string(),
+        output: z
+            .object({
+            concatenated: z.string(),
+            byAgent: z.record(z.string(), z.string())
+        })
+            .nullable(),
+        error: z.string().nullable()
+    })),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const aiProcessorLinkSchema = z.object({
+    id: z.string(),
+    surfaceId: z.string(),
+    sourceWidgetId: z.string(),
+    targetProcessorId: z.string(),
+    accessMode: aiProcessorAccessModeSchema,
+    capabilityMode: aiProcessorCapabilityModeSchema,
+    metadata: z.record(z.string(), z.unknown()),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const surfaceProcessorGraphPayloadSchema = z.object({
+    surfaceId: z.string(),
+    processors: z.array(aiProcessorSchema),
+    links: z.array(aiProcessorLinkSchema)
+});
+export const forgeBoxCapabilityModeSchema = z.enum([
+    "content",
+    "tool",
+    "action",
+    "mcp"
+]);
+export const forgeBoxToolAdapterSchema = z.object({
+    key: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    accessMode: aiProcessorAccessModeSchema.default("read")
+});
+export const forgeBoxPortDefinitionSchema = z.object({
+    key: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    kind: nonEmptyTrimmedString.default("content"),
+    required: z.boolean().default(false),
+    expandableKeys: z.array(nonEmptyTrimmedString).default([])
+});
+export const forgeBoxCatalogEntrySchema = z.object({
+    id: nonEmptyTrimmedString,
+    boxId: trimmedString.optional(),
+    surfaceId: trimmedString.nullable(),
+    routePath: trimmedString.nullable(),
+    title: nonEmptyTrimmedString,
+    label: trimmedString.optional(),
+    icon: trimmedString.nullable().optional(),
+    description: trimmedString.default(""),
+    category: nonEmptyTrimmedString,
+    tags: z.array(nonEmptyTrimmedString).default([]),
+    capabilityModes: z.array(forgeBoxCapabilityModeSchema).default(["content"]).optional(),
+    inputs: z.array(forgeBoxPortDefinitionSchema).default([]),
+    params: z.array(forgeBoxPortDefinitionSchema).default([]),
+    output: z.array(forgeBoxPortDefinitionSchema).default([]),
+    tools: z.array(forgeBoxToolAdapterSchema).default([]),
+    outputs: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+    toolAdapters: z.array(forgeBoxToolAdapterSchema).default([]).optional(),
+    snapshotResolverKey: trimmedString.optional()
+});
+export const forgeBoxSnapshotSchema = z.object({
+    boxId: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    capturedAt: z.string(),
+    contentText: z.string(),
+    contentJson: z.record(z.string(), z.unknown()).nullable(),
+    tools: z.array(forgeBoxToolAdapterSchema).default([])
+});
+export const aiConnectorKindSchema = z.enum(["functor", "chat"]);
+export const aiConnectorNodeTypeSchema = z.enum([
+    "box",
+    "box_input",
+    "value",
+    "user_input",
+    "functor",
+    "chat",
+    "output",
+    "merge",
+    "template",
+    "pick_key"
+]);
+export const aiConnectorNodeModelConfigSchema = z.object({
+    connectionId: trimmedString.nullable().default(null),
+    provider: aiModelProviderSchema.nullable().default(null),
+    baseUrl: trimmedString.nullable().default(null),
+    model: trimmedString.default(""),
+    thinking: trimmedString.nullable().default(null),
+    verbosity: trimmedString.nullable().default(null)
+});
+export const aiConnectorNodeSchema = z.object({
+    id: nonEmptyTrimmedString,
+    type: aiConnectorNodeTypeSchema,
+    position: z.object({
+        x: z.number(),
+        y: z.number()
+    }),
+    data: z.object({
+        label: nonEmptyTrimmedString,
+        description: trimmedString.default(""),
+        boxId: trimmedString.nullable().optional(),
+        prompt: trimmedString.optional(),
+        promptTemplate: trimmedString.optional(),
+        systemPrompt: trimmedString.optional(),
+        outputKey: trimmedString.optional(),
+        enabledToolKeys: z.array(nonEmptyTrimmedString).default([]),
+        inputs: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+        outputs: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+        params: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+        paramValues: z.record(z.string(), z.unknown()).default({}).optional(),
+        template: trimmedString.optional(),
+        selectedKey: trimmedString.optional(),
+        valueType: z
+            .enum(["string", "number", "boolean", "null", "array", "object"])
+            .optional(),
+        valueLiteral: trimmedString.optional(),
+        modelConfig: aiConnectorNodeModelConfigSchema.optional()
+    })
+});
+export const aiConnectorEdgeSchema = z.object({
+    id: nonEmptyTrimmedString,
+    source: nonEmptyTrimmedString,
+    target: nonEmptyTrimmedString,
+    sourceHandle: trimmedString.nullable().optional(),
+    targetHandle: trimmedString.nullable().optional(),
+    label: trimmedString.nullable().optional()
+});
+export const aiConnectorOutputSchema = z.object({
+    id: nonEmptyTrimmedString,
+    nodeId: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    apiPath: nonEmptyTrimmedString
+});
+export const aiConnectorRunResultSchema = z.object({
+    primaryText: z.string(),
+    outputs: z.record(z.string(), z.object({
+        label: z.string(),
+        text: z.string(),
+        json: z.record(z.string(), z.unknown()).nullable()
+    })),
+    debugTrace: z
+        .object({
+        nodes: z.array(z.object({
+            nodeId: nonEmptyTrimmedString,
+            nodeType: aiConnectorNodeTypeSchema,
+            label: nonEmptyTrimmedString,
+            input: z.array(z.object({
+                sourceNodeId: nonEmptyTrimmedString,
+                sourceHandle: trimmedString.nullable(),
+                targetHandle: trimmedString.nullable(),
+                text: z.string(),
+                json: z.record(z.string(), z.unknown()).nullable()
+            })),
+            output: z.object({
+                text: z.string(),
+                json: z.record(z.string(), z.unknown()).nullable()
+            }),
+            tools: z.array(z.string()).default([]),
+            logs: z.array(z.string()).default([]),
+            error: z.string().nullable()
+        })),
+        errors: z.array(z.string()).default([])
+    })
+        .optional()
+});
+export const aiConnectorRunSchema = z.object({
+    id: nonEmptyTrimmedString,
+    connectorId: nonEmptyTrimmedString,
+    mode: z.enum(["run", "chat"]),
+    status: z.enum(["running", "completed", "failed"]),
+    userInput: z.string(),
+    context: z.record(z.string(), z.unknown()).default({}),
+    conversationId: trimmedString.nullable(),
+    result: aiConnectorRunResultSchema.nullable(),
+    error: z.string().nullable(),
+    createdAt: z.string(),
+    completedAt: z.string().nullable()
+});
+export const aiConnectorConversationSchema = z.object({
+    id: nonEmptyTrimmedString,
+    connectorId: nonEmptyTrimmedString,
+    provider: trimmedString.nullable(),
+    externalConversationId: trimmedString.nullable(),
+    transcript: z.array(z.object({
+        role: z.enum(["system", "developer", "user", "assistant", "tool"]),
+        text: z.string(),
+        createdAt: z.string()
+    })),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const aiConnectorSchema = z.object({
+    id: nonEmptyTrimmedString,
+    slug: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    kind: aiConnectorKindSchema,
+    homeSurfaceId: trimmedString.nullable(),
+    endpointEnabled: z.boolean().default(true),
+    graph: z.object({
+        nodes: z.array(aiConnectorNodeSchema).default([]),
+        edges: z.array(aiConnectorEdgeSchema).default([])
+    }),
+    publishedOutputs: z.array(aiConnectorOutputSchema).default([]),
+    lastRun: aiConnectorRunSchema.nullable(),
+    legacyProcessorId: trimmedString.nullable().default(null),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const openAiCodexOauthSessionSchema = z.object({
+    id: z.string(),
+    status: z.enum([
+        "starting",
+        "awaiting_browser",
+        "awaiting_manual_input",
+        "authorized",
+        "error",
+        "consumed",
+        "expired"
+    ]),
+    authUrl: z.string().nullable(),
+    accountLabel: z.string().nullable(),
+    error: z.string().nullable(),
+    createdAt: z.string(),
+    expiresAt: z.string(),
+    credentialExpiresAt: z.string().nullable()
+});
 export const agentTokenSummarySchema = z.object({
     id: z.string(),
     label: z.string(),
@@ -1440,6 +1859,7 @@ export const settingsPayloadSchema = z.object({
     notifications: notificationPreferencesSchema,
     execution: executionSettingsSchema,
     themePreference: themePreferenceSchema,
+    customTheme: customThemeSchema.nullable(),
     localePreference: appLocaleSchema,
     security: z.object({
         integrityScore: z.number().int().min(0).max(100),
@@ -1450,8 +1870,10 @@ export const settingsPayloadSchema = z.object({
         psycheAuthRequired: z.boolean()
     }),
     calendarProviders: z.object({
+        google: googleCalendarAuthSettingsSchema,
         microsoft: microsoftCalendarAuthSettingsSchema
     }),
+    modelSettings: modelSettingsPayloadSchema,
     agents: z.array(agentIdentitySchema),
     agentTokens: z.array(agentTokenSummarySchema)
 });
@@ -1665,10 +2087,7 @@ export const createCalendarConnectionSchema = z.discriminatedUnion("provider", [
     z.object({
         provider: z.literal("google"),
         label: nonEmptyTrimmedString,
-        username: nonEmptyTrimmedString,
-        clientId: nonEmptyTrimmedString,
-        clientSecret: nonEmptyTrimmedString,
-        refreshToken: nonEmptyTrimmedString,
+        authSessionId: nonEmptyTrimmedString,
         selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).min(1),
         forgeCalendarUrl: nonEmptyTrimmedString.url().nullable().optional(),
         createForgeCalendar: z.boolean().optional().default(false)
@@ -1700,13 +2119,6 @@ export const createCalendarConnectionSchema = z.discriminatedUnion("provider", [
     })
 ]);
 export const discoverCalendarConnectionSchema = z.discriminatedUnion("provider", [
-    z.object({
-        provider: z.literal("google"),
-        username: nonEmptyTrimmedString,
-        clientId: nonEmptyTrimmedString,
-        clientSecret: nonEmptyTrimmedString,
-        refreshToken: nonEmptyTrimmedString
-    }),
     z.object({
         provider: z.literal("apple"),
         username: nonEmptyTrimmedString,
@@ -1722,6 +2134,10 @@ export const discoverCalendarConnectionSchema = z.discriminatedUnion("provider",
 export const startMicrosoftCalendarOauthSchema = z.object({
     label: nonEmptyTrimmedString.optional()
 });
+export const startGoogleCalendarOauthSchema = z.object({
+    label: nonEmptyTrimmedString.optional(),
+    browserOrigin: trimmedString.optional()
+});
 export const testMicrosoftCalendarOauthConfigurationSchema = z.object({
     clientId: nonEmptyTrimmedString.regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/, "Microsoft client IDs must use the standard app registration GUID format."),
     tenantId: trimmedString.default("common"),
@@ -1735,6 +2151,14 @@ export const microsoftCalendarOauthSessionSchema = z.object({
     error: z.string().nullable(),
     discovery: calendarDiscoveryPayloadSchema.nullable()
 });
+export const googleCalendarOauthSessionSchema = z.object({
+    sessionId: nonEmptyTrimmedString,
+    status: z.enum(["pending", "authorized", "error", "consumed", "expired"]),
+    authUrl: z.string().url().nullable(),
+    accountLabel: z.string().nullable(),
+    error: z.string().nullable(),
+    discovery: calendarDiscoveryPayloadSchema.nullable()
+});
 export const updateCalendarConnectionSchema = z.object({
     label: nonEmptyTrimmedString.optional(),
     selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).optional()
@@ -2243,6 +2667,7 @@ export const updateSettingsSchema = z.object({
     notifications: notificationPreferencesSchema.partial().optional(),
     execution: executionSettingsSchema.partial().optional(),
     themePreference: themePreferenceSchema.optional(),
+    customTheme: customThemeSchema.nullable().optional(),
     localePreference: appLocaleSchema.optional(),
     security: z
         .object({
@@ -2251,6 +2676,12 @@ export const updateSettingsSchema = z.object({
         .optional(),
     calendarProviders: z
         .object({
+        google: z
+            .object({
+            clientId: trimmedString.optional(),
+            clientSecret: trimmedString.optional()
+        })
+            .optional(),
         microsoft: z
             .object({
             clientId: trimmedString.optional(),
@@ -2260,6 +2691,182 @@ export const updateSettingsSchema = z.object({
             .optional()
     })
         .optional()
+        .superRefine((value, context) => {
+        if (!value) {
+            return;
+        }
+        const google = value.google;
+        if (!google) {
+            return;
+        }
+        const hasClientIdField = google.clientId !== undefined;
+        const hasClientSecretField = google.clientSecret !== undefined;
+        const hasClientIdValue = (google.clientId?.length ?? 0) > 0;
+        const hasClientSecretValue = (google.clientSecret?.length ?? 0) > 0;
+        if (hasClientIdField !== hasClientSecretField) {
+            const message = "When overriding Google OAuth credentials, provide both the client ID and client secret together, or clear both fields together.";
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdField ? "clientSecret" : "clientId"],
+                message
+            });
+            return;
+        }
+        if (hasClientIdValue !== hasClientSecretValue) {
+            const message = "When overriding Google OAuth credentials, provide both the client ID and client secret together, or clear both fields together.";
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdValue ? "clientSecret" : "clientId"],
+                message
+            });
+        }
+    }),
+    modelSettings: z
+        .object({
+        forgeAgent: z
+            .object({
+            basicChat: z
+                .object({
+                connectionId: trimmedString.nullable().optional(),
+                model: trimmedString.optional()
+            })
+                .optional(),
+            wiki: z
+                .object({
+                connectionId: trimmedString.nullable().optional(),
+                model: trimmedString.optional()
+            })
+                .optional()
+        })
+            .optional()
+    })
+        .optional()
+});
+export const upsertAiModelConnectionSchema = z
+    .object({
+    id: trimmedString.optional(),
+    label: nonEmptyTrimmedString,
+    provider: aiModelProviderSchema,
+    authMode: aiModelAuthModeSchema.optional(),
+    baseUrl: trimmedString.optional(),
+    model: nonEmptyTrimmedString,
+    apiKey: trimmedString.optional(),
+    oauthSessionId: trimmedString.optional(),
+    enabled: z.boolean().default(true)
+})
+    .superRefine((value, context) => {
+    const authMode = value.authMode ??
+        (value.provider === "openai-codex" ? "oauth" : "api_key");
+    if (value.provider === "openai-codex" && authMode !== "oauth") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["authMode"],
+            message: "OpenAI Codex connections must use OAuth."
+        });
+    }
+    if (authMode === "api_key" &&
+        !value.id?.trim() &&
+        !value.apiKey?.trim()) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["apiKey"],
+            message: "API key is required for a new API-backed connection."
+        });
+    }
+    if (authMode === "oauth" &&
+        !value.id?.trim() &&
+        !value.oauthSessionId?.trim()) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["oauthSessionId"],
+            message: "OAuth session is required for a new OAuth-backed connection."
+        });
+    }
+});
+export const testAiModelConnectionSchema = z.object({
+    connectionId: trimmedString.optional(),
+    provider: aiModelProviderSchema.optional(),
+    baseUrl: trimmedString.optional(),
+    model: nonEmptyTrimmedString,
+    apiKey: trimmedString.optional()
+});
+export const submitOpenAiCodexOauthManualCodeSchema = z.object({
+    codeOrUrl: nonEmptyTrimmedString
+});
+export const createAiProcessorSchema = z.object({
+    surfaceId: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    promptFlow: trimmedString.default(""),
+    contextInput: trimmedString.default(""),
+    toolConfig: z.array(aiProcessorToolSchema).default([]),
+    agentIds: z.array(z.string().trim().min(1)).default([]),
+    agentConfigs: z.array(aiProcessorAgentConfigSchema).default([]),
+    triggerMode: aiProcessorTriggerModeSchema.default("manual"),
+    cronExpression: trimmedString.default(""),
+    machineAccess: aiProcessorMachineAccessSchema.default({
+        read: false,
+        write: false,
+        exec: false
+    }),
+    endpointEnabled: z.boolean().default(true)
+});
+export const updateAiProcessorSchema = z.object({
+    title: nonEmptyTrimmedString.optional(),
+    promptFlow: trimmedString.optional(),
+    contextInput: trimmedString.optional(),
+    toolConfig: z.array(aiProcessorToolSchema).optional(),
+    agentIds: z.array(z.string().trim().min(1)).optional(),
+    agentConfigs: z.array(aiProcessorAgentConfigSchema).optional(),
+    triggerMode: aiProcessorTriggerModeSchema.optional(),
+    cronExpression: trimmedString.optional(),
+    machineAccess: aiProcessorMachineAccessSchema.partial().optional(),
+    endpointEnabled: z.boolean().optional()
+});
+export const createAiProcessorLinkSchema = z.object({
+    surfaceId: nonEmptyTrimmedString,
+    sourceWidgetId: nonEmptyTrimmedString,
+    targetProcessorId: nonEmptyTrimmedString,
+    accessMode: aiProcessorAccessModeSchema.default("read"),
+    capabilityMode: aiProcessorCapabilityModeSchema.default("content"),
+    metadata: z.record(z.string(), z.unknown()).default({})
+});
+export const runAiProcessorSchema = z.object({
+    input: trimmedString.default(""),
+    context: z.record(z.string(), z.unknown()).default({}),
+    widgetSnapshots: z.record(z.string(), z.unknown()).default({})
+});
+export const createAiConnectorSchema = z.object({
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    kind: aiConnectorKindSchema.default("functor"),
+    homeSurfaceId: trimmedString.nullable().default(null),
+    endpointEnabled: z.boolean().default(true),
+    graph: z
+        .object({
+        nodes: z.array(aiConnectorNodeSchema).default([]),
+        edges: z.array(aiConnectorEdgeSchema).default([])
+    })
+        .default({ nodes: [], edges: [] })
+});
+export const updateAiConnectorSchema = z.object({
+    title: nonEmptyTrimmedString.optional(),
+    description: trimmedString.optional(),
+    kind: aiConnectorKindSchema.optional(),
+    homeSurfaceId: trimmedString.nullable().optional(),
+    endpointEnabled: z.boolean().optional(),
+    graph: z
+        .object({
+        nodes: z.array(aiConnectorNodeSchema).default([]),
+        edges: z.array(aiConnectorEdgeSchema).default([])
+    })
+        .optional()
+});
+export const runAiConnectorSchema = z.object({
+    userInput: trimmedString.default(""),
+    context: z.record(z.string(), z.unknown()).default({}),
+    boxSnapshots: z.record(z.string(), z.unknown()).default({}),
+    conversationId: trimmedString.nullable().default(null),
+    debug: z.boolean().default(false)
 });
 export const createAgentTokenSchema = z.object({
     label: nonEmptyTrimmedString,