openclaw-server 0.1.0

package/src/core/tool-engine.ts

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import type {
+  ChatToolCall,
+  IntentDefinition,
+  LoadedPack,
+  NormalizedTurn,
+  ToolDefinition,
+  ToolStrategyDefinition,
+} from "../types.js";
+
+function requestedToolName(turn: NormalizedTurn): string | undefined {
+  if (!turn.toolChoice || typeof turn.toolChoice !== "object") {
+    return undefined;
+  }
+  return turn.toolChoice.function.name;
+}
+
+function pickProvidedTool(
+  tools: ToolDefinition[],
+  strategy: ToolStrategyDefinition,
+): ToolDefinition | undefined {
+  return tools.find((tool) => strategy.preferredNames.includes(tool.function.name));
+}
+
+export function selectToolCall(params: {
+  turn: NormalizedTurn;
+  intent: IntentDefinition;
+  pack: LoadedPack;
+}): ChatToolCall | undefined {
+  if (!params.turn.tools.length || params.turn.toolChoice === "none") {
+    return undefined;
+  }
+  if (!params.intent.toolStrategyId) {
+    return undefined;
+  }
+
+  const strategy = params.pack.toolStrategiesById.get(params.intent.toolStrategyId);
+  if (!strategy) {
+    return undefined;
+  }
+
+  const picked = pickProvidedTool(params.turn.tools, strategy);
+  if (!picked) {
+    return undefined;
+  }
+
+  const requiredToolName = requestedToolName(params.turn);
+  if (requiredToolName && requiredToolName !== picked.function.name) {
+    return undefined;
+  }
+
+  return {
+    id: `call_${randomUUID().replace(/-/g, "").slice(0, 24)}`,
+    type: "function",
+    function: {
+      name: picked.function.name,
+      arguments: JSON.stringify(strategy.arguments ?? {}),
+    },
+  };
+}

package/src/debug-log.ts

