openclaw-server 0.1.0

package/src/tasks/timezone.ts

@@ -0,0 +1,171 @@
+export type TimeZoneDateParts = {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+};
+
+type TimeZoneDateInput = {
+  year: number;
+  month: number;
+  day: number;
+  hour?: number;
+  minute?: number;
+  second?: number;
+};
+
+type DateBounds = {
+  nowIso: string;
+  todayStartIso: string;
+  tomorrowStartIso: string;
+  dayAfterTomorrowIso: string;
+  nextWeekStartIso: string;
+};
+
+const formatterCache = new Map<string, Intl.DateTimeFormat>();
+
+function getFormatter(timeZone: string): Intl.DateTimeFormat {
+  const cached = formatterCache.get(timeZone);
+  if (cached) {
+    return cached;
+  }
+
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+    hourCycle: "h23",
+  });
+  formatterCache.set(timeZone, formatter);
+  return formatter;
+}
+
+function pad(value: number): string {
+  return `${value}`.padStart(2, "0");
+}
+
+function shiftCalendarDate(parts: Pick<TimeZoneDateParts, "year" | "month" | "day">, days: number) {
+  const shifted = new Date(Date.UTC(parts.year, parts.month - 1, parts.day + days));
+  return {
+    year: shifted.getUTCFullYear(),
+    month: shifted.getUTCMonth() + 1,
+    day: shifted.getUTCDate(),
+  };
+}
+
+export function getTimeZoneDateParts(date: Date, timeZone: string): TimeZoneDateParts {
+  const values: Partial<Record<keyof TimeZoneDateParts, number>> = {};
+
+  for (const part of getFormatter(timeZone).formatToParts(date)) {
+    if (part.type === "literal") {
+      continue;
+    }
+    if (
+      part.type === "year" ||
+      part.type === "month" ||
+      part.type === "day" ||
+      part.type === "hour" ||
+      part.type === "minute" ||
+      part.type === "second"
+    ) {
+      values[part.type] = Number(part.value);
+    }
+  }
+
+  return {
+    year: values.year ?? 0,
+    month: values.month ?? 0,
+    day: values.day ?? 0,
+    hour: values.hour === 24 ? 0 : (values.hour ?? 0),
+    minute: values.minute ?? 0,
+    second: values.second ?? 0,
+  };
+}
+
+function getTimeZoneOffsetMs(date: Date, timeZone: string): number {
+  const parts = getTimeZoneDateParts(date, timeZone);
+  const zonedAsUtc = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second,
+  );
+  return zonedAsUtc - date.getTime();
+}
+
+export function zonedDateTimeToDate(input: TimeZoneDateInput, timeZone: string): Date {
+  const localAsUtc = Date.UTC(
+    input.year,
+    input.month - 1,
+    input.day,
+    input.hour ?? 0,
+    input.minute ?? 0,
+    input.second ?? 0,
+  );
+
+  let candidate = localAsUtc;
+  for (let index = 0; index < 3; index += 1) {
+    const next = localAsUtc - getTimeZoneOffsetMs(new Date(candidate), timeZone);
+    if (next === candidate) {
+      break;
+    }
+    candidate = next;
+  }
+
+  return new Date(candidate);
+}
+
+export function startOfDayInTimeZone(date: Date, timeZone: string): Date {
+  const parts = getTimeZoneDateParts(date, timeZone);
+  return zonedDateTimeToDate(
+    {
+      year: parts.year,
+      month: parts.month,
+      day: parts.day,
+    },
+    timeZone,
+  );
+}
+
+export function addDaysInTimeZone(date: Date, days: number, timeZone: string): Date {
+  const parts = getTimeZoneDateParts(date, timeZone);
+  const shifted = shiftCalendarDate(parts, days);
+  return zonedDateTimeToDate(
+    {
+      year: shifted.year,
+      month: shifted.month,
+      day: shifted.day,
+      hour: parts.hour,
+      minute: parts.minute,
+      second: parts.second,
+    },
+    timeZone,
+  );
+}
+
+export function buildDateBounds(now: Date, timeZone: string): DateBounds {
+  const todayStart = startOfDayInTimeZone(now, timeZone);
+  const tomorrowStart = addDaysInTimeZone(todayStart, 1, timeZone);
+
+  return {
+    nowIso: now.toISOString(),
+    todayStartIso: todayStart.toISOString(),
+    tomorrowStartIso: tomorrowStart.toISOString(),
+    dayAfterTomorrowIso: addDaysInTimeZone(todayStart, 2, timeZone).toISOString(),
+    nextWeekStartIso: addDaysInTimeZone(todayStart, 7, timeZone).toISOString(),
+  };
+}
+
+export function formatLocalDateTime(date: Date, timeZone: string): string {
+  const parts = getTimeZoneDateParts(date, timeZone);
+  return `${parts.year}-${pad(parts.month)}-${pad(parts.day)} ${pad(parts.hour)}:${pad(parts.minute)}`;
+}

