openclaw-server 0.1.0

package/src/routes/models.ts

@@ -0,0 +1,21 @@
+import type { Express } from "express";
+import { requireBearerAuth } from "../auth.js";
+import type { AppContext } from "../server.js";
+
+export function registerModelsRoute(app: Express, context: AppContext): void {
+  app.get("/v1/models", (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    res.json({
+      object: "list",
+      data: context.pack.manifest.models.map((id) => ({
+        id,
+        object: "model",
+        owned_by: "openclaw-server",
+      })),
+    });
+  });
+}

package/src/routes/request-validation.ts

@@ -0,0 +1,33 @@
+import type { ToolDefinition, ToolChoice } from "../types.js";
+
+function resolveRequestedToolName(toolChoice: ToolChoice | undefined): string | undefined {
+  if (!toolChoice || typeof toolChoice !== "object") {
+    return undefined;
+  }
+  return toolChoice.function.name;
+}
+
+export function validateToolChoice(params: {
+  tools: ToolDefinition[];
+  toolChoice: ToolChoice | undefined;
+}): string | undefined {
+  const { tools, toolChoice } = params;
+  if (!toolChoice || toolChoice === "auto" || toolChoice === "none") {
+    return undefined;
+  }
+  if (tools.length === 0) {
+    return "tool_choice was provided but no tools were supplied";
+  }
+  if (toolChoice === "required") {
+    return undefined;
+  }
+
+  const requestedName = resolveRequestedToolName(toolChoice);
+  if (!requestedName) {
+    return "tool_choice.function.name is required";
+  }
+  if (!tools.some((tool) => tool.function.name === requestedName)) {
+    return `tool_choice requested unknown tool: ${requestedName}`;
+  }
+  return undefined;
+}

package/src/routes/responses.ts

@@ -0,0 +1,182 @@
+import type { Express } from "express";
+import { requireBearerAuth } from "../auth.js";
+import { normalizeRequest } from "../core/normalizer.js";
+import { responseRequestToChatRequest } from "../core/request-adapter.js";
+import { streamResponsesText, streamResponsesToolCall } from "../core/stream-renderer.js";
+import {
+  logRequestDebug,
+  logResponseSelection,
+  logTaskInspection,
+  logWeatherInspection,
+} from "../debug-log.js";
+import {
+  buildResponsesResponse,
+  createResponseId,
+  createResponseOutputId,
+} from "../response-api.js";
+import type { AppContext } from "../server.js";
+import { buildTaskEngineResult, inspectTaskMessage } from "../tasks/chat-integration.js";
+import { ResponsesRequestSchema } from "../types.js";
+import { inspectWeatherMessage, respondToWeatherMessage } from "../weather/chat-integration.js";
+import { validateToolChoice } from "./request-validation.js";
+
+export function registerResponsesRoute(app: Express, context: AppContext): void {
+  app.post("/v1/responses", async (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    const parsed = ResponsesRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      res.status(400).json({
+        error: {
+          message: issue ? `${issue.path.join(".")}: ${issue.message}` : "Invalid request body",
+          type: "invalid_request_error",
+        },
+      });
+      return;
+    }
+
+    const toolChoiceError = validateToolChoice({
+      tools: parsed.data.tools ?? [],
+      toolChoice: parsed.data.tool_choice,
+    });
+    if (toolChoiceError) {
+      res.status(400).json({
+        error: {
+          message: toolChoiceError,
+          type: "invalid_request_error",
+        },
+      });
+      return;
+    }
+
+    const turn = normalizeRequest({
+      request: responseRequestToChatRequest(parsed.data),
+      defaultModelId: context.config.defaultModelId,
+    });
+    logRequestDebug({
+      enabled: context.config.debugLoggingEnabled,
+      route: "/v1/responses",
+      body: parsed.data,
+      turn,
+      previewChars: context.config.debugPreviewChars,
+    });
+    if (!turn.userText) {
+      logRequestDebug({
+        enabled: context.config.debugLoggingEnabled,
+        route: "/v1/responses",
+        body: parsed.data,
+        turn,
+        previewChars: context.config.debugPreviewChars,
+        note: "missing_user_text",
+      });
+      res.status(400).json({
+        error: {
+          message: "Missing user input in input.",
+          type: "invalid_request_error",
+        },
+      });
+      return;
+    }
+
+    const responseId = createResponseId();
+    const now = typeof req.body?.now === "string" ? req.body.now : undefined;
+    const taskMatch = inspectTaskMessage({
+      taskService: context.taskService,
+      turn,
+      explicitUser: parsed.data.user,
+      now,
+    });
+    logTaskInspection({
+      enabled: context.config.debugLoggingEnabled,
+      route: "/v1/responses",
+      userId: taskMatch.userId,
+      text: turn.userText,
+      inspection: taskMatch.inspection,
+      previewChars: context.config.debugPreviewChars,
+    });
+
+    const taskResult = taskMatch.inspection.shouldHandle
+      ? buildTaskEngineResult({
+          turn,
+          taskResult: context.taskService.processMessage({
+            userId: taskMatch.userId,
+            text: turn.userText,
+            now,
+          }),
+        })
+      : undefined;
+    const weatherMatch = !taskResult
+      ? inspectWeatherMessage({
+          weatherService: context.weatherService,
+          turn,
+          explicitUser: parsed.data.user,
+        })
+      : undefined;
+    if (weatherMatch) {
+      logWeatherInspection({
+        enabled: context.config.debugLoggingEnabled,
+        route: "/v1/responses",
+        userId: weatherMatch.userId,
+        text: turn.userText,
+        inspection: weatherMatch.inspection,
+        previewChars: context.config.debugPreviewChars,
+      });
+    }
+
+    const weatherResult =
+      !taskResult && weatherMatch?.inspection.shouldHandle
+        ? await respondToWeatherMessage({
+            weatherService: context.weatherService,
+            turn,
+            explicitUser: parsed.data.user,
+          })
+        : undefined;
+    const result = taskResult ?? weatherResult ?? context.replyEngine.respond(turn);
+    logResponseSelection({
+      enabled: context.config.debugLoggingEnabled,
+      route: "/v1/responses",
+      source: taskResult ? "task" : weatherResult ? "weather" : "reply",
+      finishReason: result.finishReason,
+      matchedIntentId: result.matchedIntentId,
+      templateId: result.templateId,
+      text: result.text,
+      previewChars: context.config.debugPreviewChars,
+    });
+    context.recordCompletion({
+      stream: turn.stream,
+      finishReason: result.finishReason,
+    });
+
+    const outputItemId = createResponseOutputId(
+      result.finishReason === "tool_calls" ? "fc" : "msg",
+    );
+
+    if (!turn.stream) {
+      res.json(buildResponsesResponse({ id: responseId, result, outputItemId }));
+      return;
+    }
+
+    if (result.finishReason === "tool_calls" && result.toolCalls?.length) {
+      await streamResponsesToolCall({
+        res,
+        id: responseId,
+        result,
+        outputItemId,
+      });
+      return;
+    }
+
+    await streamResponsesText({
+      res,
+      id: responseId,
+      result,
+      outputItemId,
+      initialDelayMs: context.config.streamInitialDelayMs,
+      chunkChars: context.config.streamChunkChars,
+    });
+  });
+}