@@ -0,0 +1,211 @@
+import { extractTextContent } from "./core/normalizer.js";
+import type { TaskMessageInspection } from "./tasks/service.js";
+import type { NormalizedTurn } from "./types.js";
+import type { WeatherMessageInspection } from "./weather/types.js";
+
+function previewText(text: string, limit: number): string {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= limit) {
+    return normalized;
+  }
+  return `${normalized.slice(0, limit)}...`;
+}
+
+function summarizeContent(content: unknown, limit: number): string {
+  if (typeof content === "string") {
+    return `string:${previewText(content, limit)}`;
+  }
+  if (Array.isArray(content)) {
+    const types = content
+      .slice(0, 4)
+      .map((part) => {
+        if (!part || typeof part !== "object") {
+          return typeof part;
+        }
+        return String((part as { type?: unknown }).type ?? "object");
+      })
+      .join(",");
+    const text = extractTextContent(content);
+    return `array[${types || "empty"}]:${previewText(text, limit)}`;
+  }
+  if (content && typeof content === "object") {
+    const text = extractTextContent(content);
+    const keys = Object.keys(content as Record<string, unknown>).slice(0, 4).join(",");
+    return `object{${keys || "no-keys"}}:${previewText(text, limit)}`;
+  }
+  return String(content);
+}
+
+function summarizeMessages(messages: unknown[], limit: number): string {
+  if (messages.length === 0) {
+    return "[]";
+  }
+
+  const summary = messages
+    .slice(0, 5)
+    .map((message, index) => {
+      if (!message || typeof message !== "object") {
+        return `${index}:invalid`;
+      }
+      const record = message as { role?: unknown; content?: unknown };
+      const role = typeof record.role === "string" ? record.role : "unknown";
+      return `${index}:${role}:${summarizeContent(record.content, limit)}`;
+    })
+    .join(" | ");
+
+  if (messages.length <= 5) {
+    return summary;
+  }
+
+  return `${summary} | +${messages.length - 5} more`;
+}
+
+function summarizeResponsesInput(input: unknown, limit: number): string {
+  const items = Array.isArray(input) ? input : [input];
+  return items
+    .slice(0, 5)
+    .map((item, index) => {
+      if (typeof item === "string") {
+        return `${index}:string:${previewText(item, limit)}`;
+      }
+      if (!item || typeof item !== "object") {
+        return `${index}:invalid`;
+      }
+
+      const record = item as { type?: unknown; role?: unknown; content?: unknown; text?: unknown };
+      const type = typeof record.type === "string" ? record.type : "item";
+      const role = typeof record.role === "string" ? record.role : "user";
+      const content = record.content ?? record.text ?? item;
+      return `${index}:${type}:${role}:${summarizeContent(content, limit)}`;
+    })
+    .join(" | ");
+}
+
+function formatField(key: string, value: unknown): string | undefined {
+  if (value === undefined || value === null || value === "") {
+    return undefined;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return `${key}=${value}`;
+  }
+  return `${key}=${JSON.stringify(String(value))}`;
+}
+
+function logLine(namespace: string, fields: Record<string, unknown>): void {
+  const parts = Object.entries(fields)
+    .map(([key, value]) => formatField(key, value))
+    .filter((value): value is string => Boolean(value));
+
+  console.log(`[openclaw-server][${namespace}] ${parts.join(" ")}`);
+}
+
+export function logRequestDebug(params: {
+  enabled: boolean;
+  route: string;
+  body: unknown;
+  turn?: NormalizedTurn;
+  previewChars: number;
+  note?: string;
+}): void {
+  if (!params.enabled || !params.body || typeof params.body !== "object") {
+    return;
+  }
+
+  const record = params.body as {
+    model?: unknown;
+    user?: unknown;
+    stream?: unknown;
+    messages?: unknown;
+    input?: unknown;
+  };
+
+  logLine("request", {
+    route: params.route,
+    note: params.note,
+    model: typeof record.model === "string" ? record.model : undefined,
+    user: typeof record.user === "string" ? record.user : undefined,
+    stream: typeof record.stream === "boolean" ? record.stream : undefined,
+    userText: params.turn ? previewText(params.turn.userText, params.previewChars) : undefined,
+    messages: Array.isArray(record.messages)
+      ? summarizeMessages(record.messages, params.previewChars)
+      : undefined,
+    input:
+      record.input !== undefined
+        ? summarizeResponsesInput(record.input, params.previewChars)
+        : undefined,
+  });
+}
+
+export function logTaskInspection(params: {
+  enabled: boolean;
+  route: string;
+  userId: string;
+  text: string;
+  inspection: TaskMessageInspection;
+  previewChars: number;
+}): void {
+  if (!params.enabled) {
+    return;
+  }
+
+  logLine("task", {
+    route: params.route,
+    userId: params.userId,
+    handled: params.inspection.shouldHandle,
+    reason: params.inspection.reason,
+    queryScope: params.inspection.queryScope,
+    actionKind: params.inspection.actionKind,
+    draftKind: params.inspection.draftKind,
+    title: params.inspection.title,
+    dueAt: params.inspection.dueAtText,
+    text: previewText(params.text, params.previewChars),
+  });
+}
+
+export function logWeatherInspection(params: {
+  enabled: boolean;
+  route: string;
+  userId: string;
+  text: string;
+  inspection: WeatherMessageInspection;
+  previewChars: number;
+}): void {
+  if (!params.enabled) {
+    return;
+  }
+
+  logLine("weather", {
+    route: params.route,
+    userId: params.userId,
+    handled: params.inspection.shouldHandle,
+    reason: params.inspection.reason,
+    missing: params.inspection.missing,
+    location: params.inspection.location,
+    day: params.inspection.day,
+    text: previewText(params.text, params.previewChars),
+  });
+}
+
+export function logResponseSelection(params: {
+  enabled: boolean;
+  route: string;
+  source: "task" | "weather" | "reply";
+  finishReason: "stop" | "tool_calls";
+  matchedIntentId?: string;
+  templateId?: string;
+  text?: string | null;
+  previewChars: number;
+}): void {
+  if (!params.enabled) {
+    return;
+  }
+
+  logLine("response", {
+    route: params.route,
+    source: params.source,
+    finishReason: params.finishReason,
+    matchedIntentId: params.matchedIntentId,
+    templateId: params.templateId,
+    text: params.text ? previewText(params.text, params.previewChars) : undefined,
+  });
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+import { loadConfig } from "./config.js";
+import { createApp, createAppContext } from "./server.js";
+
+const config = loadConfig();
+const context = await createAppContext(config);
+const app = createApp(context);
+
+const server = app.listen(config.port, config.host, () => {
+  console.log(
+    `[openclaw-server] listening on http://${config.host}:${config.port} using pack=${context.pack.manifest.id} model=${config.defaultModelId} debug=${config.debugLoggingEnabled ? "on" : "off"}`,
+  );
+});
+
+function shutdown(signal: string): void {
+  server.close(() => {
+    context.dispose();
+    console.log(`[openclaw-server] stopped after ${signal}`);
+    process.exit(0);
+  });
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));

