@axium/ai 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (105) hide show
  1. package/LICENSE.md +157 -0
  2. package/README.md +2 -2
  3. package/db.json +114 -0
  4. package/dist/client/cli.d.ts +1 -0
  5. package/dist/client/cli.js +224 -0
  6. package/dist/client/config.d.ts +196 -0
  7. package/dist/client/config.js +55 -0
  8. package/dist/client/hooks.d.ts +3 -0
  9. package/dist/client/hooks.js +32 -0
  10. package/dist/client/local.d.ts +17 -0
  11. package/dist/client/local.js +112 -0
  12. package/dist/common.d.ts +1318 -0
  13. package/dist/common.js +569 -0
  14. package/dist/hooks.d.ts +13 -0
  15. package/dist/hooks.js +34 -0
  16. package/dist/hub.d.ts +4 -0
  17. package/dist/hub.js +75 -0
  18. package/dist/index.d.ts +1 -0
  19. package/dist/index.js +1 -0
  20. package/dist/integrations/notes.d.ts +1 -0
  21. package/dist/integrations/notes.js +104 -0
  22. package/dist/integrations/tasks.d.ts +1 -0
  23. package/dist/integrations/tasks.js +157 -0
  24. package/dist/loop.d.ts +75 -0
  25. package/dist/loop.js +239 -0
  26. package/dist/memory.d.ts +107 -0
  27. package/dist/memory.js +193 -0
  28. package/dist/node/chat.d.ts +50 -0
  29. package/dist/node/chat.js +60 -0
  30. package/dist/node/llama.d.ts +115 -0
  31. package/dist/node/llama.js +385 -0
  32. package/dist/node/markdown.d.ts +6 -0
  33. package/dist/node/markdown.js +285 -0
  34. package/dist/node/models.d.ts +34 -0
  35. package/dist/node/models.js +287 -0
  36. package/dist/node/web.d.ts +1 -0
  37. package/dist/node/web.js +203 -0
  38. package/dist/server/api/conversations.d.ts +1 -0
  39. package/dist/server/api/conversations.js +216 -0
  40. package/dist/server/api/gateway.d.ts +1 -0
  41. package/dist/server/api/gateway.js +113 -0
  42. package/dist/server/api/memories.d.ts +1 -0
  43. package/dist/server/api/memories.js +129 -0
  44. package/dist/server/api/models.d.ts +1 -0
  45. package/dist/server/api/models.js +161 -0
  46. package/dist/server/api/temporary.d.ts +1 -0
  47. package/dist/server/api/temporary.js +50 -0
  48. package/dist/server/api/timers.d.ts +1 -0
  49. package/dist/server/api/timers.js +27 -0
  50. package/dist/server/api/voice.d.ts +1 -0
  51. package/dist/server/api/voice.js +188 -0
  52. package/dist/server/generation.d.ts +38 -0
  53. package/dist/server/generation.js +299 -0
  54. package/dist/server/memory.d.ts +7 -0
  55. package/dist/server/memory.js +218 -0
  56. package/dist/server/models.d.ts +13 -0
  57. package/dist/server/models.js +59 -0
  58. package/dist/server/preferences.d.ts +3 -0
  59. package/dist/server/preferences.js +12 -0
  60. package/dist/server/timers.d.ts +7 -0
  61. package/dist/server/timers.js +66 -0
  62. package/dist/speech.d.ts +17 -0
  63. package/dist/speech.js +69 -0
  64. package/dist/timers.d.ts +1 -0
  65. package/dist/timers.js +67 -0
  66. package/dist/tools.d.ts +70 -0
  67. package/dist/tools.js +84 -0
  68. package/lib/ChatMessage.svelte +331 -0
  69. package/lib/Composer.svelte +234 -0
  70. package/lib/Conversation.svelte +433 -0
  71. package/lib/ConversationMenu.svelte +18 -0
  72. package/lib/ModelActions.svelte +71 -0
  73. package/lib/ModelOptions.svelte +101 -0
  74. package/lib/ModelStatus.svelte +49 -0
  75. package/lib/ToolCall.svelte +171 -0
  76. package/lib/VoiceMode.svelte +113 -0
  77. package/lib/actions.ts +21 -0
  78. package/lib/index.ts +7 -0
  79. package/lib/live.svelte.ts +113 -0
  80. package/lib/markdown.ts +40 -0
  81. package/lib/preferences.ts +13 -0
  82. package/lib/transition.ts +24 -0
  83. package/lib/tsconfig.json +14 -0
  84. package/lib/voice.svelte.ts +476 -0
  85. package/locales/en.json +316 -0
  86. package/package.json +139 -5
  87. package/routes/ai/+layout.svelte +177 -0
  88. package/routes/ai/+layout.ts +26 -0
  89. package/routes/ai/+page.svelte +109 -0
  90. package/routes/ai/TimerAlerts.svelte +51 -0
  91. package/routes/ai/Timers.svelte +121 -0
  92. package/routes/ai/[id]/+page.svelte +18 -0
  93. package/routes/ai/[id]/+page.ts +14 -0
  94. package/routes/ai/memory/+page.svelte +313 -0
  95. package/routes/ai/memory/+page.ts +10 -0
  96. package/routes/ai/memory/MemoryForm.svelte +111 -0
  97. package/routes/ai/models/+page.svelte +199 -0
  98. package/routes/ai/models/+page.ts +5 -0
  99. package/routes/ai/models/AddModel.svelte +240 -0
  100. package/routes/ai/models/MemoryMeter.svelte +120 -0
  101. package/routes/ai/models/Roles.svelte +159 -0
  102. package/routes/ai/models/[id]/+page.svelte +331 -0
  103. package/routes/ai/models/[id]/+page.ts +6 -0
  104. package/routes/ai/timers.svelte.ts +94 -0
  105. package/routes/tsconfig.json +14 -0
