@nocobase/app-plugin-agents 0.1.0-beta.9 → 1.0.0-beta.15

package/dist/server/routes/chat.js

@@ -1,10 +1,13 @@
 /**
- * The chat API, mounted at `/api/agents` (`CHAT_ROUTES` in `shared/conversations`), and the agent presets at
- * `/api/agents/presets`. Every route is behind the guard (a signed-in person and their authorization context). A
- * conversation is its owner's alone: the service answers 404 to anyone else, whatever they may manage. Changing the
- * team's default chat agent needs `agents.agents` manage; reading presets needs `agents.agents` read.
+ * The chat API, mounted at `/api/agents` (`CHAT_ROUTES` in `shared/conversations`). Every route is behind the guard (a
+ * signed-in person and their authorization context). A conversation is its owner's alone: the service answers 404 to
+ * anyone else, whatever they may manage. Changing the team's default chat agent needs `agents.agents` manage.
  */
 import { apiErrorResponse, apiErrorResponses, apiValidator, cliRoute, dataResponse, describeRoute, emptyResponse, listResponse, } from '@nocobase/app-server/router';
+import { createUIMessageStreamResponse } from 'ai';
+import { appUIMessageMetadataSchema, appUIToolApprovalInputSchema, } from '../../shared/online-agent.js';
+import { cleanTitle } from '../core/conversations/titles.js';
+import { jsonSafe } from '../online/agent/messages/json.js';
 import { bodyLimit } from 'hono/body-limit';
 import { z } from 'zod';
 import { CHAT_ATTACHMENT_SIZE_MAX, CHAT_ATTACHMENTS_PER_MESSAGE_MAX, CONVERSATION_SOURCE_PATTERN, CONVERSATION_TITLE_MAX, MESSAGE_CONTENT_MAX, } from '../../shared/conversations.js';
@@ -14,59 +17,100 @@ import { fileTooLarge } from '../core/conversations/attachments.js';
 import { forbidden, invalid } from '../kernel/errors.js';
 import { decodePageToken, domainRouter, encodePageToken, } from '../kernel/http.js';
 import { personOrRunSecurity, tags } from './openapi.js';
-import { AgentParams, AgentPresetSchema, AgentSchema, ChatAgentSchema, ChatSettingsSchema, ChatAttachmentContentQuery, ChatAttachmentParams, ChatDefaultAgentSchema, ConversationDetailSchema, ConversationListQuerySchema, ConversationMessageSchema, ConversationParams, ConversationSummarySchema, MessageAttachmentSchema, MessageListQuerySchema, PageTokenMetaSchema, SendMessageResultSchema, SeqPageMetaSchema, } from './schemas.js';
+import { ChatAgentSchema, ChatSettingsSchema, ChatAttachmentContentQuery, ChatAttachmentParams, ChatDefaultAgentSchema, ConversationDetailSchema, ConversationListQuerySchema, ConversationParams, ConversationSummarySchema, MessageAttachmentSchema, MessageListQuerySchema, PageTokenMetaSchema, SeqPageMetaSchema, } from './schemas.js';
 const noConversation = apiErrorResponse(404, "The conversation does not exist or is not the caller's (`CONVERSATION_NOT_FOUND`).");
 const conversationConflict = (when) => apiErrorResponse(400, `${when} (\`CONVERSATION_CONFLICT\`).`);
 const MessagePosition = z.object({ before: z.number().int().min(1) });