package/src/openai.ts

@@ -0,0 +1,79 @@
+import { randomUUID } from "node:crypto";
+import type { EngineResult, ChatToolCall } from "./types.js";
+
+export function createChatCompletionId(): string {
+  return `chatcmpl_${randomUUID().replace(/-/g, "")}`;
+}
+
+function createUsage() {
+  return {
+    prompt_tokens: 0,
+    completion_tokens: 0,
+    total_tokens: 0,
+  };
+}
+
+export function buildTextCompletionResponse(params: {
+  id: string;
+  model: string;
+  text: string;
+}): Record<string, unknown> {
+  return {
+    id: params.id,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: params.model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: params.text,
+        },
+        finish_reason: "stop",
+      },
+    ],
+    usage: createUsage(),
+  };
+}
+
+export function buildToolCompletionResponse(params: {
+  id: string;
+  model: string;
+  toolCalls: ChatToolCall[];
+}): Record<string, unknown> {
+  return {
+    id: params.id,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: params.model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: null,
+          tool_calls: params.toolCalls,
+        },
+        finish_reason: "tool_calls",
+      },
+    ],
+    usage: createUsage(),
+  };
+}
+
+export function buildCompletionResponse(id: string, result: EngineResult): Record<string, unknown> {
+  if (result.finishReason === "tool_calls" && result.toolCalls?.length) {
+    return buildToolCompletionResponse({
+      id,
+      model: result.model,
+      toolCalls: result.toolCalls,
+    });
+  }
+
+  return buildTextCompletionResponse({
+    id,
+    model: result.model,
+    text: result.text ?? "No response available.",
+  });
+}

package/src/response-api.ts

@@ -0,0 +1,107 @@
+import { randomUUID } from "node:crypto";
+import type { ChatToolCall, EngineResult } from "./types.js";
+
+type ResponseOutputItem = Record<string, unknown>;
+
+function compactUuid(): string {
+  return randomUUID().replace(/-/g, "");
+}
+
+function createUsage() {
+  return {
+    input_tokens: 0,
+    output_tokens: 0,
+    total_tokens: 0,
+  };
+}
+
+export function createResponseId(): string {
+  return `resp_${compactUuid()}`;
+}
+
+export function createResponseOutputId(prefix: "msg" | "fc"): string {
+  return `${prefix}_${compactUuid()}`;
+}
+
+export function buildResponseMessageItem(
+  text: string,
+  itemId = createResponseOutputId("msg"),
+): ResponseOutputItem {
+  return {
+    id: itemId,
+    type: "message",
+    status: "completed",
+    role: "assistant",
+    content: [
+      {
+        type: "output_text",
+        text,
+        annotations: [],
+      },
+    ],
+  };
+}
+
+export function buildResponseFunctionCallItem(
+  toolCall: ChatToolCall,
+  itemId = createResponseOutputId("fc"),
+): ResponseOutputItem {
+  return {
+    id: itemId,
+    type: "function_call",
+    call_id: toolCall.id,
+    name: toolCall.function.name,
+    arguments: toolCall.function.arguments,
+    status: "completed",
+  };
+}
+
+export function buildResponsesInProgressResponse(params: {
+  id: string;
+  model: string;
+  createdAt?: number;
+}): Record<string, unknown> {
+  return {
+    id: params.id,
+    object: "response",
+    created_at: params.createdAt ?? Math.floor(Date.now() / 1000),
+    status: "in_progress",
+    error: null,
+    model: params.model,
+    output: [],
+    output_text: "",
+  };
+}
+
+export function buildResponsesResponse(params: {
+  id: string;
+  result: EngineResult;
+  createdAt?: number;
+  outputItemId?: string;
+}): Record<string, unknown> {
+  const createdAt = params.createdAt ?? Math.floor(Date.now() / 1000);
+  const base = {
+    id: params.id,
+    object: "response",
+    created_at: createdAt,
+    status: "completed",
+    error: null,
+    model: params.result.model,
+    usage: createUsage(),
+  };
+
+  if (params.result.finishReason === "tool_calls" && params.result.toolCalls?.length) {
+    return {
+      ...base,
+      output: [buildResponseFunctionCallItem(params.result.toolCalls[0], params.outputItemId)],
+      output_text: "",
+    };
+  }
+
+  const text = params.result.text ?? "No response available.";
+  return {
+    ...base,
+    output: [buildResponseMessageItem(text, params.outputItemId)],
+    output_text: text,
+  };
+}

