150 lines
4.4 KiB
TypeScript
150 lines
4.4 KiB
TypeScript
import { Buffer } from "node:buffer";
|
|
|
|
import type WebSocket from "ws";
|
|
|
|
import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
|
|
|
|
export type ResponsePrefixContext = {
|
|
model?: string;
|
|
modelFull?: string;
|
|
provider?: string;
|
|
thinkingLevel?: string;
|
|
identityName?: string;
|
|
};
|
|
|
|
export function extractShortModelName(fullModel: string): string {
|
|
const slash = fullModel.lastIndexOf("/");
|
|
const modelPart = slash >= 0 ? fullModel.slice(slash + 1) : fullModel;
|
|
return modelPart.replace(/-\d{8}$/, "").replace(/-latest$/, "");
|
|
}
|
|
|
|
export function formatInboundFromLabel(params: {
|
|
isGroup: boolean;
|
|
groupLabel?: string;
|
|
groupId?: string;
|
|
directLabel: string;
|
|
directId?: string;
|
|
groupFallback?: string;
|
|
}): string {
|
|
if (params.isGroup) {
|
|
const label = params.groupLabel?.trim() || params.groupFallback || "Group";
|
|
const id = params.groupId?.trim();
|
|
return id ? `${label} id:${id}` : label;
|
|
}
|
|
|
|
const directLabel = params.directLabel.trim();
|
|
const directId = params.directId?.trim();
|
|
if (!directId || directId === directLabel) return directLabel;
|
|
return `${directLabel} id:${directId}`;
|
|
}
|
|
|
|
type DedupeCache = {
|
|
check: (key: string | undefined | null, now?: number) => boolean;
|
|
};
|
|
|
|
export function createDedupeCache(options: { ttlMs: number; maxSize: number }): DedupeCache {
|
|
const ttlMs = Math.max(0, options.ttlMs);
|
|
const maxSize = Math.max(0, Math.floor(options.maxSize));
|
|
const cache = new Map<string, number>();
|
|
|
|
const touch = (key: string, now: number) => {
|
|
cache.delete(key);
|
|
cache.set(key, now);
|
|
};
|
|
|
|
const prune = (now: number) => {
|
|
const cutoff = ttlMs > 0 ? now - ttlMs : undefined;
|
|
if (cutoff !== undefined) {
|
|
for (const [entryKey, entryTs] of cache) {
|
|
if (entryTs < cutoff) {
|
|
cache.delete(entryKey);
|
|
}
|
|
}
|
|
}
|
|
if (maxSize <= 0) {
|
|
cache.clear();
|
|
return;
|
|
}
|
|
while (cache.size > maxSize) {
|
|
const oldestKey = cache.keys().next().value as string | undefined;
|
|
if (!oldestKey) break;
|
|
cache.delete(oldestKey);
|
|
}
|
|
};
|
|
|
|
return {
|
|
check: (key, now = Date.now()) => {
|
|
if (!key) return false;
|
|
const existing = cache.get(key);
|
|
if (existing !== undefined && (ttlMs <= 0 || now - existing < ttlMs)) {
|
|
touch(key, now);
|
|
return true;
|
|
}
|
|
touch(key, now);
|
|
prune(now);
|
|
return false;
|
|
},
|
|
};
|
|
}
|
|
|
|
export function rawDataToString(
|
|
data: WebSocket.RawData,
|
|
encoding: BufferEncoding = "utf8",
|
|
): string {
|
|
if (typeof data === "string") return data;
|
|
if (Buffer.isBuffer(data)) return data.toString(encoding);
|
|
if (Array.isArray(data)) return Buffer.concat(data).toString(encoding);
|
|
if (data instanceof ArrayBuffer) {
|
|
return Buffer.from(data).toString(encoding);
|
|
}
|
|
return Buffer.from(String(data)).toString(encoding);
|
|
}
|
|
|
|
function normalizeAgentId(value: string | undefined | null): string {
|
|
const trimmed = (value ?? "").trim();
|
|
if (!trimmed) return "main";
|
|
if (/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(trimmed)) return trimmed;
|
|
return (
|
|
trimmed
|
|
.toLowerCase()
|
|
.replace(/[^a-z0-9_-]+/g, "-")
|
|
.replace(/^-+/, "")
|
|
.replace(/-+$/, "")
|
|
.slice(0, 64) || "main"
|
|
);
|
|
}
|
|
|
|
type AgentEntry = NonNullable<NonNullable<ClawdbotConfig["agents"]>["list"]>[number];
|
|
|
|
function listAgents(cfg: ClawdbotConfig): AgentEntry[] {
|
|
const list = cfg.agents?.list;
|
|
if (!Array.isArray(list)) return [];
|
|
return list.filter((entry): entry is AgentEntry => Boolean(entry && typeof entry === "object"));
|
|
}
|
|
|
|
function resolveAgentEntry(cfg: ClawdbotConfig, agentId: string): AgentEntry | undefined {
|
|
const id = normalizeAgentId(agentId);
|
|
return listAgents(cfg).find((entry) => normalizeAgentId(entry.id) === id);
|
|
}
|
|
|
|
export function resolveIdentityName(cfg: ClawdbotConfig, agentId: string): string | undefined {
|
|
const entry = resolveAgentEntry(cfg, agentId);
|
|
return entry?.identity?.name?.trim() || undefined;
|
|
}
|
|
|
|
export function resolveThreadSessionKeys(params: {
|
|
baseSessionKey: string;
|
|
threadId?: string | null;
|
|
parentSessionKey?: string;
|
|
useSuffix?: boolean;
|
|
}): { sessionKey: string; parentSessionKey?: string } {
|
|
const threadId = (params.threadId ?? "").trim();
|
|
if (!threadId) {
|
|
return { sessionKey: params.baseSessionKey, parentSessionKey: undefined };
|
|
}
|
|
const useSuffix = params.useSuffix ?? true;
|
|
const sessionKey = useSuffix
|
|
? `${params.baseSessionKey}:thread:${threadId}`
|
|
: params.baseSessionKey;
|
|
return { sessionKey, parentSessionKey: params.parentSessionKey };
|
|
} |