forge-openclaw-plugin 0.2.23 → 0.2.25

package/dist/server/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,29 @@ 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",
+    "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 +1249,309 @@ export const microsoftCalendarAuthSettingsSchema = z.object({
     isReadyForSignIn: z.boolean(),
     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 forgeBoxCatalogEntrySchema = z.object({
+    boxId: nonEmptyTrimmedString,
+    surfaceId: trimmedString.nullable(),
+    routePath: trimmedString.nullable(),
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    category: nonEmptyTrimmedString,
+    capabilityModes: z.array(forgeBoxCapabilityModeSchema).default(["content"]),
+    toolAdapters: z.array(forgeBoxToolAdapterSchema).default([])
+});
+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_input",
+    "user_input",
+    "functor",
+    "chat",
+    "output"
+]);
+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(),
+        systemPrompt: trimmedString.optional(),
+        outputKey: trimmedString.optional(),
+        enabledToolKeys: z.array(nonEmptyTrimmedString).default([]),
+        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()
+    }))
+});
+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 +1781,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),
@@ -1452,6 +1794,7 @@ export const settingsPayloadSchema = z.object({
     calendarProviders: z.object({
         microsoft: microsoftCalendarAuthSettingsSchema
     }),
+    modelSettings: modelSettingsPayloadSchema,
     agents: z.array(agentIdentitySchema),
     agentTokens: z.array(agentTokenSummarySchema)
 });
@@ -2243,6 +2586,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({
@@ -2258,9 +2602,154 @@ export const updateSettingsSchema = z.object({
             redirectUri: trimmedString.optional()
         })
             .optional()
+    })
+        .optional(),
+    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)
+});
 export const createAgentTokenSchema = z.object({
     label: nonEmptyTrimmedString,
     agentLabel: nonEmptyTrimmedString.default("Forge Agent"),