package/src/routes/admin.ts

@@ -0,0 +1,32 @@
+import type { Express } from "express";
+import { requireBearerAuth } from "../auth.js";
+import type { AppContext } from "../server.js";
+
+export function registerAdminRoutes(app: Express, context: AppContext): void {
+  app.get("/admin/stats", (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    res.json(context.snapshotStats());
+  });
+
+  app.post("/admin/packs/reload", async (req, res, next) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    try {
+      await context.reloadPack();
+      res.json({
+        ok: true,
+        packId: context.pack.manifest.id,
+        reloadedAt: context.snapshotStats().lastReloadAt,
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+}

package/src/routes/chat-completions.ts

@@ -0,0 +1,173 @@
+import type { Express } from "express";
+import { requireBearerAuth } from "../auth.js";
+import { normalizeRequest } from "../core/normalizer.js";
+import { streamTextCompletion, streamToolCallCompletion } from "../core/stream-renderer.js";
+import {
+  logRequestDebug,
+  logResponseSelection,
+  logTaskInspection,
+  logWeatherInspection,
+} from "../debug-log.js";
+import { buildCompletionResponse, createChatCompletionId } from "../openai.js";
+import type { AppContext } from "../server.js";
+import { buildTaskEngineResult, inspectTaskMessage } from "../tasks/chat-integration.js";
+import { ChatCompletionsRequestSchema } from "../types.js";
+import { inspectWeatherMessage, respondToWeatherMessage } from "../weather/chat-integration.js";
+import { validateToolChoice } from "./request-validation.js";
+
+export function registerChatCompletionsRoute(app: Express, context: AppContext): void {
+  app.post("/v1/chat/completions", async (req, res) => {
+    if (!requireBearerAuth(req, res, context.config)) {
+      context.recordAuthFailure();
+      return;
+    }
+
+    const parsed = ChatCompletionsRequestSchema.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: parsed.data,
+      defaultModelId: context.config.defaultModelId,
+    });
+    logRequestDebug({
+      enabled: context.config.debugLoggingEnabled,
+      route: "/v1/chat/completions",
+      body: parsed.data,
+      turn,
+      previewChars: context.config.debugPreviewChars,
+    });
+    if (!turn.userText) {
+      logRequestDebug({
+        enabled: context.config.debugLoggingEnabled,
+        route: "/v1/chat/completions",
+        body: parsed.data,
+        turn,
+        previewChars: context.config.debugPreviewChars,
+        note: "missing_user_text",
+      });
+      res.status(400).json({
+        error: {
+          message: "Missing user message in messages.",
+          type: "invalid_request_error",
+        },
+      });
+      return;
+    }
+
+    const completionId = createChatCompletionId();
+    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/chat/completions",
+      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/chat/completions",
+        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/chat/completions",
+      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,
+    });
+
+    if (!turn.stream) {
+      res.json(buildCompletionResponse(completionId, result));
+      return;
+    }
+
+    if (result.finishReason === "tool_calls" && result.toolCalls?.length) {
+      await streamToolCallCompletion({
+        res,
+        id: completionId,
+        model: result.model,
+        toolCall: result.toolCalls[0],
+      });
+      return;
+    }
+
+    await streamTextCompletion({
+      res,
+      id: completionId,
+      model: result.model,
+      text: result.text ?? "No response available.",
+      initialDelayMs: context.config.streamInitialDelayMs,
+      chunkChars: context.config.streamChunkChars,
+    });
+  });
+}

package/src/routes/health.ts

@@ -0,0 +1,7 @@
+import type { Express } from "express";
+
+export function registerHealthRoute(app: Express): void {
+  app.get("/healthz", (_req, res) => {
+    res.json({ ok: true, version: "0.1.0" });
+  });
+}