openbot 0.4.7 → 0.5.5

package/src/services/plugins/model-registry.ts

@@ -0,0 +1,178 @@
+import {
+  DEFAULT_MARKETPLACE_REGISTRY_URL,
+  loadConfig,
+} from '../../app/config.js';
+import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
+import {
+  DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+  isCloudMode,
+} from '../../app/cloud-mode.js';
+import type { ConfigSchema, PluginDescriptor } from './domain.js';
+
+export type RegistryProviderCatalog = Record<
+  string,
+  {
+    label: string;
+    models: Array<{ id: string; label: string; description: string }>;
+  }
+>;
+
+export type ModelRegistry = {
+  providers?: RegistryProviderCatalog;
+};
+
+export type RegistryModelOption = {
+  value: string;
+  label: string;
+  description?: string;
+  provider: string;
+};
+
+let cachedRegistry: ModelRegistry | null = null;
+let cacheUrl: string | null = null;
+
+function getRegistryUrl(): string {
+  const { marketplaceRegistryUrl } = loadConfig();
+  return marketplaceRegistryUrl?.trim() || DEFAULT_MARKETPLACE_REGISTRY_URL;
+}
+
+export async function resolveModelRegistry(): Promise<ModelRegistry> {
+  const url = getRegistryUrl();
+  if (cachedRegistry && cacheUrl === url) return cachedRegistry;
+
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: 'application/json' },
+      signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok) {
+      throw new Error(`Registry HTTP ${res.status} ${res.statusText}`);
+    }
+    cachedRegistry = (await res.json()) as ModelRegistry;
+    cacheUrl = url;
+    return cachedRegistry;
+  } catch (err) {
+    console.warn(
+      '[model-registry] fetch failed:',
+      err instanceof Error ? err.message : err,
+    );
+    return { providers: {} };
+  }
+}
+
+export function listModelOptionsFromRegistry(registry: ModelRegistry): RegistryModelOption[] {
+  const providers = registry.providers ?? {};
+  const out: RegistryModelOption[] = [];
+
+  for (const [providerId, provider] of Object.entries(providers)) {
+    for (const model of provider.models ?? []) {
+      out.push({
+        value: `${providerId}/${model.id}`,
+        label: `${provider.label} — ${model.label}`,
+        description: model.description,
+        provider: providerId,
+      });
+    }
+  }
+
+  return out;
+}
+
+export async function listRegistryModelOptions(): Promise<RegistryModelOption[]> {
+  const registry = await resolveModelRegistry();
+  return listModelOptionsFromRegistry(registry);
+}
+
+export function listApiKeyProvidersFromRegistry(
+  registry: ModelRegistry,
+): Array<{ id: string; label: string }> {
+  const providers = registry.providers ?? {};
+  return Object.entries(providers).map(([id, provider]) => ({
+    id,
+    label: provider.label,
+  }));
+}
+
+function pickDefaultModelValue(options: RegistryModelOption[]): string | undefined {
+  if (options.length === 0) return undefined;
+  const values = options.map((option) => option.value);
+  const preferred = values.find((value) => value.startsWith('openai/'));
+  return preferred ?? values[0];
+}
+
+export function enrichOpenbotPluginDescriptor(
+  descriptor: PluginDescriptor,
+  modelOptions: RegistryModelOption[],
+): PluginDescriptor {
+  if (descriptor.id !== OPENBOT_PLUGIN_ID || !descriptor.configSchema) return descriptor;
+
+  const modelProperty = descriptor.configSchema.properties.model;
+  if (!modelProperty) return descriptor;
+
+  const values = modelOptions.map((option) => option.value);
+  const staticDefault =
+    typeof modelProperty.default === 'string' ? modelProperty.default : undefined;
+  const defaultModel =
+    staticDefault && values.includes(staticDefault)
+      ? staticDefault
+      : pickDefaultModelValue(modelOptions) ?? staticDefault;
+
+  const nextModelProperty: ConfigSchema['properties'][string] = {
+    ...modelProperty,
+    description: 'Model from the hosted marketplace registry.',
+  };
+
+  if (values.length > 0) {
+    nextModelProperty.enum = values;
+    nextModelProperty.options = modelOptions.map((option) => ({
+      label: option.label,
+      value: option.value,
+      description: option.description,
+    }));
+  }
+
+  if (defaultModel) {
+    nextModelProperty.default = defaultModel;
+  }
+
+  const { model: _model, authMode: _authMode, ...otherProperties } =
+    descriptor.configSchema.properties;
+
+  const cloudAuthModeProperty: ConfigSchema['properties'][string] = {
+    type: 'string',
+    description: 'Credits uses OpenBot platform billing. BYOK uses your own API keys.',
+    enum: ['credits', 'byok'],
+    default: DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+    options: [
+      {
+        label: 'Credits',
+        value: 'credits',
+        description: 'Use OpenBot platform credits.',
+      },
+      {
+        label: 'Bring your own key',
+        value: 'byok',
+        description: 'Use your own provider API keys.',
+      },
+    ],
+  };
+
+  const nextProperties: ConfigSchema['properties'] = isCloudMode()
+    ? {
+        authMode: cloudAuthModeProperty,
+        model: nextModelProperty,
+        ...otherProperties,
+      }
+    : {
+        model: nextModelProperty,
+        ...otherProperties,
+      };
+
+  return {
+    ...descriptor,
+    configSchema: {
+      ...descriptor.configSchema,
+      properties: nextProperties,
+    },
+  };
+}