package/src/routes/tasks.ts

@@ -0,0 +1,138 @@
+import type { Express } from "express";
+import { requireBearerAuth } from "../auth.js";
+import { logResponseSelection, logTaskInspection } from "../debug-log.js";
+import type { AppContext } from "../server.js";
+import {
+  TaskChatRequestSchema,
+  TaskListQuerySchema,
+  TaskReminderQuerySchema,
+  TaskStatsQuerySchema,
+} from "../tasks/types.js";
+
+function validationError(res: import("express").Response, issue?: { path: PropertyKey[]; message: string }) {
+  res.status(400).json({
+    error: {
+      message: issue ? `${issue.path.join(".")}: ${issue.message}` : "Invalid request",
+      type: "invalid_request_error",
+    },
+  });
+}
+
+export function registerTaskRoutes(app: Express, context: AppContext): void {
+  app.post("/v1/tasks/chat", (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    const parsed = TaskChatRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      validationError(res, parsed.error.issues[0]);
+      return;
+    }
+
+    const inspection = context.taskService.inspectMessage({
+      userId: parsed.data.user,
+      text: parsed.data.text,
+      now: parsed.data.now,
+    });
+    logTaskInspection({
+      enabled: context.config.debugLoggingEnabled,
+      route: "/v1/tasks/chat",
+      userId: parsed.data.user,
+      text: parsed.data.text,
+      inspection,
+      previewChars: context.config.debugPreviewChars,
+    });
+
+    const result = context.taskService.processMessage({
+      userId: parsed.data.user,
+      text: parsed.data.text,
+      now: parsed.data.now,
+    });
+    logResponseSelection({
+      enabled: context.config.debugLoggingEnabled,
+      route: "/v1/tasks/chat",
+      source: "task",
+      finishReason: "stop",
+      matchedIntentId: `task.${result.intent}`,
+      templateId: `task.${result.intent}`,
+      text: result.reply,
+      previewChars: context.config.debugPreviewChars,
+    });
+    res.json(result);
+  });
+
+  app.get("/v1/tasks", (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    const parsed = TaskListQuerySchema.safeParse({
+      user: typeof req.query.user === "string" ? req.query.user : undefined,
+      scope: typeof req.query.scope === "string" ? req.query.scope : undefined,
+      now: typeof req.query.now === "string" ? req.query.now : undefined,
+    });
+    if (!parsed.success) {
+      validationError(res, parsed.error.issues[0]);
+      return;
+    }
+
+    const data = context.taskService.listTasks(
+      parsed.data.user,
+      parsed.data.scope ?? "today",
+      parsed.data.now,
+    );
+    res.json({ object: "list", data });
+  });
+
+  app.get("/v1/tasks/reminders/pending", (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    const parsed = TaskReminderQuerySchema.safeParse({
+      user: typeof req.query.user === "string" ? req.query.user : undefined,
+      now: typeof req.query.now === "string" ? req.query.now : undefined,
+    });
+    if (!parsed.success) {
+      validationError(res, parsed.error.issues[0]);
+      return;
+    }
+
+    const data = context.taskService.listPendingReminders(parsed.data.user, parsed.data.now);
+    res.json({ object: "list", data, count: data.length });
+  });
+
+  app.get("/v1/tasks/stats", (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    const parsed = TaskStatsQuerySchema.safeParse({
+      user: typeof req.query.user === "string" ? req.query.user : undefined,
+      now: typeof req.query.now === "string" ? req.query.now : undefined,
+    });
+    if (!parsed.success) {
+      validationError(res, parsed.error.issues[0]);
+      return;
+    }
+
+    const data = context.taskService.getStats(parsed.data.user, parsed.data.now);
+    res.json({ object: "task.stats", data });
+  });
+
+  app.post("/admin/tasks/dispatch", (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    const now = typeof req.body?.now === "string" ? req.body.now : undefined;
+    const dispatched = context.taskService.dispatchDueReminders(now);
+    res.json({ ok: true, dispatched });
+  });
+}

