269 lines
10 KiB
TypeScript
269 lines
10 KiB
TypeScript
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
|
|
import type { ToolSet, UIMessage } from "ai";
|
|
import { convertToModelMessages, jsonSchema, stepCountIs, streamText, tool } from "ai";
|
|
import { parse, stringify } from "superjson";
|
|
import { z } from "zod/v4";
|
|
|
|
import { createTRPCContext, mcpRouter } from "@homarr/api/mcp";
|
|
import { auth } from "@homarr/auth/next";
|
|
import { env } from "@homarr/common/env";
|
|
import { decryptSecret } from "@homarr/common/server";
|
|
import { createLogger } from "@homarr/core/infrastructure/logs";
|
|
import { and, eq } from "@homarr/db";
|
|
import { db } from "@homarr/db";
|
|
import { assistantConfigurations, assistantThreads } from "@homarr/db/schema";
|
|
|
|
import { extractMcpTools } from "../../mcp/_extract-tools";
|
|
|
|
export const maxDuration = 60;
|
|
|
|
const logger = createLogger({ module: "assistant" });
|
|
|
|
const requestSchema = z.object({
|
|
id: z.string().min(1).max(64),
|
|
messages: z
|
|
.array(
|
|
z
|
|
.object({
|
|
id: z.string().min(1).max(128),
|
|
role: z.enum(["user", "assistant"]),
|
|
parts: z.array(z.unknown()).max(200),
|
|
})
|
|
.passthrough(),
|
|
)
|
|
.max(200),
|
|
tools: z
|
|
.record(
|
|
z.string(),
|
|
z.object({
|
|
description: z.string().optional(),
|
|
parameters: z.record(z.string(), z.unknown()),
|
|
providerOptions: z.record(z.string(), z.unknown()).optional(),
|
|
}),
|
|
)
|
|
.refine((tools) => tools === undefined || Object.keys(tools).length <= 16)
|
|
.optional(),
|
|
});
|
|
|
|
const browserToolDefinitions = {
|
|
navigate_to_route: {
|
|
description: "Navigate the current Homarr tab to a safe internal route.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: { path: { type: "string", description: "An internal Homarr path beginning with /" } },
|
|
required: ["path"],
|
|
additionalProperties: false,
|
|
},
|
|
},
|
|
open_command_menu: {
|
|
description: "Open Homarr's command and search menu.",
|
|
parameters: { type: "object", properties: {}, additionalProperties: false },
|
|
},
|
|
open_media_request_search: {
|
|
description: "Open Homarr's media request search interface.",
|
|
parameters: { type: "object", properties: {}, additionalProperties: false },
|
|
},
|
|
} as const;
|
|
|
|
const assistantInstructions = `You are Homarr Assistant, embedded in the user's self-hosted Homarr dashboard.
|
|
|
|
Use the available Homarr tools whenever live instance data is needed. Never invent integrations, boards, apps, users, media, system status, or action results.
|
|
|
|
Homarr concepts:
|
|
- Integrations connect Homarr to services such as Sonarr, Radarr, Plex, Jellyfin, Home Assistant, download clients, DNS filters, and monitoring systems.
|
|
- Boards are customizable dashboards. Apps are visual links on boards. Widgets show live integration data.
|
|
- Tool inputs that require an integrationId must use an id returned by an integration discovery tool.
|
|
- Existing Homarr permissions are authoritative. If a tool denies access, explain that the current user lacks permission without suggesting a bypass.
|
|
|
|
Action rules:
|
|
- Prefer read-only tools before actions.
|
|
- Mutating Homarr tools require user approval. Present the exact intended change and wait for the approval flow.
|
|
- Do not retry a denied action.
|
|
- Browser tools can navigate within Homarr or open existing Homarr UI. Never navigate to an arbitrary external URL.
|
|
- Keep responses concise and lead with the result. Summarize tool output instead of dumping JSON.
|
|
- If configuration or a service is unavailable, say what the user or administrator can do next.`;
|
|
|
|
const safeToolError = (error: unknown) => {
|
|
if (error instanceof Error && "code" in error) {
|
|
switch ((error as Error & { code: string }).code) {
|
|
case "UNAUTHORIZED":
|
|
case "FORBIDDEN":
|
|
return "You do not have permission to perform this action.";
|
|
case "NOT_FOUND":
|
|
return "The requested resource was not found.";
|
|
case "BAD_REQUEST":
|
|
return "The tool input was not valid.";
|
|
case "TOO_MANY_REQUESTS":
|
|
return "The operation is rate limited. Try again later.";
|
|
}
|
|
}
|
|
return "The Homarr tool could not complete this request.";
|
|
};
|
|
|
|
const getProcedureTypeMap = () => {
|
|
const procedures = (
|
|
mcpRouter as unknown as {
|
|
["_def"]: { procedures: Record<string, { ["_def"]?: { type?: string } }> };
|
|
}
|
|
)["_def"].procedures;
|
|
return new Map(
|
|
Object.entries(procedures).flatMap(([path, procedure]) => {
|
|
const type = procedure["_def"]?.type;
|
|
return type === "query" || type === "mutation" ? [[path, type] as const] : [];
|
|
}),
|
|
);
|
|
};
|
|
|
|
export async function POST(request: Request) {
|
|
const contentLength = Number(request.headers.get("content-length") ?? 0);
|
|
if (contentLength > 2_000_000) {
|
|
return Response.json({ error: "The assistant request is too large." }, { status: 413 });
|
|
}
|
|
|
|
const session = await auth();
|
|
if (!session) {
|
|
return Response.json({ error: "Sign in to use Homarr Assistant." }, { status: 401 });
|
|
}
|
|
|
|
const requestBody = await request.text();
|
|
if (requestBody.length > 2_000_000) {
|
|
return Response.json({ error: "The assistant request is too large." }, { status: 413 });
|
|
}
|
|
const parsed = requestSchema.safeParse(
|
|
(() => {
|
|
try {
|
|
return JSON.parse(requestBody) as unknown;
|
|
} catch {
|
|
return null;
|
|
}
|
|
})(),
|
|
);
|
|
if (!parsed.success) {
|
|
return Response.json({ error: "The assistant request was invalid." }, { status: 400 });
|
|
}
|
|
|
|
const configuration = await db.query.assistantConfigurations.findFirst({
|
|
where: eq(assistantConfigurations.id, "default"),
|
|
});
|
|
const requiresApiKey = configuration?.provider === "openrouter" || configuration?.provider === "openai";
|
|
if (!configuration?.enabled || !configuration.modelId || (requiresApiKey && !configuration.encryptedApiKey)) {
|
|
return Response.json({ error: "Homarr Assistant is not configured." }, { status: 503 });
|
|
}
|
|
|
|
const thread = await db.query.assistantThreads.findFirst({
|
|
where: and(
|
|
eq(assistantThreads.id, parsed.data.id),
|
|
eq(assistantThreads.userId, session.user.id),
|
|
eq(assistantThreads.status, "regular"),
|
|
),
|
|
});
|
|
if (!thread) {
|
|
return Response.json({ error: "Conversation not found." }, { status: 404 });
|
|
}
|
|
|
|
const context = createTRPCContext({ headers: request.headers, session });
|
|
const caller = mcpRouter.createCaller(context);
|
|
const procedureTypes = getProcedureTypeMap();
|
|
|
|
const homarrTools = Object.fromEntries(
|
|
extractMcpTools().map((mcpTool) => {
|
|
const procedurePath = mcpTool.pathInRouter.join(".");
|
|
const isMutation = procedureTypes.get(procedurePath) === "mutation";
|
|
return [
|
|
mcpTool.name,
|
|
tool({
|
|
description: mcpTool.description,
|
|
inputSchema: jsonSchema(
|
|
(mcpTool.inputSchema ?? { type: "object", properties: {} }) as Parameters<typeof jsonSchema>[0],
|
|
),
|
|
needsApproval: isMutation,
|
|
execute: async (input) => {
|
|
try {
|
|
const procedure = mcpTool.pathInRouter.reduce<unknown>(
|
|
(current, segment) =>
|
|
(typeof current === "object" || typeof current === "function") && current !== null
|
|
? (current as Record<string, unknown>)[segment]
|
|
: undefined,
|
|
caller,
|
|
);
|
|
if (typeof procedure !== "function") {
|
|
throw new Error("Procedure not callable");
|
|
}
|
|
const result = await (procedure as (value: unknown) => Promise<unknown>)(
|
|
input && Object.keys(input as object).length > 0 ? input : undefined,
|
|
);
|
|
return parse(stringify(result));
|
|
} catch (error) {
|
|
logger.error("Assistant tool call failed", {
|
|
toolName: mcpTool.name,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
});
|
|
return { error: safeToolError(error) };
|
|
}
|
|
},
|
|
}),
|
|
];
|
|
}),
|
|
) satisfies ToolSet;
|
|
|
|
const frontendTools = Object.fromEntries(
|
|
Object.keys(parsed.data.tools ?? {}).flatMap((name) => {
|
|
if (!(name in browserToolDefinitions)) return [];
|
|
const definition = browserToolDefinitions[name as keyof typeof browserToolDefinitions];
|
|
return [
|
|
[
|
|
name,
|
|
tool({
|
|
description: definition.description,
|
|
inputSchema: jsonSchema(definition.parameters as Parameters<typeof jsonSchema>[0]),
|
|
}),
|
|
] as const,
|
|
];
|
|
}),
|
|
) satisfies ToolSet;
|
|
|
|
try {
|
|
const customHeaders = configuration.encryptedHeaders
|
|
? z.record(z.string(), z.string()).parse(JSON.parse(decryptSecret(configuration.encryptedHeaders)))
|
|
: {};
|
|
const providerHeaders = {
|
|
...(configuration.provider === "openrouter"
|
|
? { "HTTP-Referer": "https://homarr.dev", "X-Title": "Homarr Assistant" }
|
|
: {}),
|
|
...customHeaders,
|
|
};
|
|
const provider = createOpenAICompatible({
|
|
name: `homarr-${configuration.provider}`,
|
|
baseURL: configuration.baseUrl,
|
|
apiKey: configuration.encryptedApiKey ? decryptSecret(configuration.encryptedApiKey) : undefined,
|
|
headers: providerHeaders,
|
|
includeUsage: true,
|
|
});
|
|
|
|
const result = streamText({
|
|
model: provider(configuration.modelId),
|
|
instructions: assistantInstructions,
|
|
messages: await convertToModelMessages(parsed.data.messages as UIMessage[]),
|
|
tools: { ...homarrTools, ...frontendTools },
|
|
stopWhen: stepCountIs(8),
|
|
abortSignal: request.signal,
|
|
timeout: { totalMs: 55_000, stepMs: 30_000, toolMs: 30_000 },
|
|
maxRetries: 2,
|
|
experimental_toolApprovalSecret: env.SECRET_ENCRYPTION_KEY,
|
|
onFinish: async () => {
|
|
await db
|
|
.update(assistantThreads)
|
|
.set({ modelId: configuration.modelId, updatedAt: new Date() })
|
|
.where(eq(assistantThreads.id, thread.id));
|
|
},
|
|
});
|
|
|
|
return result.toUIMessageStreamResponse();
|
|
} catch {
|
|
return Response.json(
|
|
{ error: "The configured model endpoint could not start this response. Check its URL, model, and credentials." },
|
|
{ status: 502 },
|
|
);
|
|
}
|
|
}
|