@kevin5251984/guild 0.2.12

package/src/trajectory.ts

@@ -0,0 +1,339 @@
+import type { ChatMessage } from "@guild/protocol";
+import type { ToolTrace } from "./tools.ts";
+
+export type TrajectoryKind =
+  | "system"
+  | "user"
+  | "context"
+  | "model"
+  | "thinking"
+  | "tool"
+  | "skill"
+  | "spawn"
+  | "assistant";
+
+export type TrajectoryEvent = {
+  seq: number;
+  ts: string;
+  turnId: string;
+  botId?: string;
+  kind: TrajectoryKind;
+  summary: string;
+  payload?: unknown;
+  result?: string;
+  durationMs?: number;
+  isError?: boolean;
+  /** In-progress turn; not persisted. */
+  live?: boolean;
+};
+
+export type TrajectoryDraft = Omit<TrajectoryEvent, "seq">;
+
+const CLIP = 140;
+const FIELD_CAP = 32_000;
+
+export function clip(text: string, n = CLIP): string {
+  const one = String(text || "").replace(/\s+/g, " ").trim();
+  if (one.length <= n) return one;
+  return one.slice(0, n - 1) + "…";
+}
+
+function recordOf(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value as Record<string, unknown>;
+}
+
+/** Old rows logged spawn as TOOL "spawn spawn". Present them as spawn. */
+export function promoteSpawnEvent<T extends { kind: string; summary: string; payload?: unknown }>(
+  event: T,
+): T & { kind: TrajectoryKind; summary: string } {
+  if (event.kind === "spawn") return event as T & { kind: TrajectoryKind; summary: string };
+  const payload = recordOf(event.payload);
+  const toolName = String(payload?.name || "");
+  const looksSpawn =
+    event.kind === "tool" &&
+    (toolName === "spawn" || /^\s*spawn(\s+spawn)?\s*$/i.test(event.summary || ""));
+  if (!looksSpawn) return event as T & { kind: TrajectoryKind; summary: string };
+  const args = recordOf(payload?.args) || payload || {};
+  const agent = String(args.name || "worker").trim() || "worker";
+  const label = String(args.description || "").replace(/\s+/g, " ").trim();
+  const prompt = String(args.prompt || "").replace(/\s+/g, " ").trim();
+  return {
+    ...event,
+    kind: "spawn",
+    summary: clip(
+      `${agent}${label ? " · " + label : ""}${prompt ? " — " + prompt : ""}`,
+    ),
+  };
+}
+
+function cap(value: unknown): unknown {
+  if (typeof value === "string") {
+    return value.length > FIELD_CAP ? value.slice(0, FIELD_CAP) : value;
+  }
+  try {
+    const raw = JSON.stringify(value);
+    if (raw && raw.length > FIELD_CAP) return raw.slice(0, FIELD_CAP);
+  } catch {
+    /* ignore */
+  }
+  return value;
+}
+
+export function userTrajectoryEvent(
+  messageId: string,
+  body: string,
+  ts = new Date().toISOString(),
+): TrajectoryDraft {
+  return {
+    ts,
+    turnId: messageId,
+    kind: "user",
+    summary: clip(body),
+    payload: { body },
+  };
+}
+
+export function turnTrajectoryEvents(input: {
+  turnId: string;
+  botId: string;
+  ts?: string;
+  system?: string;
+  channelMd?: string;
+  model?: { provider: string; model: string } | null;
+  thinking?: string;
+  traces?: ToolTrace[];
+  text: string;
+  source?: string;
+}): TrajectoryDraft[] {
+  const ts = input.ts || new Date().toISOString();
+  const { turnId, botId } = input;
+  const events: TrajectoryDraft[] = [];
+  const modelLabel = input.model
+    ? `${input.model.provider} / ${input.model.model}`
+    : input.source === "local"
+      ? "local"
+      : "";
+  if (modelLabel) {
+    events.push({
+      ts,
+      turnId,
+      botId,
+      kind: "model",
+      summary: modelLabel,
+      payload: input.model ?? { source: "local" },
+    });
+  }
+  if (input.system) {
+    events.push({
+      ts,
+      turnId,
+      botId,
+      kind: "system",
+      summary: clip(input.system),
+      payload: cap(input.system),
+    });
+  }
+  if (input.channelMd?.trim()) {
+    events.push({
+      ts,
+      turnId,
+      botId,
+      kind: "context",
+      summary: "Channel.md",
+      payload: cap(input.channelMd),
+    });
+  }
+  if (input.thinking?.trim()) {
+    events.push({
+      ts,
+      turnId,
+      botId,
+      kind: "thinking",
+      summary: clip(input.thinking),
+      result: String(cap(input.thinking)),
+    });
+  }
+  for (const trace of input.traces ?? []) {
+    if (trace.name === "skill") {
+      const name = String(trace.args.name ?? "skill");
+      events.push({
+        ts,
+        turnId,
+        botId,
+        kind: "skill",
+        summary: `${name}${trace.running ? " …" : ""}`,
+        payload: cap(trace.args),
+        result: String(cap(trace.text ?? "")),
+        isError: trace.isError,
+      });
+      continue;
+    }
+    if (trace.name === "spawn" || trace.name === "read_spawn") {
+      const agent =
+        String(
+          trace.args.profile ||
+            trace.args.name ||
+            trace.args.agent ||
+            "worker",
+        ).trim() || "worker";
+      const label = String(trace.args.title || trace.args.description || "")
+        .replace(/\s+/g, " ")
+        .trim();
+      const prompt = String(trace.args.prompt || trace.args.task || "")
+        .replace(/\s+/g, " ")
+        .trim();
+      const bg =
+        trace.args.background === true || trace.args.is_background === true
+          ? " (bg)"
+          : "";
+      const waitId = String(trace.args.agent_id || trace.args.id || "").trim();
+      events.push({
+        ts,
+        turnId,
+        botId,
+        kind: "spawn",
+        summary: clip(
+          trace.name === "read_spawn"
+            ? `read ${waitId || agent}${trace.running ? " …" : ""}`
+            : `${agent}${bg}${label ? " · " + label : ""}${prompt ? " — " + prompt : ""}${trace.running ? " …" : ""}`,
+        ),
+        payload: cap(trace.args),
+        result: String(cap(trace.text ?? "")),
+        isError: trace.isError,
+      });
+      continue;
+    }
+    const detail =
+      trace.name === "run"
+        ? String(trace.args.command ?? "")
+        : String(trace.args.path ?? trace.name);
+    events.push({
+      ts,
+      turnId,
+      botId,
+      kind: "tool",
+      summary: clip(`${trace.name} ${detail}${trace.running ? " …" : ""}`),
+      payload: cap({ name: trace.name, args: trace.args }),
+      result: String(cap(trace.text ?? "")),
+      isError: trace.isError,
+    });
+  }
+  events.push({
+    ts,
+    turnId,
+    botId,
+    kind: "assistant",
+    summary: clip(input.text),
+    result: String(cap(input.text)),
+  });
+  return events;
+}
+
+export function liveTrajectoryEvents(input: {
+  botId: string;
+  thinking?: string;
+  traces?: Array<{
+    name: string;
+    args?: Record<string, unknown>;
+    text?: string;
+    isError?: boolean;
+    running?: boolean;
+  }>;
+  startedAt?: string;
+}): TrajectoryDraft[] {
+  const traces: ToolTrace[] = (input.traces ?? []).map((tr) => ({
+    name: tr.name,
+    args: tr.args ?? {},
+    text: tr.text ?? "",
+    isError: Boolean(tr.isError),
+    running: tr.running,
+  }));
+  const events = turnTrajectoryEvents({
+    turnId: `live-${input.botId}`,
+    botId: input.botId,
+    ts: input.startedAt,
+    thinking: input.thinking,
+    traces,
+    text: "",
+  }).filter((event) => event.kind !== "assistant");
+  return events.map((event) => ({ ...event, live: true }));
+}
+
+export function synthesizeTrajectory(messages: ChatMessage[]): TrajectoryEvent[] {
+  const events: TrajectoryEvent[] = [];
+  let seq = 0;
+  for (const msg of messages) {
+    const ts = msg.createdAt;
+    const turnId = `derived-${msg.id}`;
+    if (msg.author === "you") {
+      events.push({
+        seq: seq++,
+        ts,
+        turnId,
+        kind: "user",
+        summary: clip(msg.body),
+        payload: { body: msg.body },
+      });
+      continue;
+    }
+    const parts = msg.parts?.length
+      ? msg.parts
+      : [{ type: "text" as const, text: msg.body }];
+    for (const part of parts) {
+      if (part.type === "thinking") {
+        events.push({
+          seq: seq++,
+          ts,
+          turnId,
+          botId: msg.author,
+          kind: "thinking",
+          summary: clip(part.text),
+          result: part.text,
+        });
+        continue;
+      }
+      if (part.type === "skill") {
+        events.push({
+          seq: seq++,
+          ts,
+          turnId,
+          botId: msg.author,
+          kind: "skill",
+          summary: part.name,
+          payload: { name: part.name },
+          result: part.output || "",
+        });
+        continue;
+      }
+      if (part.type === "tool") {
+        events.push({
+          seq: seq++,
+          ts,
+          turnId,
+          botId: msg.author,
+          kind: part.name === "spawn" ? "spawn" : "tool",
+          summary: clip(
+            part.name === "spawn"
+              ? part.detail || part.label || "spawn"
+              : `${part.name} ${part.detail}`,
+          ),
+          payload: { name: part.name, detail: part.detail },
+          result: part.output,
+          isError: part.isError,
+        });
+        continue;
+      }
+      events.push({
+        seq: seq++,
+        ts,
+        turnId,
+        botId: msg.author,
+        kind: "assistant",
+        summary: clip(part.text),
+        result: part.text,
+      });
+    }
+  }
+  return events;
+}