package/src/services/plugins/registry.ts

@@ -1,16 +1,11 @@
-import fs from 'node:fs';
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import type { Plugin } from './types.js';
-import { openbotPlugin } from '../../plugins/openbot/index.js';
-import { bashPlugin } from '../../plugins/bash/index.js';
 import { storagePlugin } from '../../plugins/storage/index.js';
-import { approvalPlugin } from '../../plugins/approval/index.js';
-import { memoryPlugin } from '../../plugins/memory/index.js';
-import { delegationPlugin } from '../../plugins/delegation/index.js';
-import { uiPlugin } from '../../plugins/ui/index.js';
 import { pluginManagerPlugin } from '../../plugins/plugin-manager/index.js';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
+import { DEFAULT_PLUGINS_DIR, getBaseDir } from '../../app/config.js';
 import {
   invalidatePlugin as clearResolvedPluginEntry,
   loadedCommunityPlugins,
@@ -20,13 +15,7 @@ import {
 let pluginsDir: string | null = null;
 
 const BUILT_IN: Record<string, Plugin> = {
-  [openbotPlugin.id]: openbotPlugin,
-  [bashPlugin.id]: bashPlugin,
   [storagePlugin.id]: storagePlugin,
-  [approvalPlugin.id]: approvalPlugin,
-  [memoryPlugin.id]: memoryPlugin,
-  [delegationPlugin.id]: delegationPlugin,
-  [uiPlugin.id]: uiPlugin,
   [pluginManagerPlugin.id]: pluginManagerPlugin,
 };
 
@@ -71,24 +60,18 @@ export function initPlugins(dir?: string) {
   if (dir) {
     pluginsDir = dir;
   } else {
-    const config = loadConfig();
-    const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-    pluginsDir = path.join(resolvePath(baseDir), DEFAULT_PLUGINS_DIR);
+    pluginsDir = path.join(getBaseDir(), DEFAULT_PLUGINS_DIR);
   }
 }
 
 /**
  * Resolve a Plugin by id. The id is either:
- *   - a built-in id (e.g. "openbot", "bash"), or
- *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
+ *   - a built-in id (e.g. "storage", "plugin-manager"), or
+ *   - an npm package name (e.g. "@meetopenbot/openbot"),
  *     in which case the folder layout is `plugins/<id>/dist/index.js`.
  */
 export async function resolvePlugin(id: string): Promise<Plugin | null> {
   if (resolvedPluginCache.has(id)) return resolvedPluginCache.get(id)!;
-  if (BUILT_IN[id]) {
-    resolvedPluginCache.set(id, BUILT_IN[id]);
-    return BUILT_IN[id];
-  }
 
   if (!pluginsDir) {
     initPlugins();
@@ -97,29 +80,33 @@ export async function resolvePlugin(id: string): Promise<Plugin | null> {
 
   const distPath = path.join(pluginsDir, id, 'dist', 'index.js');
 
-  if (!fs.existsSync(distPath)) {
-    console.warn(`[plugins] Plugin "${id}" not found at ${distPath}.`);
-    return null;
+  if (existsSync(distPath)) {
+    try {
+      const module = await import(pathToFileURL(distPath).href);
+      const parsed = parsePluginModule(module as Record<string, unknown>);
+      if (!parsed) {
+        console.warn(`[plugins] Plugin "${id}" at ${distPath} has no recognizable export.`);
+      } else {
+        const plugin: Plugin = { id, ...parsed, name: parsed.name || id };
+        resolvedPluginCache.set(id, plugin);
+        if (!loadedCommunityPlugins.has(id)) {
+          console.log(`[plugins] Loaded plugin "${id}" from ${distPath}`);
+          loadedCommunityPlugins.add(id);
+        }
+        return plugin;
+      }
+    } catch (e) {
+      console.warn(`[plugins] Failed to load plugin "${id}" from ${distPath}:`, e);
+    }
   }
 
-  try {
-    const module = await import(pathToFileURL(distPath).href);
-    const parsed = parsePluginModule(module as Record<string, unknown>);
-    if (!parsed) {
-      console.warn(`[plugins] Plugin "${id}" at ${distPath} has no recognizable export.`);
-      return null;
-    }
-    const plugin: Plugin = { id, ...parsed, name: parsed.name || id };
-    resolvedPluginCache.set(id, plugin);
-    if (!loadedCommunityPlugins.has(id)) {
-      console.log(`[plugins] Loaded community plugin "${id}" from ${distPath}`);
-      loadedCommunityPlugins.add(id);
-    }
-    return plugin;
-  } catch (e) {
-    console.warn(`[plugins] Failed to load plugin "${id}" from ${distPath}:`, e);
-    return null;
+  if (BUILT_IN[id]) {
+    resolvedPluginCache.set(id, BUILT_IN[id]);
+    return BUILT_IN[id];
   }
+
+  console.warn(`[plugins] Plugin "${id}" not found at ${distPath}.`);
+  return null;
 }
 
 /** Drop a single id from the in-memory cache (e.g. after fresh install). */

package/src/services/plugins/service.ts

@@ -5,8 +5,8 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import {
   DEFAULT_PLUGINS_DIR,
-  DEFAULT_BASE_DIR,
   DEFAULT_MARKETPLACE_REGISTRY_URL,
+  getBaseDir,
   loadConfig,
   resolvePath,
 } from '../../app/config.js';
@@ -104,7 +104,9 @@ export function parseMarketplaceRegistryJson(data: unknown): MarketplaceRegistry
       if (!Array.isArray(pluginsRaw)) throw new Error(`agents[${i}].plugins must be an array`);
       const plugins: PluginRef[] = pluginsRaw.map((p, j) => {
         if (!isRecord(p) || typeof p.id !== 'string' || !p.id) {
-          throw new Error(`agents[${i}].plugins[${j}]: expected { "id": string, "config"?: object }`);
+          throw new Error(
+            `agents[${i}].plugins[${j}]: expected { "id": string, "config"?: object }`,
+          );
         }
         const ref: PluginRef = { id: p.id };
         if (p.config !== undefined) {
@@ -202,11 +204,7 @@ export async function resolveMarketplaceAgentList(): Promise<MarketplaceAgentLis
   return registry.agents;
 }
 
-const getPluginsDir = (): string => {
-  const config = loadConfig();
-  const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-  return path.join(baseDir, DEFAULT_PLUGINS_DIR);
-};
+const getPluginsDir = (): string => path.join(getBaseDir(), DEFAULT_PLUGINS_DIR);
 
 /**
  * Lifecycle for community-built plugins distributed via npm.
@@ -267,17 +265,13 @@ export const pluginService = {
         console.warn(`[plugins] Failed to run npm install in ${finalPath}:`, e);
       }
 
-      const pkgJson = JSON.parse(
-        await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'),
-      );
+      const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
 
       invalidatePlugin(packageName);
       return { name: pkgJson.name, version: pkgJson.version };
     } catch (error) {
       console.error(`[plugins] Failed to install ${packageName}:`, error);
-      throw new Error(
-        `Failed to install plugin ${packageName}: ${(error as Error).message}`,
-      );
+      throw new Error(`Failed to install plugin ${packageName}: ${(error as Error).message}`);
     } finally {
       await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
     }
@@ -303,10 +297,7 @@ export const pluginService = {
       }
     } catch (error) {
       console.error(`[plugins] Failed to uninstall ${packageName}:`, error);
-      throw new Error(
-        `Failed to uninstall plugin ${packageName}: ${(error as Error).message}`,
-      );
+      throw new Error(`Failed to uninstall plugin ${packageName}: ${(error as Error).message}`);
     }
   },
 };
-

package/src/services/plugins/types.ts

@@ -5,8 +5,8 @@ import { AgentDetails, ConfigSchema, Storage } from './domain.js';
 /**
  * Reference to a plugin from an agent's AGENT.md frontmatter.
  *
- * The `id` is either a built-in plugin id (e.g. `openbot`, `bash`) or an npm
- * package name (e.g. `openbot-plugin-codex`, `@scope/openbot-plugin-foo`).
+ * The `id` is either a built-in plugin id (e.g. `storage`, `plugin-manager`) or
+ * an npm package name (e.g. `@meetopenbot/openbot`, `openbot-plugin-foo`).
  * Each entry may carry plugin-specific `config`.
  */
 export interface PluginRef {
@@ -20,6 +20,38 @@ export interface ToolDefinition {
   inputSchema: unknown;
 }
 
+/** Options for delegated / nested agent runs via PluginHost.runAgent. */
+export interface RunAgentHostOptions {
+  runId: string;
+  agentId: string;
+  event: OpenBotEvent;
+  channelId: string;
+  threadId?: string;
+  persistEvents?: boolean;
+  publicBaseUrl?: string;
+  onEvent: (event: OpenBotEvent, state?: OpenBotState) => Promise<void>;
+}
+
+/** Host capabilities exposed to community / external agent runtime plugins. */
+export interface PluginHost {
+  runAgent: (options: RunAgentHostOptions) => Promise<void>;
+  isCloudSystemAgent: (agentId: string) => boolean;
+  isCloudMode: () => boolean;
+  parseOpenbotAuthMode: (value: unknown) => 'credits' | 'byok';
+  resolveModelRegistry: () => ReturnType<
+    typeof import('./model-registry.js').resolveModelRegistry
+  >;
+  listApiKeyProvidersFromRegistry: (
+    registry: Awaited<ReturnType<PluginHost['resolveModelRegistry']>>,
+  ) => Array<{ id: string; label: string }>;
+  saveConfig: (patch: Record<string, unknown>) => void;
+  getBaseDir: () => string;
+  resolvePath: (p: string) => string;
+  orchestratorAgentId: string;
+  openbotPluginId: string;
+  defaultCloudAuthMode: 'credits' | 'byok';
+}
+
 /**
  * Context passed to a Plugin factory at runtime.
  *
@@ -37,6 +69,8 @@ export interface PluginContext {
   publicBaseUrl: string;
   /** Signal that fires when this run is stopped; runtimes should pass it to long-running calls. */
   abortSignal?: AbortSignal;
+  /** Platform hooks for external runtime plugins (delegation, cloud auth, config). */
+  host: PluginHost;
 }
 
 /**

package/src/services/todo/types.ts

@@ -0,0 +1,12 @@
+export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled';
+
+export type TodoItem = {
+  id: string;
+  content: string;
+  status: TodoStatus;
+};
+
+export type TodoList = {
+  items: TodoItem[];
+  updatedAt: string;
+};

package/dist/agents/openbot/index.js

@@ -1,76 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { openBotRuntime } from './runtime.js';
-import { shellPlugin, shellToolDefinitions } from './tools/shell.js';
-import { mcpPlugin, mcpToolDefinitions } from './tools/mcp.js';
-import { uiPlugin, uiToolDefinitions } from './tools/ui.js';
-import { delegationPlugin, delegationToolDefinitions } from './tools/delegation.js';
-import { storageToolDefinitions } from './tools/storage.js';
-import { approvalPlugin } from './middleware/approval.js';
-import { DEFAULT_OPENBOT_APPROVAL_RULES, OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
-const OPENBOT_ICON_DATA_URL = (() => {
-    try {
-        const svg = readFileSync(new URL('../../assets/icon.svg', import.meta.url), 'utf-8').trim();
-        if (!svg.startsWith('<svg'))
-            return undefined;
-        return `data:image/svg+xml;base64,${Buffer.from(svg, 'utf-8').toString('base64')}`;
-    }
-    catch {
-        return undefined;
-    }
-})();
-const composeMelonyPlugin = (...plugins) => {
-    return (builder) => {
-        for (const plugin of plugins) {
-            plugin(builder);
-        }
-    };
-};
-/**
- * OpenBot — the first-party orchestrator agent package.
- *
- * Treats the bus as a peer environment: registers a runtime that owns
- * `agent:invoke`, exposes a curated tool set (delegation, storage, MCP, shell,
- * UI widgets), and wires approval middleware for protected actions.
- *
- * Other agents (Codex, Claude Code, Gemini, custom Coder/Researcher) are
- * separate AgentPackages with their own runtime + tool composition.
- */
-export const openBotAgentPackage = {
-    id: 'openbot',
-    name: 'OpenBot',
-    description: 'First-party orchestration agent for OpenBot. Coordinates other agents via handoff and delegation.',
-    image: OPENBOT_ICON_DATA_URL,
-    defaultInstructions: OPENBOT_SYSTEM_PROMPT,
-    configSchema: {
-        type: 'object',
-        properties: {
-            model: {
-                type: 'string',
-                description: 'Provider model string, e.g. openai/gpt-4o-mini, anthropic/claude-3-5-sonnet-20240620',
-                default: 'openai/gpt-4o-mini',
-            },
-        },
-    },
-    factory: ({ agentDetails, config, storage }) => {
-        const model = typeof config.model === 'string' && config.model
-            ? config.model
-            : 'openai/gpt-4o-mini';
-        const toolDefinitions = {
-            ...delegationToolDefinitions,
-            ...storageToolDefinitions,
-            ...mcpToolDefinitions,
-            ...shellToolDefinitions,
-            // Re-enable when the dashboard renders widgets:
-            // ...uiToolDefinitions,
-        };
-        const systemPrompt = agentDetails.instructions || OPENBOT_SYSTEM_PROMPT;
-        return composeMelonyPlugin(openBotRuntime({
-            model,
-            system: systemPrompt,
-            storage,
-            toolDefinitions,
-        }), approvalPlugin({ rules: DEFAULT_OPENBOT_APPROVAL_RULES }), delegationPlugin(), shellPlugin(), mcpPlugin(), uiPlugin());
-    },
-};
-// Suppress unused warning while UI widget tools are not wired into the LLM tool list.
-void uiToolDefinitions;

package/dist/agents/openbot/middleware/approval.js

@@ -1,132 +0,0 @@
-import { storageService } from '../../../services/storage.js';
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
-    ? value
-    : {};
-const getApprovalsFromState = (state) => {
-    const source = state.threadDetails?.state ?? state.channelDetails?.state;
-    const stateRecord = asRecord(source);
-    return asRecord(stateRecord.approvals);
-};
-const persistApprovals = async (state, approvals) => {
-    if (state.threadId) {
-        await storageService.patchThreadState({
-            channelId: state.channelId,
-            threadId: state.threadId,
-            state: { approvals },
-        });
-        return;
-    }
-    await storageService.patchChannelState({
-        channelId: state.channelId,
-        state: { approvals },
-    });
-};
-export const approvalPlugin = (options = {}) => (builder) => {
-    const rules = options.rules || [];
-    for (const rule of rules) {
-        builder.on(rule.action, async function* (event, context) {
-            const meta = asRecord(event.meta);
-            if (meta.approvalStatus === 'approved')
-                return;
-            const eventData = asRecord(event.data);
-            const eventMeta = meta;
-            const approvalId = `approval_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-            const widgetId = `widget_${approvalId}`;
-            const executeEvent = rule.executeEvent || rule.action;
-            const denyEvent = rule.denyEvent || `${rule.action}:result`;
-            const denyData = rule.denyData || {};
-            const hiddenKeys = new Set(rule.hiddenKeys || []);
-            const detailKeys = rule.detailKeys || Object.keys(eventData);
-            const details = detailKeys
-                .filter((key) => !hiddenKeys.has(key))
-                .map((key) => `- ${key}: ${String(eventData[key] ?? '')}`)
-                .join('\n');
-            const pendingApprovals = getApprovalsFromState(context.state);
-            pendingApprovals[approvalId] = {
-                id: approvalId,
-                action: rule.action,
-                executeEvent,
-                denyEvent,
-                denyData,
-                payload: eventData,
-                meta: eventMeta,
-                message: rule.message || `Approval required for ${rule.action}.`,
-                createdAt: new Date().toISOString(),
-                status: 'pending',
-            };
-            await persistApprovals(context.state, pendingApprovals);
-            yield {
-                type: 'client:ui:widget',
-                data: {
-                    kind: 'choice',
-                    widgetId,
-                    title: 'Approval Required',
-                    body: `${rule.message || 'A protected action requires approval.'}${details ? `\n\n${details}` : ''}`,
-                    metadata: { type: 'approval:request', approvalId, action: rule.action },
-                    actions: [
-                        { id: 'approve', label: 'Approve', variant: 'primary' },
-                        { id: 'deny', label: 'Deny', variant: 'danger' },
-                    ],
-                },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-            yield {
-                type: 'agent:output',
-                data: { content: `Waiting for approval before running \`${rule.action}\`.` },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-            context.suspend();
-        });
-    }
-    builder.on('client:ui:widget:response', async function* (event, context) {
-        const metadata = asRecord(event.data?.metadata);
-        if (metadata.type !== 'approval:request')
-            return;
-        const approvalId = String(metadata.approvalId || '');
-        if (!approvalId)
-            return;
-        const approvals = getApprovalsFromState(context.state);
-        const approval = approvals[approvalId];
-        if (!approval || approval.status !== 'pending') {
-            yield {
-                type: 'agent:output',
-                data: { content: 'Approval request not found or already resolved.' },
-                meta: { ...(event.meta || {}), agentId: context.state.agentId },
-            };
-            return;
-        }
-        const approved = event.data.actionId === 'approve';
-        approvals[approvalId] = {
-            ...approval,
-            status: approved ? 'approved' : 'denied',
-        };
-        await persistApprovals(context.state, approvals);
-        if (approved) {
-            yield {
-                type: approval.executeEvent,
-                data: approval.payload,
-                meta: {
-                    ...(approval.meta || {}),
-                    approvalId,
-                    approvalStatus: 'approved',
-                },
-            };
-            return;
-        }
-        yield {
-            type: approval.denyEvent,
-            data: {
-                success: false,
-                approved: false,
-                error: 'Action denied by user approval.',
-                ...approval.denyData,
-            },
-            meta: { ...(approval.meta || {}), approvalId },
-        };
-        yield {
-            type: 'agent:output',
-            data: { content: 'Action denied by user approval.' },
-            meta: { ...(event.meta || {}), agentId: context.state.agentId },
-        };
-    });
-};