package/src/runtime-stats.ts

@@ -0,0 +1,80 @@
+import { SessionStore } from "./core/session-store.js";
+import type { LoadedPack } from "./types.js";
+
+export type RuntimeStatsSnapshot = {
+  startedAt: string;
+  lastRequestAt?: string;
+  lastReloadAt?: string;
+  requestsTotal: number;
+  streamedRequests: number;
+  textResponses: number;
+  toolCallResponses: number;
+  authFailures: number;
+  reloadCount: number;
+  activeSessions: number;
+  pack: {
+    id: string;
+    models: string[];
+    intents: number;
+    faqs: number;
+    scenarios: number;
+    templates: number;
+  };
+};
+
+export class RuntimeStats {
+  private readonly startedAt = new Date().toISOString();
+  private lastRequestAt?: string;
+  private lastReloadAt?: string;
+  private requestsTotal = 0;
+  private streamedRequests = 0;
+  private textResponses = 0;
+  private toolCallResponses = 0;
+  private authFailures = 0;
+  private reloadCount = 0;
+
+  recordAuthFailure(): void {
+    this.authFailures += 1;
+  }
+
+  recordCompletion(params: { stream: boolean; finishReason: "stop" | "tool_calls" }): void {
+    this.requestsTotal += 1;
+    this.lastRequestAt = new Date().toISOString();
+    if (params.stream) {
+      this.streamedRequests += 1;
+    }
+    if (params.finishReason === "tool_calls") {
+      this.toolCallResponses += 1;
+      return;
+    }
+    this.textResponses += 1;
+  }
+
+  recordReload(): void {
+    this.reloadCount += 1;
+    this.lastReloadAt = new Date().toISOString();
+  }
+
+  snapshot(pack: LoadedPack, sessionStore: SessionStore): RuntimeStatsSnapshot {
+    return {
+      startedAt: this.startedAt,
+      lastRequestAt: this.lastRequestAt,
+      lastReloadAt: this.lastReloadAt,
+      requestsTotal: this.requestsTotal,
+      streamedRequests: this.streamedRequests,
+      textResponses: this.textResponses,
+      toolCallResponses: this.toolCallResponses,
+      authFailures: this.authFailures,
+      reloadCount: this.reloadCount,
+      activeSessions: sessionStore.size(),
+      pack: {
+        id: pack.manifest.id,
+        models: [...pack.manifest.models],
+        intents: pack.intents.length,
+        faqs: pack.faqs.length,
+        scenarios: pack.scenariosById.size,
+        templates: pack.templatesById.size,
+      },
+    };
+  }
+}