@@ -0,0 +1,50 @@
1
+ import { requireSession } from '@axium/server/auth';
2
+ import { database } from '@axium/server/database';
3
+ import { error, parseBody } from '@axium/server/requests';
4
+ import { addRoute } from '@axium/server/routes';
5
+ import { randomUUID } from 'node:crypto';
6
+ import * as z from 'zod';
7
+ import * as ai from '../../common.js';
8
+ import { cancel, emitMessage, generateTemporary, isGenerating } from '../generation.js';
9
+ addRoute({
10
+ path: '/api/ai/temporary/:id',
11
+ params: { id: z.uuid() },
12
+ async PUT(request, { id }) {
13
+ const init = await parseBody(request, ai.TemporaryInit);
14
+ const { userId, timezone } = await requireSession(request);
15
+ if (isGenerating(id))
16
+ error(409, 'A response is already being generated');
17
+ const last = init.messages.at(-1);
18
+ const deciding = !!init.decisions && init.messages.some(message => message.status == 'awaiting');
19
+ if (!deciding && (last.role != 'user' || !last.content.trim())) {
20
+ error(400, 'The last message must be from the user, unless deciding on tool calls');
21
+ }
22
+ const saved = await database.selectFrom('ai_conversations').select('id').where('id', '=', id).executeTakeFirst();
23
+ if (saved)
24
+ error(409, 'A saved conversation has this ID');
25
+ const pending = {
26
+ id: randomUUID(),
27
+ conversationId: id,
28
+ created: new Date(),
29
+ role: 'assistant',
30
+ content: '',
31
+ reasoning: null,
32
+ toolCalls: null,
33
+ toolCallId: null,
34
+ status: 'pending',
35
+ error: null,
36
+ usage: null,
37
+ voice: false,
38
+ };
39
+ emitMessage(userId, pending);
40
+ void generateTemporary(userId, init, pending, timezone);
41
+ return pending;
42
+ },
43
+ async POST(request, { id }) {
44
+ await parseBody(request, z.object({ action: z.literal('cancel') }));
45
+ const { userId } = await requireSession(request);
46
+ if (!cancel(id, userId))
47
+ error(409, 'No response is being generated');
48
+ return {};
49
+ },
50
+ });
@@ -0,0 +1 @@
1
+ export {};
@@ -0,0 +1,27 @@
1
+ import { checkAuthForUser } from '@axium/server/auth';
2
+ import { parseBody } from '@axium/server/requests';
3
+ import { addRoute } from '@axium/server/routes';
4
+ import * as z from 'zod';
5
+ import * as ai from '../../common.js';
6
+ import { cancel, list, start } from '../timers.js';
7
+ addRoute({
8
+ path: '/api/users/:id/ai/timers',
9
+ params: { id: z.uuid() },
10
+ async GET(request, { id: userId }) {
11
+ await checkAuthForUser(request, userId);
12
+ return await list(userId);
13
+ },
14
+ async PUT(request, { id: userId }) {
15
+ const init = await parseBody(request, ai.TimerInit);
16
+ await checkAuthForUser(request, userId);
17
+ return await start(userId, init);
18
+ },
19
+ });
20
+ addRoute({
21
+ path: '/api/users/:id/ai/timers/:timer',
22
+ params: { id: z.uuid(), timer: z.uuid() },
23
+ async DELETE(request, { id: userId, timer: id }) {
24
+ await checkAuthForUser(request, userId);
25
+ return await cancel(userId, id);
26
+ },
27
+ });
@@ -0,0 +1 @@
1
+ export {};
@@ -0,0 +1,188 @@
1
+ import { getConfig } from '@axium/core';
2
+ import features from '@axium/core/features';
3
+ import { requireSession } from '@axium/server/auth';
4
+ import { error, parseBody, withError } from '@axium/server/requests';
5
+ import { addRoute } from '@axium/server/routes';
6
+ import { existsSync } from 'node:fs';
7
+ import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
8
+ import { dirname, join } from 'node:path';
9
+ import * as ai from '../../common.js';
10
+ import * as llama from '../../node/llama.js';
11
+ import { speakable } from '../../speech.js';
12
+ import { getModels, resolveRole } from '../models.js';
13
+ /** The most audio accepted for transcription, in bytes */
14
+ const maxAudioSize = 32 * 1024 * 1024;
15
+ /** Makes speech reproducible, including the generated default voice */
16
+ const seed = 1;
17
+ /** How long the end of each clip fades out, in seconds */
18
+ const fadeLength = 0.04;
19
+ /** The pause after each clip, in seconds */
20
+ const pauseLength = 0.25;
21
+ async function requireVoiceEnabled(request) {
22
+ await requireSession(request);
23
+ if (!features('ai-voice'))
24
+ error(403, 'Voice is disabled');
25
+ if (!llama.isRunning())
26
+ error(503, 'llama-server is not running');
27
+ }
28
+ async function requireVoice(request, role) {
29
+ await requireVoiceEnabled(request);
30
+ return (await resolveRole(role)) ?? error(503, `No ${role == 'stt' ? 'speech-to-text' : 'text-to-speech'} model is available`);
31
+ }
32
+ /** llama-server's error message, or its status when it didn't give one */
33
+ async function upstreamError(response) {
34
+ const body = await response.text();
35
+ try {
36
+ return JSON.parse(body).error?.message ?? body;
37
+ }
38
+ catch {
39
+ return body || response.statusText;
40
+ }
41
+ }
42
+ const defaultVoiceText = 'Hello. I am your assistant, and this is the voice I will use when I speak to you.';
43
+ let generating;
44
+ async function generateDefaultVoice(path, model) {
45
+ const response = await llama.send('v1/audio/speech', {
46
+ method: 'POST',
47
+ body: JSON.stringify({ model, input: defaultVoiceText, response_format: 'wav', seed }),
48
+ });
49
+ if (!response.ok)
50
+ throw new Error(await upstreamError(response));
51
+ await mkdir(dirname(path), { recursive: true });
52
+ await writeFile(path, await response.bytes());
53
+ }
54
+ let cached;
55
+ /** The recording every reply imitates: the configured one, or a default voice made the first time it's needed */
56
+ async function speakerReference(model) {
57
+ const { speaker_reference: configured, speaker_reference_text, data_dir } = getConfig('@axium/ai');
58
+ const path = configured ?? join(data_dir, 'default-voice.wav');
59
+ if (!configured && !existsSync(path)) {
60
+ generating ??= generateDefaultVoice(path, model).finally(() => (generating = undefined));
61
+ await generating;
62
+ }
63
+ const { mtimeMs: modified } = await stat(path);
64
+ if (cached?.path != path || cached.modified != modified) {
65
+ cached = { path, modified, audio: (await readFile(path)).toString('base64') };
66
+ }
67
+ return { audio: cached.audio, text: (configured ? speaker_reference_text : defaultVoiceText) ?? undefined };
68
+ }
69
+ /**
70
+ * Fades out the end of 16-bit PCM WAV audio and adds a pause, so clips the model ends early don't stop mid-sound.
71
+ * Other formats are returned unchanged.
72
+ */
73
+ function finishSpeech(wav) {
74
+ const view = new DataView(wav.buffer, wav.byteOffset, wav.byteLength);
75
+ const tag = (offset) => String.fromCharCode(...wav.subarray(offset, offset + 4));
76
+ if (wav.length < 44 || tag(0) != 'RIFF' || tag(8) != 'WAVE')
77
+ return wav;
78
+ let format;
79
+ let offset = 12;
80
+ while (offset + 8 <= wav.length) {
81
+ const size = view.getUint32(offset + 4, true);
82
+ if (tag(offset) == 'fmt ') {
83
+ format = {
84
+ pcm: view.getUint16(offset + 8, true) == 1,
85
+ channels: view.getUint16(offset + 10, true),
86
+ rate: view.getUint32(offset + 12, true),
87
+ bits: view.getUint16(offset + 22, true),
88
+ };
89
+ }
90
+ if (tag(offset) == 'data')
91
+ break;
92
+ offset += 8 + size + (size % 2);
93
+ }
94
+ if (!format?.pcm || format.bits != 16 || tag(offset) != 'data')
95
+ return wav;
96
+ const start = offset + 8;
97
+ const frameSize = format.channels * 2;
98
+ const length = Math.min(view.getUint32(offset + 4, true), wav.length - start);
99
+ const frames = Math.floor(length / frameSize);
100
+ const fadeFrames = Math.min(frames, Math.round(format.rate * fadeLength));
101
+ for (let frame = frames - fadeFrames; frame < frames; frame++) {
102
+ const gain = (frames - frame) / fadeFrames;
103
+ for (let channel = 0; channel < format.channels; channel++) {
104
+ const position = start + frame * frameSize + channel * 2;
105
+ view.setInt16(position, Math.round(view.getInt16(position, true) * gain), true);
106
+ }
107
+ }
108
+ const pause = Math.round(format.rate * pauseLength) * frameSize;
109
+ const result = new Uint8Array(start + frames * frameSize + pause);
110
+ result.set(wav.subarray(0, start + frames * frameSize));
111
+ const header = new DataView(result.buffer);
112
+ header.setUint32(4, result.length - 8, true);
113
+ header.setUint32(offset + 4, frames * frameSize + pause, true);
114
+ return result;
115
+ }
116
+ addRoute({
117
+ path: '/api/ai/transcription',
118
+ /** Takes a WAV or MP3 recording as the body */
119
+ async POST(request) {
120
+ const model = await requireVoice(request, 'stt');
121
+ const audio = await request.blob();
122
+ if (!audio.size)
123
+ error(400, 'Missing audio');
124
+ if (audio.size > maxAudioSize)
125
+ error(413, 'The recording is too large');
126
+ const form = new FormData();
127
+ form.set('model', model);
128
+ form.set('file', audio, audio.type.includes('mpeg') ? 'audio.mp3' : 'audio.wav');
129
+ const upstream = await llama
130
+ .send('v1/audio/transcriptions', { method: 'POST', body: form, signal: request.signal })
131
+ .catch(withError('Could not reach llama-server', 502));
132
+ if (!upstream.ok)
133
+ error(502, 'Could not transcribe: ' + (await upstreamError(upstream)));
134
+ const { text } = (await upstream.json());
135
+ return { text: text?.trim() ?? '' };
136
+ },
137
+ });
138
+ addRoute({
139
+ path: '/api/ai/speech',
140
+ /** Responds with WAV audio */
141
+ async POST(request) {
142
+ const { text } = await parseBody(request, ai.SpeechInit);
143
+ const model = await requireVoice(request, 'tts');
144
+ const input = speakable(text);
145
+ if (!/[\p{L}\p{N}]/u.test(input))
146
+ error(400, 'Nothing in the text can be spoken');
147
+ const speaker = await speakerReference(model).catch(withError('Could not get the voice to speak with', 502));
148
+ const speak = (speaker) => llama
149
+ .send('v1/audio/speech', {
150
+ method: 'POST',
151
+ body: JSON.stringify({
152
+ model,
153
+ input,
154
+ response_format: 'wav',
155
+ seed,
156
+ speaker_ref_b64: speaker?.audio,
157
+ speaker_ref_text: speaker?.text,
158
+ }),
159
+ signal: request.signal,
160
+ })
161
+ .catch(withError('Could not reach llama-server', 502));
162
+ let upstream = await speak(speaker);
163
+ // Models without a voice encoder reject speaker references.
164
+ if (upstream.status == 400)
165
+ upstream = await speak();
166
+ if (!upstream.ok)
167
+ error(502, 'Could not speak: ' + (await upstreamError(upstream)));
168
+ const audio = finishSpeech(await upstream.bytes());
169
+ return new Response(audio, { headers: { 'Content-Type': upstream.headers.get('Content-Type') ?? 'audio/wav' } });
170
+ },
171
+ });
172
+ addRoute({
173
+ path: '/api/ai/voice/prepare',
174
+ async POST(request) {
175
+ await requireVoiceEnabled(request);
176
+ const { models, roles } = await getModels();
177
+ const stt = ai.resolveRole(models, roles, 'stt');
178
+ const tts = ai.resolveRole(models, roles, 'tts');
179
+ for (const model of new Set([stt, tts])) {
180
+ if (!model || model.status == 'loaded' || model.status == 'loading')
181
+ continue;
182
+ await llama.load(model.id).catch(withError(`Could not load ${model.name}`, 502));
183
+ }
184
+ if (tts)
185
+ await speakerReference(tts.id).catch(withError('Could not get the voice to speak with', 502));
186
+ return {};
187
+ },
188
+ });
@@ -0,0 +1,38 @@
1
+ import { type Schema } from '@axium/server/database';
2
+ import type { FromFile as FromSchemaFile } from '@axium/server/db/schema';
3
+ import type { Selectable } from 'kysely';
4
+ import type schema from '../../db.json';
5
+ import type * as ai from '../common.js';
6
+ import * as loop from '../loop.js';
7
+ declare module '@axium/server/database' {
8
+ interface Schema extends FromSchemaFile<typeof schema> {
9
+ }
10
+ }
11
+ type MessageRow = Selectable<Schema['ai_messages']>;
12
+ type ConversationRow = Selectable<Schema['ai_conversations']>;
13
+ export declare function toMessage(row: MessageRow): ai.Message;
14
+ export declare function emitMessage(userId: string, message: ai.Message): void;
15
+ export declare function emitRemoved(userId: string, removed: ai.MessagesRemoved): void;
16
+ export declare function isGenerating(conversationId: string): boolean;
17
+ /** Stops the response being generated in a conversation, if it belongs to `userId` */
18
+ export declare function cancel(conversationId: string, userId: string): boolean;
19
+ /** Fills in the text streamed so far, which is only saved once the response ends */
20
+ export declare function withProgress(message: ai.Message): ai.Message;
21
+ interface TurnInit extends Pick<loop.TurnInit, 'store' | 'pending' | 'history' | 'decisions' | 'allowedTools' | 'allowForChat' | 'anonymous' | 'temporary'> {
22
+ /** `null` uses the chat role's model */
23
+ model: string | null;
24
+ reasoning: string;
25
+ /** Called after the turn's final response */
26
+ onDone?(model: string, content: string): void;
27
+ /** The time zone of the session the turn was requested from */
28
+ timeZone?: string | null;
29
+ }
30
+ export interface GenerateOptions extends Pick<TurnInit, 'decisions' | 'timeZone'> {
31
+ }
32
+ /** Responds into the pending `message` of a saved conversation. Never throws. */
33
+ export declare function generate(conversation: ConversationRow, message: MessageRow, { decisions, timeZone }: GenerateOptions): Promise<void>;
34
+ /** Responds into `pending` for a temporary conversation, which is never saved. Never throws. */
35
+ export declare function generateTemporary(userId: string, init: ai.TemporaryInit, pending: ai.Message, timeZone?: string | null): Promise<void>;
36
+ /** Marks responses and tool calls left pending by a previous process as failed */
37
+ export declare function failInterrupted(): Promise<void>;
38
+ export {};
@@ -0,0 +1,299 @@
1
+ import { getConfig } from '@axium/core';
2
+ import { getUser } from '@axium/server/auth';
3
+ import { callAPI } from '@axium/server/call';
4
+ import { database } from '@axium/server/database';
5
+ import { io as socketServer } from '@axium/server/socket';
6
+ import * as io from 'ioium';
7
+ import { randomUUID } from 'node:crypto';
8
+ import * as loop from '../loop.js';
9
+ import { chat, streamChat } from '../node/chat.js';
10
+ import features from '@axium/core/features';
11
+ import { getMemories } from './memory.js';
12
+ import { getPreferences } from './preferences.js';
13
+ import * as timers from './timers.js';
14
+ import { getRow, learnCapabilities, resolveRole } from './models.js';
15
+ import { pick } from 'utilium';
16
+ export function toMessage(row) {
17
+ return {
18
+ ...row,
19
+ toolCalls: row.toolCalls,
20
+ usage: row.usage,
21
+ };
22
+ }
23
+ export function emitMessage(userId, message) {
24
+ socketServer?.to('user:' + userId).emit('ai.message', message);
25
+ }
26
+ export function emitRemoved(userId, removed) {
27
+ socketServer?.to('user:' + userId).emit('ai.message.remove', removed);
28
+ }
29
+ /** Running responses, by conversation ID */
30
+ const active = new Map();
31
+ export function isGenerating(conversationId) {
32
+ return active.has(conversationId);
33
+ }
34
+ /** Stops the response being generated in a conversation, if it belongs to `userId` */
35
+ export function cancel(conversationId, userId) {
36
+ const generation = active.get(conversationId);
37
+ if (generation?.userId != userId)
38
+ return false;
39
+ generation.controller.abort();
40
+ return true;
41
+ }
42
+ /** Fills in the text streamed so far, which is only saved once the response ends */
43
+ export function withProgress(message) {
44
+ const progress = active.get(message.conversationId)?.progress;
45
+ if (message.status != 'pending' || progress?.messageId != message.id)
46
+ return message;
47
+ return { ...message, content: progress.content, reasoning: progress.reasoning || null };
48
+ }
49
+ function toRow({ toolCalls, usage, ...changes }) {
50
+ return {
51
+ ...changes,
52
+ ...(toolCalls !== undefined && { toolCalls: toolCalls && JSON.stringify(toolCalls) }),
53
+ ...(usage !== undefined && { usage: usage && JSON.stringify(usage) }),
54
+ };
55
+ }
56
+ function savedStore(conversation) {
57
+ return {
58
+ userId: conversation.userId,
59
+ conversationId: conversation.id,
60
+ async add(message) {
61
+ const row = await database
62
+ .insertInto('ai_messages')
63
+ .values({ ...toRow(message), role: message.role, conversationId: conversation.id })
64
+ .returningAll()
65
+ .executeTakeFirstOrThrow();
66
+ const added = toMessage(row);
67
+ emitMessage(conversation.userId, added);
68
+ return added;
69
+ },
70
+ async update(id, changes) {
71
+ const row = await database
72
+ .updateTable('ai_messages')
73
+ .set(toRow(changes))
74
+ .where('id', '=', id)
75
+ .returningAll()
76
+ .executeTakeFirstOrThrow();
77
+ const updated = toMessage(row);
78
+ emitMessage(conversation.userId, updated);
79
+ return updated;
80
+ },
81
+ };
82
+ }
83
+ /** Keeps messages only long enough to send them; the client holds temporary conversations */
84
+ function temporaryStore(userId, conversationId, messages) {
85
+ const known = new Map(messages.map(message => [message.id, message]));
86
+ return {
87
+ userId,
88
+ conversationId,
89
+ add(message) {
90
+ const added = {
91
+ id: randomUUID(),
92
+ conversationId,
93
+ created: new Date(),
94
+ content: '',
95
+ reasoning: null,
96
+ toolCalls: null,
97
+ toolCallId: null,
98
+ status: 'done',
99
+ error: null,
100
+ usage: null,
101
+ voice: false,
102
+ ...message,
103
+ };
104
+ known.set(added.id, added);
105
+ emitMessage(userId, added);
106
+ return Promise.resolve(added);
107
+ },
108
+ update(id, changes) {
109
+ const existing = known.get(id);
110
+ if (!existing)
111
+ return Promise.reject(new ReferenceError(`Unknown message ${id}`));
112
+ const updated = { ...existing, ...changes };
113
+ known.set(id, updated);
114
+ emitMessage(userId, updated);
115
+ return Promise.resolve(updated);
116
+ },
117
+ };
118
+ }
119
+ /** Saves tools the user allowed in every conversation */
120
+ async function allowAlways(userId, preferences, names) {
121
+ for (const name of names)
122
+ preferences.tools.approvals[name] = 'allow';
123
+ await database
124
+ .insertInto('app_preferences')
125
+ .values({ userId, appId: 'ai', data: preferences })
126
+ .onConflict(conflict => conflict.columns(['userId', 'appId']).doUpdateSet({ data: preferences }))
127
+ .execute();
128
+ }
129
+ /** Responds with the server's model, streaming text to the user. Never throws. */
130
+ async function respond(init) {
131
+ const { store } = init;
132
+ const config = getConfig('@axium/ai');
133
+ const controller = new AbortController();
134
+ const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(config.timeout * 1000)]);
135
+ const progress = { messageId: init.pending.id, content: '', reasoning: '' };
136
+ active.set(store.conversationId, { controller, userId: store.userId, progress });
137
+ try {
138
+ const id = init.model ?? (await resolveRole('chat'));
139
+ const model = id && (await getRow(id));
140
+ if (!model)
141
+ throw new Error('No model is available');
142
+ const [preferences, user] = await Promise.all([getPreferences(store.userId), getUser(store.userId)]);
143
+ const remembers = preferences.tools.memory && features('ai-memory') && !init.anonymous;
144
+ let streaming = false;
145
+ await loop.respond({
146
+ store,
147
+ model,
148
+ defaultSystemPrompt: config.system_prompt,
149
+ maxSteps: config.max_steps,
150
+ ...pick(init, 'reasoning', 'pending', 'history', 'decisions', 'allowedTools', 'allowForChat', 'anonymous', 'temporary'),
151
+ complete: request => streamChat({ ...request, model: model.id }),
152
+ preferences,
153
+ timeZone: init.timeZone ?? user.preferences.time_zone,
154
+ homeTimeZone: user.preferences.time_zone,
155
+ memories: remembers ? await getMemories(store.userId) : undefined,
156
+ context: {
157
+ userId: user.id,
158
+ conversationId: init.temporary ? undefined : store.conversationId,
159
+ signal,
160
+ api: (method, endpoint, data, ...params) => callAPI(user, method, endpoint, data, ...params),
161
+ timers: timers.forUser(user.id),
162
+ },
163
+ allowAlways: names => allowAlways(store.userId, preferences, names),
164
+ progress,
165
+ onText(field, text, position) {
166
+ socketServer
167
+ ?.to('user:' + store.userId)
168
+ .emit('ai.delta', { conversationId: store.conversationId, messageId: progress.messageId, field, text, position });
169
+ if (streaming)
170
+ return;
171
+ streaming = true;
172
+ void learnCapabilities(model.id);
173
+ },
174
+ onDone: content => init.onDone?.(model.id, content),
175
+ });
176
+ }
177
+ catch (error) {
178
+ io.warn(`AI: could not start a response in ${store.conversationId}: ${io.errorText(error)}`);
179
+ await store
180
+ .update(init.pending.id, { status: 'error', error: io.errorText(error) })
181
+ .catch(error => io.error(`AI: could not finish response in ${store.conversationId}: ${io.errorText(error)}`));
182
+ }
183
+ finally {
184
+ active.delete(store.conversationId);
185
+ }
186
+ }
187
+ async function savedHistory(conversationId, exclude) {
188
+ const rows = await database
189
+ .selectFrom('ai_messages')
190
+ .selectAll()
191
+ .where('conversationId', '=', conversationId)
192
+ .where('id', '!=', exclude)
193
+ .orderBy('created')
194
+ .execute();
195
+ return rows.map(toMessage);
196
+ }
197
+ /** Responds into the pending `message` of a saved conversation. Never throws. */
198
+ export async function generate(conversation, message, { decisions, timeZone }) {
199
+ await respond({
200
+ timeZone,
201
+ store: savedStore(conversation),
202
+ model: conversation.model,
203
+ reasoning: conversation.reasoning,
204
+ pending: toMessage(message),
205
+ history: () => savedHistory(conversation.id, message.id),
206
+ decisions,
207
+ allowedTools: conversation.allowedTools,
208
+ async allowForChat(names) {
209
+ const updated = await database
210
+ .updateTable('ai_conversations')
211
+ .set({ allowedTools: names })
212
+ .where('id', '=', conversation.id)
213
+ .returningAll()
214
+ .executeTakeFirstOrThrow();
215
+ socketServer?.to('user:' + conversation.userId).emit('ai.conversation', updated);
216
+ },
217
+ onDone: (model, content) => void nameConversation(conversation, model, content),
218
+ });
219
+ }
220
+ /** Responds into `pending` for a temporary conversation, which is never saved. Never throws. */
221
+ export async function generateTemporary(userId, init, pending, timeZone) {
222
+ const history = init.messages.map((message) => ({
223
+ conversationId: pending.conversationId,
224
+ reasoning: null,
225
+ error: null,
226
+ usage: null,
227
+ ...message,
228
+ toolCalls: message.toolCalls ?? null,
229
+ toolCallId: message.toolCallId ?? null,
230
+ status: message.status ?? 'done',
231
+ }));
232
+ await respond({
233
+ store: temporaryStore(userId, pending.conversationId, [...history, pending]),
234
+ model: init.model ?? null,
235
+ reasoning: init.reasoning,
236
+ pending,
237
+ history: () => Promise.resolve(history),
238
+ decisions: init.decisions,
239
+ allowedTools: init.allowedTools,
240
+ anonymous: init.anonymous,
241
+ temporary: true,
242
+ timeZone,
243
+ });
244
+ }
245
+ const titlePrompt = 'Write a title of 2 to 6 words for the conversation below. Reply with only the title.';
246
+ /** Titles a conversation from its first exchange, unless it already has a title from a model or the user */
247
+ async function nameConversation(conversation, model, reply) {
248
+ if (conversation.titleSource != 'none')
249
+ return;
250
+ try {
251
+ const first = await database
252
+ .selectFrom('ai_messages')
253
+ .select('content')
254
+ .where('conversationId', '=', conversation.id)
255
+ .where('role', '=', 'user')
256
+ .orderBy('created')
257
+ .limit(1)
258
+ .executeTakeFirst();
259
+ if (!first)
260
+ return;
261
+ const result = await chat({
262
+ model,
263
+ reasoning: 'none',
264
+ maxTokens: 24,
265
+ signal: AbortSignal.timeout(30_000),
266
+ messages: [
267
+ { role: 'system', content: titlePrompt },
268
+ { role: 'user', content: `User: ${first.content.slice(0, 2000)}\n\nAssistant: ${reply.slice(0, 2000)}` },
269
+ ],
270
+ });
271
+ const title = result.content
272
+ .split('\n')
273
+ .find(line => line.trim())
274
+ ?.replace(/^[\s"'*#]+|[\s"'*.]+$/g, '')
275
+ .slice(0, 100);
276
+ if (!title)
277
+ return;
278
+ const updated = await database
279
+ .updateTable('ai_conversations')
280
+ .set({ title, titleSource: 'auto' })
281
+ .where('id', '=', conversation.id)
282
+ .where('titleSource', '=', 'none')
283
+ .returningAll()
284
+ .executeTakeFirst();
285
+ if (updated)
286
+ socketServer?.to('user:' + conversation.userId).emit('ai.conversation', updated);
287
+ }
288
+ catch (error) {
289
+ io.debug(`AI: could not title ${conversation.id}: ${io.errorText(error)}`);
290
+ }
291
+ }
292
+ /** Marks responses and tool calls left pending by a previous process as failed */
293
+ export async function failInterrupted() {
294
+ await database
295
+ .updateTable('ai_messages')
296
+ .set({ status: 'error', error: 'Interrupted by a server restart' })
297
+ .where('status', '=', 'pending')
298
+ .execute();
299
+ }
@@ -0,0 +1,7 @@
1
+ import * as memory from '../memory.js';
2
+ export declare function getMemories(userId: string): Promise<memory.Node[]>;
3
+ /** Whether the server allows periodic updates */
4
+ export declare function updatesEnabled(): boolean;
5
+ export declare function getStatus(userId: string, running?: boolean): Promise<memory.Updates>;
6
+ /** Starts an update for the user now */
7
+ export declare function startUpdate(userId: string): Promise<void>;