package/src/usage.ts

@@ -0,0 +1,111 @@
+import type { ChatUsage } from "@guild/protocol";
+
+export function blankUsage(): ChatUsage {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    totalTokens: 0,
+    costUsd: 0,
+    rounds: 0,
+    durationMs: 0,
+  };
+}
+
+export function addUsage(acc: ChatUsage, next?: ChatUsage | null): ChatUsage {
+  if (!next) return acc;
+  acc.input = (acc.input ?? 0) + (next.input ?? 0);
+  acc.output = (acc.output ?? 0) + (next.output ?? 0);
+  acc.cacheRead = (acc.cacheRead ?? 0) + (next.cacheRead ?? 0);
+  acc.cacheWrite = (acc.cacheWrite ?? 0) + (next.cacheWrite ?? 0);
+  acc.reasoning = (acc.reasoning ?? 0) + (next.reasoning ?? 0);
+  acc.totalTokens = (acc.totalTokens ?? 0) + (next.totalTokens ?? 0);
+  acc.costUsd = (acc.costUsd ?? 0) + (next.costUsd ?? 0);
+  acc.rounds = (acc.rounds ?? 0) + (next.rounds ?? 0);
+  if (next.provider) acc.provider = next.provider;
+  if (next.model) acc.model = next.model;
+  return acc;
+}
+
+export function fromPiUsage(usage?: {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  reasoning?: number;
+  totalTokens?: number;
+  cost?: { total?: number };
+} | null): ChatUsage {
+  if (!usage) return { rounds: 1 };
+  const input = num(usage.input);
+  const output = num(usage.output);
+  const total =
+    num(usage.totalTokens) || (input || 0) + (output || 0) || undefined;
+  return {
+    input,
+    output,
+    cacheRead: num(usage.cacheRead),
+    cacheWrite: num(usage.cacheWrite),
+    reasoning: num(usage.reasoning),
+    totalTokens: total,
+    costUsd: num(usage.cost?.total),
+    rounds: 1,
+  };
+}
+
+export function fromOpenAiUsage(usage?: {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+  prompt_tokens_details?: { cached_tokens?: number };
+  input_tokens_details?: { cached_tokens?: number };
+} | null): ChatUsage {
+  if (!usage) return { rounds: 1 };
+  const input = num(usage.prompt_tokens);
+  const output = num(usage.completion_tokens);
+  const cacheRead =
+    num(usage.prompt_tokens_details?.cached_tokens) ??
+    num(usage.input_tokens_details?.cached_tokens);
+  return {
+    input,
+    output,
+    cacheRead,
+    totalTokens: num(usage.total_tokens) || sum(input, output),
+    rounds: 1,
+  };
+}
+
+export function fromAnthropicUsage(usage?: {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+} | null): ChatUsage {
+  if (!usage) return { rounds: 1 };
+  const input = num(usage.input_tokens);
+  const output = num(usage.output_tokens);
+  return {
+    input,
+    output,
+    cacheRead: num(usage.cache_read_input_tokens),
+    cacheWrite: num(usage.cache_creation_input_tokens),
+    totalTokens: sum(input, output),
+    rounds: 1,
+  };
+}
+
+export function withDuration(usage: ChatUsage, started: number): ChatUsage {
+  usage.durationMs = Math.max(0, Date.now() - started);
+  return usage;
+}
+
+function num(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function sum(a?: number, b?: number): number | undefined {
+  if (a == null && b == null) return undefined;
+  return (a ?? 0) + (b ?? 0);
+}

package/vendor/protocol/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@guild/protocol",
+  "version": "0.2.11",
+  "type": "module",
+  "license": "MIT",
+  "description": "Shared types for Guild (guildd).",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": ["src"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jakevin/guild.git",
+    "directory": "packages/protocol"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/vendor/protocol/src/index.ts

@@ -0,0 +1,159 @@
+export type HealthResponse = {
+  status: "ok";
+  ready: true;
+  service: "guildd";
+};
+
+export type BotStatus = "bench" | "staffed" | "running" | "retired";
+
+export type ModelRef = { provider: string; model: string };
+
+export type LibraryKind =
+  | "souls"
+  | "agents"
+  | "skills"
+  | "positions"
+  | "subagents";
+
+export type LibraryItem = {
+  id: string;
+  slug: string;
+  name: string;
+  body: string;
+  description?: string;
+  tags?: string[];
+  source?: "catalog" | "user";
+  featured?: boolean;
+  createdAt: string;
+};
+
+export type Bot = {
+  id: string;
+  handle: string;
+  name: string;
+  status: BotStatus;
+  soulId: string;
+  agentTemplateId: string;
+  skillIds: string[];
+  defaultPositionId: string;
+  oneLiner?: string;
+  /** Public /generated/… sprite. Missing → procedural tavern buddy. */
+  portrait?: string;
+  /** Chat model for this bot. Missing → guild default. */
+  model?: ModelRef | null;
+  createdAt: string;
+};
+
+/** Talent bench listing. Empty before any bots exist. */
+export type BenchListing = Bot[];
+
+export type RoomKind = "channel" | "dm";
+
+export type Room = {
+  id: string;
+  kind: RoomKind;
+  name: string;
+  memberIds: string[];
+  createdAt: string;
+};
+
+export type ChatPart =
+  | { type: "thinking"; text: string }
+  | {
+      type: "tool";
+      name: string;
+      detail: string;
+      output: string;
+      isError?: boolean;
+      /** Short UI label (DSH bash `description`). */
+      label?: string;
+    }
+  | { type: "skill"; name: string; output?: string }
+  | { type: "text"; text: string };
+
+export type ChatAttachment = {
+  token: string;
+  title: string;
+  body: string;
+  /** Small data-URL thumbnail for hover preview. Not sent to the model. */
+  preview?: string;
+};
+
+/** Per-turn LLM accounting, shown in the message stats panel. */
+export type ChatUsage = {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  reasoning?: number;
+  totalTokens?: number;
+  costUsd?: number;
+  rounds?: number;
+  durationMs?: number;
+  /** When this agent turn started working. */
+  startedAt?: string;
+  provider?: string;
+  model?: string;
+  estimated?: boolean;
+};
+
+export type ChatMessage = {
+  id: string;
+  roomId: string;
+  author: "you" | string;
+  body: string;
+  /** DSH-style transcript rows. Missing on older messages. */
+  parts?: ChatPart[];
+  /** Parent message id when this is a reply. */
+  replyTo?: string;
+  /** Composer attachments referenced by tokens like [Image #1]. */
+  attachments?: ChatAttachment[];
+  usage?: ChatUsage;
+  createdAt: string;
+  /** When an agent turn finished. User messages omit this. */
+  finishedAt?: string;
+  /** Injected into a live turn (⌘/Ctrl+Enter), not a new user turn. */
+  steer?: boolean;
+  /** Live bot this steer was aimed at. */
+  steerBotId?: string;
+};
+
+export type LlmApi =
+  | "openai-completions"
+  | "anthropic-messages"
+  | "openai-responses";
+
+export type ModelEntry = {
+  id: string;
+  name?: string;
+};
+
+export type ProviderEntry = {
+  name?: string;
+  baseUrl: string;
+  api: LlmApi;
+  apiKey?: string;
+  models: ModelEntry[];
+};
+
+export type AuxRole =
+  | "vision"
+  | "web"
+  | "compression"
+  | "skills"
+  | "approval"
+  | "title"
+  | "generate"
+  | "spawn";
+
+export type ModelsFile = {
+  default?: ModelRef | null;
+  reasoning?: "minimal" | "low" | "medium" | "high";
+  fast?: boolean;
+  aux?: Partial<Record<AuxRole, ModelRef | null>>;
+  recent?: ModelRef[];
+  providers: Record<string, ProviderEntry>;
+};
+
+export const DEFAULT_GUILD_HOST = "127.0.0.1";
+export const DEFAULT_GUILD_PORT = 7420;