package/src/tasks/types.ts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+
+export const TaskScopeSchema = z.enum(["today", "tomorrow", "week", "overdue", "all"]);
+export type TaskScope = z.infer<typeof TaskScopeSchema>;
+
+const IsoDateTimeSchema = z.string().datetime({ offset: true });
+
+export const TaskChatRequestSchema = z.object({
+  user: z.string().min(1),
+  text: z.string().min(1),
+  now: IsoDateTimeSchema.optional(),
+});
+
+export const TaskListQuerySchema = z.object({
+  user: z.string().min(1),
+  scope: TaskScopeSchema.optional(),
+  now: IsoDateTimeSchema.optional(),
+});
+
+export const TaskReminderQuerySchema = z.object({
+  user: z.string().min(1),
+  now: IsoDateTimeSchema.optional(),
+});
+
+export const TaskStatsQuerySchema = z.object({
+  user: z.string().min(1),
+  now: IsoDateTimeSchema.optional(),
+});
+
+export type TaskChatRequest = z.infer<typeof TaskChatRequestSchema>;
+export type TaskListQuery = z.infer<typeof TaskListQuerySchema>;
+export type TaskReminderQuery = z.infer<typeof TaskReminderQuerySchema>;
+export type TaskStatsQuery = z.infer<typeof TaskStatsQuerySchema>;
+
+export type ConversationStatus = "awaiting_reminder";
+export type TaskStatus = "scheduled" | "done" | "cancelled";
+export type ReminderStatus = "scheduled" | "sent" | "acked" | "cancelled";
+
+export type ReminderPreference = {
+  offsetMinutes: number | null;
+  matchedText: string;
+};
+
+export type ParsedTaskDraft =
+  | {
+      kind: "ready";
+      title: string;
+      dueAt: Date;
+      reminderOffsetMinutes?: number | null;
+    }
+  | {
+      kind: "missing_time";
+      title: string;
+    }
+  | {
+      kind: "missing_title";
+    };
+
+export type ParsedTaskAction =
+  | { kind: "done" }
+  | { kind: "cancel" }
+  | { kind: "snooze"; minutes: number };
+
+export type TaskSummary = {
+  id: string;
+  userId: string;
+  title: string;
+  sourceText: string;
+  dueAt: string;
+  dueAtText: string;
+  timezone: string;
+  status: TaskStatus;
+  reminderOffsetMinutes: number | null;
+  createdAt: string;
+  updatedAt: string;
+  completedAt: string | null;
+  cancelledAt: string | null;
+};
+
+export type ReminderSummary = {
+  id: string;
+  taskId: string;
+  userId: string;
+  title: string;
+  dueAt: string;
+  dueAtText: string;
+  remindAt: string;
+  remindAtText: string;
+  message: string;
+  status: ReminderStatus;
+};
+
+export type TaskStats = {
+  totalTasks: number;
+  scheduledTasks: number;
+  doneTasks: number;
+  cancelledTasks: number;
+  overdueTasks: number;
+  todayTasks: number;
+  todayDoneTasks: number;
+  pendingReminders: number;
+};
+
+export type ConversationDraft = {
+  userId: string;
+  status: ConversationStatus;
+  sourceText: string;
+  title: string;
+  dueAt: string;
+  reminderOffsetMinutes: number | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type TaskChatResult = {
+  reply: string;
+  intent:
+    | "draft_created"
+    | "task_created"
+    | "task_query"
+    | "task_action"
+    | "clarify"
+    | "help";
+  task?: TaskSummary;
+  tasks?: TaskSummary[];
+  reminders?: ReminderSummary[];
+  stats?: TaskStats;
+};

package/src/types.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+
+export const ChatMessageSchema = z
+  .object({
+    role: z.string().optional(),
+    content: z.unknown().optional(),
+    name: z.string().optional(),
+  })
+  .passthrough();
+
+export const ToolDefinitionSchema = z
+  .object({
+    type: z.literal("function"),
+    function: z
+      .object({
+        name: z.string(),
+        description: z.string().optional(),
+        parameters: z.record(z.string(), z.unknown()).optional(),
+      })
+      .passthrough(),
+  })
+  .passthrough();
+
+export const NamedToolChoiceSchema = z
+  .object({
+    type: z.literal("function"),
+    function: z.object({ name: z.string() }).passthrough(),
+  })
+  .passthrough();
+
+export const ToolChoiceSchema = z.union([
+  z.literal("auto"),
+  z.literal("none"),
+  z.literal("required"),
+  NamedToolChoiceSchema,
+]);
+
+export const ChatCompletionsRequestSchema = z
+  .object({
+    model: z.string().optional(),
+    stream: z.boolean().optional(),
+    user: z.string().optional(),
+    messages: z.array(ChatMessageSchema).min(1),
+    tools: z.array(ToolDefinitionSchema).optional(),
+    tool_choice: ToolChoiceSchema.optional(),
+    temperature: z.number().optional(),
+    max_tokens: z.number().int().positive().optional(),
+  })
+  .passthrough();
+
+export const ResponseInputTextItemSchema = z
+  .object({
+    type: z.literal("input_text"),
+    text: z.string(),
+  })
+  .passthrough();
+
+export const ResponseInputMessageSchema = z
+  .object({
+    type: z.literal("message").optional(),
+    role: z.string().optional(),
+    content: z.unknown().optional(),
+    text: z.string().optional(),
+  })
+  .passthrough();
+
+export const ResponseInputItemSchema = z.union([
+  z.string(),
+  ResponseInputTextItemSchema,
+  ResponseInputMessageSchema,
+]);
+
+export const ResponsesRequestSchema = z
+  .object({
+    model: z.string().optional(),
+    stream: z.boolean().optional(),
+    user: z.string().optional(),
+    instructions: z.string().optional(),
+    input: z.union([ResponseInputItemSchema, z.array(ResponseInputItemSchema).min(1)]),
+    tools: z.array(ToolDefinitionSchema).optional(),
+    tool_choice: ToolChoiceSchema.optional(),
+    max_output_tokens: z.number().int().positive().optional(),
+  })
+  .passthrough();
+
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+export type ToolChoice = z.infer<typeof ToolChoiceSchema>;
+export type ChatCompletionsRequest = z.infer<typeof ChatCompletionsRequestSchema>;
+export type ResponseInputTextItem = z.infer<typeof ResponseInputTextItemSchema>;
+export type ResponseInputMessage = z.infer<typeof ResponseInputMessageSchema>;
+export type ResponsesInputItem = z.infer<typeof ResponseInputItemSchema>;
+export type ResponsesRequest = z.infer<typeof ResponsesRequestSchema>;
+
+export const PackManifestSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  models: z.array(z.string()).min(1),
+  fallbackTemplateId: z.string(),
+  continueKeywords: z.array(z.string()).default([]),
+});
+
+export const TemplateDefinitionSchema = z.object({
+  id: z.string(),
+  variants: z.array(z.string()).min(1),
+});
+
+export const IntentDefinitionSchema = z.object({
+  id: z.string(),
+  priority: z.number().default(0),
+  matchAny: z.array(z.string()).default([]),
+  regex: z.array(z.string()).default([]),
+  responseTemplateId: z.string().optional(),
+  scenarioId: z.string().optional(),
+  toolStrategyId: z.string().optional(),
+});
+
+export const FaqDefinitionSchema = z.object({
+  id: z.string(),
+  priority: z.number().default(0),
+  questionPatterns: z.array(z.string()).min(1),
+  responseTemplateId: z.string(),
+});
+
+export const ScenarioNodeDefinitionSchema = z.object({
+  id: z.string(),
+  responseTemplateId: z.string(),
+  nextId: z.string().optional(),
+  continueKeywords: z.array(z.string()).default([]),
+  end: z.boolean().optional(),
+});
+
+export const ScenarioDefinitionSchema = z.object({
+  id: z.string(),
+  entryIntentId: z.string(),
+  nodes: z.array(ScenarioNodeDefinitionSchema).min(1),
+});
+
+export const ToolStrategyDefinitionSchema = z.object({
+  id: z.string(),
+  preferredNames: z.array(z.string()).min(1),
+  arguments: z.record(z.string(), z.unknown()).default({}),
+});
+
+export type PackManifest = z.infer<typeof PackManifestSchema>;
+export type TemplateDefinition = z.infer<typeof TemplateDefinitionSchema>;
+export type IntentDefinition = z.infer<typeof IntentDefinitionSchema>;
+export type FaqDefinition = z.infer<typeof FaqDefinitionSchema>;
+export type ScenarioNodeDefinition = z.infer<typeof ScenarioNodeDefinitionSchema>;
+export type ScenarioDefinition = z.infer<typeof ScenarioDefinitionSchema>;
+export type ToolStrategyDefinition = z.infer<typeof ToolStrategyDefinitionSchema>;
+
+export type LoadedPack = {
+  manifest: PackManifest;
+  templatesById: Map<string, TemplateDefinition>;
+  intents: IntentDefinition[];
+  faqs: FaqDefinition[];
+  scenariosById: Map<string, ScenarioDefinition>;
+  toolStrategiesById: Map<string, ToolStrategyDefinition>;
+};
+
+export type NormalizedTurn = {
+  sessionId: string;
+  locale: "zh-CN" | "en-US" | "mixed";
+  model: string;
+  stream: boolean;
+  systemPrompts: string[];
+  history: Array<{ role: string; text: string }>;
+  userText: string;
+  normalizedUserText: string;
+  tools: ToolDefinition[];
+  toolChoice?: ToolChoice;
+};
+
+export type SessionState = {
+  sessionId: string;
+  locale: string;
+  activeScenarioId?: string;
+  activeNodeId?: string;
+  lastIntentId?: string;
+  lastTemplateId?: string;
+  turnCount: number;
+};
+
+export type ChatToolCall = {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+};
+
+export type EngineResult = {
+  model: string;
+  sessionId: string;
+  text: string | null;
+  finishReason: "stop" | "tool_calls";
+  matchedIntentId?: string;
+  templateId?: string;
+  toolCalls?: ChatToolCall[];
+};