-const CreateSchema = z.strictObject({
+const ConfigInput = z.strictObject({
     agentId: z.string().min(1).max(64).optional(),
+    scope: z.array(z.string()).optional(),
+    thinking: z.string().optional(),
+    context: z
+        .strictObject({
+        variable: z.json().optional(),
+    })
+        .optional(),
+});
+const ConfigOutput = z.object({
+    agentId: z.string().optional(),
+    selectedModel: z
+        .object({ modelService: z.string(), model: z.string() })
+        .nullable(),
+    scope: z.array(z.string()),
+    model: z.array(z.string()),
+    thinking: z.string().optional(),
+    tool: z.array(z.string()),
+    toolVersions: z.record(z.string(), z.string()),
+    systemPrompt: z.string(),
+    variable: z.json().optional(),
+});
+const SelectedModel = z.strictObject({
+    modelService: z.string().min(1),
+    model: z.string().min(1),
+});
+const CreateSchema = z.strictObject({
+    agentId: z
+        .string()
+        .min(1)
+        .max(64)
+        .optional()
+        .describe('The agent to start the conversation with.'),
     title: z
         .string()
         .max(CONVERSATION_TITLE_MAX * 2)
-        .optional(),
-    source: z.string().regex(CONVERSATION_SOURCE_PATTERN).optional(),
-    model: z
-        .strictObject({
-        modelService: z.string().min(1).max(100),
-        model: z.string().min(1).max(200),
-    })
-        .nullable()
         .optional()
-        .meta({
-        description: "An online agent: the entry of its list (`ChatAgent.models`) to answer with; the agent's default when left out.",
-    }),
+        .describe('The conversation title.'),
+    source: z
+        .string()
+        .regex(CONVERSATION_SOURCE_PATTERN)
+        .optional()
+        .describe('The source context associated with this conversation.'),
+    showInChatList: z
+        .boolean()
+        .optional()
+        .describe('Include this conversation in the default chat list (default true).'),
+    config: ConfigInput.optional().describe('Explicit ordinary OnlineAgent configuration overrides for the new conversation.'),
+    selectedModel: SelectedModel.optional().describe('Native model selection as modelService and model; omit for a Runner agent.'),
 });
 const PatchSchema = z.strictObject({
     title: z
         .string()
         .max(CONVERSATION_TITLE_MAX * 2)
-        .optional(),
-    archived: z.boolean().optional(),
-    model: z
+        .optional()
+        .describe('The conversation title.'),
+    archived: z
+        .boolean()
+        .optional()
+        .describe('Whether to archive the conversation.'),
+});
+const NativeSendSchema = z.strictObject({
+    message: z
         .strictObject({
-        modelService: z.string().min(1).max(100),
-        model: z.string().min(1).max(200),
+        id: z.string().min(1).max(64),
+        role: z.literal('user'),
+        parts: z
+            .array(z.strictObject({
+            type: z.literal('text'),
+            text: z.string().max(MESSAGE_CONTENT_MAX * 2),
+        }))
+            .max(20),
     })
-        .nullable()
-        .optional(),
-});
-const SendSchema = z.strictObject({
-    content: z
-        .string()
-        .max(MESSAGE_CONTENT_MAX * 2)
-        .meta({
-        description: 'Markdown; empty only when files are sent.',
-    }),
-    context: PageContextSchema.optional(),
-    clientId: z.string().min(1).max(100).optional(),
+        .describe('The current SDK user message with id, role user and text parts.'),
     attachmentIds: z
         .array(z.string().min(1).max(64))
         .max(CHAT_ATTACHMENTS_PER_MESSAGE_MAX)
-        .optional()
-        .meta({
-        description: `The caller's uploads not sent yet (\`POST /api/agents/chatAttachments\`), at most ${CHAT_ATTACHMENTS_PER_MESSAGE_MAX}, sent with the message in this order.`,
-    }),
+        .optional(),
+    context: PageContextSchema.optional(),
+    selectedModel: SelectedModel.optional(),
 });
+const SendSchema = NativeSendSchema;
+const NativeMessageSchema = z.object({
+    id: z.string(),
+    role: z.enum(['user', 'assistant', 'system']),
+    metadata: appUIMessageMetadataSchema,
+    parts: z.array(z.json()),
+});
+const ApprovalSchema = appUIToolApprovalInputSchema;
 /** A multipart body of one file, as `file`. */
 const singleFileBody = {
     required: true,
@@ -75,7 +119,13 @@ const singleFileBody = {
             schema: {
                 type: 'object',
                 required: ['file'],
-                properties: { file: { type: 'string', format: 'binary' } },
+                properties: {
+                    file: {
+                        type: 'string',
+                        format: 'binary',
+                        description: 'The file to upload for the conversation.',
+                    },
+                },
             },
         },
     },
@@ -103,24 +153,6 @@ function contentHeaders(attachment, download) {
     };
 }
 const noAttachment = apiErrorResponse(404, 'The file does not exist, or the caller may not read it (`NOT_FOUND`).');
-const StartSchema = z.strictObject({
-    source: z.string().regex(CONVERSATION_SOURCE_PATTERN),
-    text: z
-        .string()
-        .min(1)
-        .max(MESSAGE_CONTENT_MAX * 2),
-    agentId: z.string().min(1).max(64).optional(),
-    title: z
-        .string()
-        .max(CONVERSATION_TITLE_MAX * 2)
-        .optional(),
-    context: PageContextSchema.optional(),
-    clientId: z.string().min(1).max(100).optional(),
-});
-const CopySchema = z.strictObject({
-    name: z.string().max(400).optional(),
-    makeDefault: z.boolean().optional(),
-});
 /**
  * `guard` authenticates the request and sets `caller`; the route contribution passes the real one, tests a fake.
  * `personOrRun` also takes a run token (setting `caller.run`), for reading a conversation's files; `guard` by default.
@@ -129,6 +161,12 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
     const router = domainRouter();
     const { conversations, chat } = services;
     const me = (context) => context.get('caller').userId;
+    const trusted = (context) => {
+        const value = context.get('caller').onlineContext;
+        if (!value)
+            throw forbidden('Trusted entry credentials are required.');
+        return value;
+    };
     const conversationParam = apiValidator('param', ConversationParams);
     const conversationId = (context) => context.req.param('conversationId') ?? '';
     router.get('/conversations', guard, describeRoute({
@@ -170,9 +208,12 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
         operationId: 'agentsCreateConversation',
         ...cliRoute({
             command: 'conversation create',
-            flags: { agentId: { name: 'agent' } },
+            flags: {
+                agentId: { name: 'agent' },
+                showInChatList: { name: 'show-in-chat-list' },
+            },
         }),
-        description: "With the given agent, or the caller's default chat agent when none is named; for an online agent, `model` chooses one of its `models` to answer with (400, `metadata.reason` `MODEL_NOT_LISTED`, for any other).",
+        description: 'Creates an OnlineAgent session without sending input. Configuration defaults are resolved once; original model columns remain authoritative.',
         responses: {
             201: dataResponse(ConversationDetailSchema, 'Created.'),
             400: conversationConflict('No chat agent is available'),
@@ -180,24 +221,28 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
             ...apiErrorResponses,
         },
     }), apiValidator('json', CreateSchema), async (context) => context.json({
-        data: await conversations.create(me(context), context.req.valid('json')),
+        data: await (async () => {
+            const request = context.req.valid('json');
+            const title = request.title === undefined
+                ? undefined
+                : cleanTitle(request.title);
+            if (title && title.length > CONVERSATION_TITLE_MAX)
+                throw invalid('The conversation title is too long.');
+            if (request.source &&
+                request.source !== 'panel' &&
+                !conversations.sources.has(request.source))
+                throw invalid('Unknown conversation source.');
+            const agent = await services.onlineAgent.realtime(trusted(context), {
+                ...request.config,
+                ...(request.agentId ? { agentId: request.agentId } : {}),
+                selectedModel: request.selectedModel,
+                source: request.source ?? 'panel',
+                title: title?.text || undefined,
+                showInChatList: request.showInChatList,
+            }, 'http');
+            return conversations.get(me(context), agent.sessionId);
+        })(),
     }, 201));
-    router.post('/conversations/start', guard, describeRoute({
-        tags,
-        summary: 'Start a conversation with its first message',
-        operationId: 'agentsStartConversation',
-        // UI-only: the pages' buttons, with page context; `conversation create` and `conversation message send` do it from the command line.
-        ...cliRoute(false),
-        description: "A new conversation from a place the application registered (`source`), with its first message, which wakes the agent. What the application's buttons call.",
-        responses: {
-            200: dataResponse(SendMessageResultSchema),
-            400: conversationConflict('No chat agent is available'),
-            404: apiErrorResponse(404, 'The agent does not exist (`AGENT_NOT_FOUND`).'),
-            ...apiErrorResponses,
-        },
-    }), apiValidator('json', StartSchema), async (context) => context.json({
-        data: await conversations.start(me(context), context.req.valid('json')),
-    }));
     router.get('/conversations/:conversationId', guard, describeRoute({
         tags,
         summary: 'Get a conversation',
@@ -217,9 +262,8 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
     }));
     router.patch('/conversations/:conversationId', guard, describeRoute({
         tags,
-        summary: 'Rename, archive or choose the model of a conversation',
+        summary: 'Rename or archive a conversation',
         operationId: 'agentsUpdateConversation',
-        description: "`model` picks one of the online conversation's `models` for its next runs (null: the agent's default); 400 `INVALID_REQUEST` with `reason: MODEL_NOT_LISTED` when the agent does not list it.",
         ...cliRoute({
             command: 'conversation update',
             args: ['conversationId'],
@@ -244,31 +288,45 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
                 conversationId: { name: 'conversation' },
                 pageSize: { name: 'limit' },
             },
-            columns: ['seq', 'role', 'content.content', 'createdAt'],
+            columns: ['metadata.seq', 'role', 'parts', 'metadata.createdAt'],
         }),
-        description: 'Newest page first, each page in order; `after` reads only what arrived since a `seq`, and a page token the page before.',
+        description: 'Newest page first, each page in order; after reads newly inserted sequences and pageToken reads older pages. Native ids rereads current messages after revision notifications, including updates at unchanged sequences.',
         responses: {
-            200: listResponse(ConversationMessageSchema, SeqPageMetaSchema),
+            200: listResponse(NativeMessageSchema, SeqPageMetaSchema),
             404: noConversation,
             ...apiErrorResponses,
         },
     }), conversationParam, apiValidator('query', MessageListQuerySchema), async (context) => {
-        const { after, pageSize, pageToken } = context.req.valid('query');
+        const { after, pageSize, pageToken, ids } = context.req.valid('query');
         const before = pageToken === undefined
             ? undefined
             : decodePageToken(pageToken, MessagePosition).before;
-        const page = await conversations.messages(me(context), context.req.valid('param').conversationId, {
-            ...(before === undefined ? {} : { before }),
-            ...(after === undefined || before !== undefined ? {} : { after }),
+        const agent = await services.onlineAgent.realtime(trusted(context), {
+            sessionId: conversationId(context),
+        });
+        const wanted = ids?.split(',');
+        if (wanted &&
+            (wanted.length > 100 || wanted.some((id) => !id || id.length > 100)))
+            throw invalid('Select at most 100 valid message IDs.');
+        const page = await agent.messages({
+            ids: wanted,
+            before,
+            after: before === undefined ? after : undefined,
             limit: pageSize,
         });
-        const first = page.items[0];
         return context.json({
             data: page.items,
             meta: {
                 lastSeq: page.lastSeq,
-                ...(page.hasMore && first
-                    ? { nextPageToken: encodePageToken({ before: first.seq }) }
+                ...(page.nextAfter !== undefined
+                    ? { nextAfter: page.nextAfter }
+                    : {}),
+                ...(page.hasMore && after === undefined && page.items[0]
+                    ? {
+                        nextPageToken: encodePageToken({
+                            before: page.items[0].metadata.seq,
+                        }),
+                    }
                     : {}),
             },
         });
@@ -279,12 +337,13 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
         operationId: 'agentsSendConversationMessage',
         ...cliRoute({
             command: 'conversation message send',
+            bodyFile: 'file',
             args: ['conversationId'],
             flags: {
                 conversationId: { name: 'conversation' },
-                content: { contentFile: true, alias: 'm' },
+                message: { alias: 'm' },
                 context: { hidden: true },
-                clientId: { hidden: true },
+                selectedModel: { hidden: true },
             },
             uploads: {
                 attach: {
@@ -296,19 +355,100 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
                 },
             },
             examples: [
-                'conversation message send <conversation> -m "What is left on PM-12?"',
-                'conversation message send <conversation> -m "See the log" --attach build.log',
+                'conversation message send <conversation> --file current-user-message.json',
+                'conversation message send <conversation> --file current-user-message.json --attach build.log',
             ],
         }),
-        description: "Adds the caller's message and hands it to the conversation's agent: a new run, or the open one. The answer arrives as messages later; `run` says what happened to the agent. `attachmentIds` sends the caller's uploads with it; any other id answers 400 and nothing is sent.",
+        description: 'Native input accepts only the current SDK user message with text parts and authorized attachmentIds, returning a standard UI message stream. Server metadata, history, tools and config are not writable here. Runner uses the same input and standard stream; only saved source records are projected. Busy input is refused. A timeout means outcome unknown: reconcile history and execution, never automatically resend.',
         responses: {
-            201: dataResponse(SendMessageResultSchema, 'Created.'),
+            200: {
+                description: 'Native AI SDK UI message stream. Finish closes this response; query execution for durable business state.',
+                content: { 'text/event-stream': { schema: { type: 'string' } } },
+            },
             404: noConversation,
             ...apiErrorResponses,
         },
-    }), conversationParam, apiValidator('json', SendSchema), async (context) => context.json({
-        data: await conversations.send(me(context), context.req.valid('param').conversationId, context.req.valid('json')),
-    }, 201));
+    }), conversationParam, apiValidator('json', SendSchema), async (context) => {
+        const id = context.req.valid('param').conversationId;
+        const request = context.req.valid('json');
+        const text = request.message.parts.map((part) => part.text).join('\n');
+        if ([...text].length > MESSAGE_CONTENT_MAX)
+            throw invalid('The message is too long.');
+        if (!text.trim() && !request.attachmentIds?.length)
+            throw invalid('A message or attachment is required.');
+        const workContext = request.context
+            ? await conversations.contextKinds.resolve(services.tx.read(), me(context), request.context)
+            : undefined;
+        const actor = trusted(context);
+        const agent = await services.onlineAgent.realtime({
+            ...actor,
+            ...(workContext ? { business: jsonSafe(workContext) } : {}),
+        }, { sessionId: id });
+        const parts = request.message.parts;
+        await agent.send([{ role: 'user', content: parts }], {
+            attachmentIds: [[...(request.attachmentIds ?? [])]],
+            clientId: request.message.id,
+            messageId: request.message.id,
+            selectedModel: request.selectedModel,
+            workContext,
+        });
+        const stream = await agent.receive();
+        if (!stream)
+            throw invalid('The accepted response requires history reconciliation.');
+        return createUIMessageStreamResponse({
+            stream,
+            headers: {
+                'Cache-Control': 'private, no-store',
+                'x-online-agent-recovery': services.onlineAgent.recovery,
+            },
+        });
+    });
+    router.post('/conversations/:conversationId/approval', guard, describeRoute({
+        tags,
+        summary: 'Respond to a native SDK tool approval',
+        operationId: 'agentsRespondConversationApproval',
+        ...cliRoute(false),
+        description: 'Only the SDK approval response is accepted. The server binds it to the owner, execution, message and real pending tool call. Duplicate, expired and concurrent responses are rejected without executing tools again.',
+        responses: {
+            200: {
+                description: 'Standard SDK UI message continuation stream.',
+                content: { 'text/event-stream': { schema: { type: 'string' } } },
+            },
+            ...apiErrorResponses,
+        },
+    }), conversationParam, apiValidator('json', ApprovalSchema), async (context) => {
+        const agent = await services.onlineAgent.realtime(trusted(context), {
+            sessionId: conversationId(context),
+        });
+        await agent.approve(context.req.valid('json'));
+        const stream = await agent.receive();
+        if (!stream)
+            throw invalid('The accepted continuation requires history reconciliation.');
+        return createUIMessageStreamResponse({
+            stream,
+            headers: {
+                'Cache-Control': 'private, no-store',
+                'x-online-agent-recovery': services.onlineAgent.recovery,
+            },
+        });
+    });
+    router.post('/conversations/:conversationId/finalize', guard, describeRoute({
+        tags,
+        summary: 'Retry response persistence without executing again',
+        operationId: 'agentsFinalizeConversation',
+        ...cliRoute(false),
+        responses: {
+            200: dataResponse(ConversationDetailSchema),
+            ...apiErrorResponses,
+        },
+    }), conversationParam, apiValidator('json', z.strictObject({})), async (context) => {
+        const id = conversationId(context);
+        const agent = await services.onlineAgent.realtime(trusted(context), {
+            sessionId: id,
+        });
+        await agent.retryFinalization();
+        return context.json({ data: await conversations.get(me(context), id) });
+    });
     const acts = {
         markRead: {
             act: (userId, id) => conversations.markRead(userId, id),
@@ -319,7 +459,9 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
             description: "Marks the conversation's messages read for the caller.",
         },
         stop: {
-            act: (userId, id) => conversations.stop(userId, id),
+            act: async () => {
+                throw invalid('Use the authenticated OnlineAgent stop handler.');
+            },
             operationId: 'agentsStopConversation',
             cli: {
                 command: 'conversation stop',
@@ -327,31 +469,7 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
                 flags: { conversationId: { name: 'conversation' } },
             },
             summary: "Stop a conversation's agent",
-            description: 'Cancels the run answering in the conversation, if any.',
-        },
-        fallback: {
-            act: (userId, id) => conversations.fallback(userId, id),
-            operationId: 'agentsFallbackConversation',
-            cli: {
-                command: 'conversation fallback',
-                args: ['conversationId'],
-                flags: { conversationId: { name: 'conversation' } },
-            },
-            summary: 'Switch a conversation to the default agent',
-            description: 'Continues the conversation with the default chat agent while its own agent cannot answer; a runner conversation whose default is not a runner agent continues with the online fallback agent.',
-            conflict: 'The conversation cannot fall back',
-        },
-        restore: {
-            act: (userId, id) => conversations.restore(userId, id),
-            operationId: 'agentsRestoreConversation',
-            cli: {
-                command: 'conversation restore',
-                args: ['conversationId'],
-                flags: { conversationId: { name: 'conversation' } },
-            },
-            summary: 'Switch a conversation back to its agent',
-            description: 'Gives the conversation back to the agent it fell back from.',
-            conflict: 'The conversation has nothing to switch back to',
+            description: 'Processes a cancellation request. The returned execution may remain running until actual termination and canonical history synchronization; request success does not mean the agent has stopped.',
         },
     };
     for (const [verb, item] of Object.entries(acts))
@@ -370,8 +488,77 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
                 ...apiErrorResponses,
             },
         }), conversationParam, async (context) => context.json({
-            data: await item.act(me(context), conversationId(context)),
+            data: verb === 'stop'
+                ? await (async () => {
+                    const id = conversationId(context);
+                    const detail = await conversations.get(me(context), id);
+                    if (!detail.execution)
+                        return conversations.stop(me(context), id);
+                    const agent = await services.onlineAgent.realtime(trusted(context), { sessionId: id });
+                    await agent.abort();
+                    return conversations.get(me(context), id);
+                })()
+                : await item.act(me(context), conversationId(context)),
         }));
+    router.get('/conversations/:conversationId/events', guard, describeRoute({
+        tags,
+        summary: 'Resume the current OnlineAgent UI stream',
+        operationId: 'agentsConversationEvents',
+        ...cliRoute(false),
+        description: 'Returns a full standard SDK replay and subsequent chunks when optional shared Redis recovery is configured. Without it, only an unclaimed local live response is available. Execution is never restarted. Missing streams return 204, which does not mean idle or successful: reconcile execution and persisted history. Disconnect never invokes Stop.',
+        responses: {
+            200: {
+                description: 'Standard SDK UI message stream for Native and Runner.',
+                content: { 'text/event-stream': { schema: { type: 'string' } } },
+            },
+            204: { description: 'No current stream; read saved history.' },
+            ...apiErrorResponses,
+        },
+    }), conversationParam, async (context) => {
+        const agent = await services.onlineAgent.realtime(trusted(context), {
+            sessionId: conversationId(context),
+        });
+        context.header('Cache-Control', 'private, no-store');
+        context.header('x-online-agent-recovery', services.onlineAgent.recovery);
+        const events = await agent.receive();
+        if (!events)
+            return context.body(null, 204);
+        return createUIMessageStreamResponse({
+            stream: events,
+            headers: {
+                'Cache-Control': 'private, no-store',
+                'x-online-agent-recovery': services.onlineAgent.recovery,
+            },
+        });
+    });
+    router.get('/conversations/:conversationId/config', guard, describeRoute({
+        tags,
+        summary: 'Read the saved OnlineAgent configuration',
+        operationId: 'agentsGetConversationConfig',
+        ...cliRoute(false),
+        responses: {
+            200: dataResponse(ConfigOutput),
+            ...apiErrorResponses,
+        },
+    }), conversationParam, async (context) => {
+        const config = await services.onlineAgent.configuration(trusted(context), conversationId(context));
+        return context.json({ data: config });
+    });
+    router.patch('/conversations/:conversationId/config', guard, describeRoute({
+        tags,
+        summary: 'Update idle OnlineAgent configuration',
+        operationId: 'agentsUpdateConversationConfig',
+        ...cliRoute(false),
+        description: 'Explicit overrides only; running configuration is frozen. The selected model and snapshot update atomically.',
+        responses: { 200: dataResponse(ConfigOutput), ...apiErrorResponses },
+    }), conversationParam, apiValidator('json', z.strictObject({
+        config: ConfigInput,
+        selectedModel: SelectedModel.optional(),
+    })), async (context) => {
+        const input = context.req.valid('json');
+        const config = await services.onlineAgent.configure(trusted(context), conversationId(context), input.config, input.selectedModel, 'http');
+        return context.json({ data: config });
+    });
     router.get('/chatAgents', guard, describeRoute({
         tags,
         summary: 'List the agents the caller may chat with',
@@ -384,27 +571,9 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
             ...apiErrorResponses,
         },
     }), async (context) => {
-        const data = await conversations.chatAgents(me(context));
+        const data = await services.conversations.chatAgents(me(context));
         return context.json({ data, meta: { total: data.length } });
     });
-    router.post('/:agentId/copy', guard, describeRoute({
-        tags,
-        summary: 'Copy an agent for oneself',
-        operationId: 'agentsCopyAgent',
-        ...cliRoute({
-            command: 'agent copy',
-            args: ['agentId'],
-            flags: { agentId: { name: 'agent' } },
-        }),
-        description: "A private copy of an agent the caller may wake, owned and usable only by them; `makeDefault` makes it the caller's default chat agent.",
-        responses: {
-            200: dataResponse(AgentSchema),
-            404: apiErrorResponse(404, 'The agent does not exist, or the caller may not wake it.'),
-            ...apiErrorResponses,
-        },
-    }), apiValidator('param', AgentParams), apiValidator('json', CopySchema), async (context) => context.json({
-        data: await conversations.copyAgent(me(context), context.req.valid('param').agentId, context.req.valid('json')),
-    }));
     router.get('/chatPreferences', guard, describeRoute({
         tags,
         summary: "Get the caller's chat preferences",
@@ -453,10 +622,9 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
             command: 'conversation settings update',
             flags: {
                 defaultAgentId: { name: 'default-agent' },
-                onlineFallbackAgentId: { name: 'online-fallback-agent' },
             },
         }),
-        description: "Sets the team's default chat agent and the online agent that answers in place of a runner agent with no runner for the person. Needs `agents.agents` manage.",
+        description: "Sets the team's default chat agent, an enabled agent. Needs `agents.agents` manage.",
         responses: {
             200: dataResponse(ChatSettingsSchema),
             ...apiErrorResponses,
@@ -549,25 +717,6 @@ export function createChatRoutes(services, guard, personOrRun = guard) {
             headers: contentHeaders(attachment, context.req.valid('query').download),
         });
     });
-    router.get('/presets', guard, describeRoute({
-        tags,
-        summary: 'List agent presets',
-        operationId: 'agentsListPresets',
-        ...cliRoute({
-            command: 'agent preset list',
-            columns: ['key', 'name', 'type', 'description'],
-        }),
-        description: 'The roles the application registered that a new agent can start from. Needs `agents.agents` read.',
-        responses: {
-            200: listResponse(AgentPresetSchema),
-            ...apiErrorResponses,
-        },
-    }), async (context) => {
-        if (!(await context.get('caller').can('agents.agents', 'read')))
-            throw forbidden('This needs agents.agents read permission.');
-        const data = services.presets.list();
-        return context.json({ data, meta: { total: data.length } });
-    });
     return router;
 }
 //# sourceMappingURL=chat.js.map