package/src/weather/chat-integration.ts

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+import type { EngineResult, NormalizedTurn } from "../types.js";
+import type { WeatherMessageInspection } from "./types.js";
+import type { WeatherService } from "./service.js";
+
+function firstUserText(turn: NormalizedTurn): string {
+  return turn.history.find((message) => message.role === "user")?.text ?? turn.userText;
+}
+
+export function resolveWeatherUserId(turn: NormalizedTurn, explicitUser?: string): string {
+  if (explicitUser?.trim()) {
+    return explicitUser.trim();
+  }
+
+  const seed = `${turn.model}\n${firstUserText(turn)}`;
+  const digest = createHash("sha1").update(seed).digest("hex").slice(0, 16);
+  return `weather:${digest}`;
+}
+
+export function inspectWeatherMessage(params: {
+  weatherService: WeatherService;
+  turn: NormalizedTurn;
+  explicitUser?: string;
+}): { userId: string; inspection: WeatherMessageInspection } {
+  const userId = resolveWeatherUserId(params.turn, params.explicitUser);
+  const inspection = params.weatherService.inspectMessage({
+    userId,
+    text: params.turn.userText,
+  });
+  return { userId, inspection };
+}
+
+export async function respondToWeatherMessage(params: {
+  weatherService: WeatherService;
+  turn: NormalizedTurn;
+  explicitUser?: string;
+}): Promise<EngineResult | undefined> {
+  const { userId, inspection } = inspectWeatherMessage(params);
+  if (!inspection.shouldHandle) {
+    return undefined;
+  }
+
+  const weatherResult = await params.weatherService.processMessage({
+    userId,
+    text: params.turn.userText,
+  });
+
+  return {
+    model: params.turn.model,
+    sessionId: params.turn.sessionId,
+    text: weatherResult.reply,
+    finishReason: "stop",
+    matchedIntentId: `weather.${weatherResult.intent}`,
+    templateId: `weather.${weatherResult.intent}`,
+  };
+}