@neutrome/open-ai-router 0.4.2 → 0.5.0

package/src/observer.ts

@@ -1,315 +0,0 @@
-import { opcodeName, type Program } from "@neutrome/lil-engine";
-import type { AuditEvent } from "./router/execution-types.ts";
-
-const decoder = new TextDecoder();
-
-export type TraceSpanKind = "request" | "provider" | "tool" | "executor";
-
-export type TraceSpan = {
-  kind: TraceSpanKind;
-  event: string;
-  requestId: string;
-  executionId: string;
-  parentExecutionId?: string;
-  model?: string;
-  provider?: string;
-  toolName?: string;
-  executor?: string;
-  startedAt: string;
-  finishedAt?: string;
-  tokensInput: number;
-  tokensOutput: number;
-  cachedTokensInput: number;
-  requestBytes: number;
-  responseBytes: number;
-  error?: string;
-};
-
-export type ExecutionTrace = {
-  spanId: string;
-  startedAt: string;
-  finishedAt?: string;
-  spans: TraceSpan[];
-  totalTokensInput: number;
-  totalTokensOutput: number;
-  totalCachedTokensInput: number;
-  rawTrace: string;
-  error?: string;
-};
-
-export function createTraceCollector(spanId = crypto.randomUUID()): {
-  observe: (event: AuditEvent) => void;
-  getTrace: () => ExecutionTrace;
-} {
-  const spans: TraceSpan[] = [];
-  const providerSpans = new Map<string, TraceSpan>();
-  const executorSpans = new Map<string, TraceSpan>();
-  const rawSegments: string[] = [];
-  const startedAt = new Date().toISOString();
-  let rawSegmentIndex = 0;
-  let finishedAt: string | undefined;
-  let error: string | undefined;
-
-  return {
-    observe(event) {
-      appendTimingComment(event);
-      appendLilSegment(event);
-
-      switch (event.kind) {
-        case "request.received":
-          spans.push(createSpan("request", event, {
-            finishedAt: event.timestamp,
-          }));
-          break;
-        case "provider.started":
-        case "provider.stream_started": {
-          const span = createSpan("provider", event, {
-            event: event.kind,
-            ...withMaybeString("model", asString(event.data?.model)),
-            ...withMaybeString("provider", asString(event.data?.provider)),
-          });
-          spans.push(span);
-          providerSpans.set(event.executionId, span);
-          break;
-        }
-        case "provider.usage": {
-          const span = providerSpans.get(event.executionId);
-          if (!span) break;
-          span.tokensInput = asNumber(event.data?.tokensInput);
-          span.tokensOutput = asNumber(event.data?.tokensOutput);
-          span.cachedTokensInput = asNumber(event.data?.cachedTokensInput);
-          span.requestBytes = asNumber(event.data?.requestBytes);
-          span.responseBytes = asNumber(event.data?.responseBytes);
-          const provider = asString(event.data?.provider);
-          if (!span.provider && provider) {
-            span.provider = provider;
-          }
-          const model = asString(event.data?.model);
-          if (!span.model && model) {
-            span.model = model;
-          }
-          break;
-        }
-        case "provider.finished":
-        case "provider.stream_finished": {
-          const span = providerSpans.get(event.executionId);
-          if (!span) break;
-          span.finishedAt = event.timestamp;
-          break;
-        }
-        case "executor.started":
-        case "executor.stream_started": {
-          const span = createSpan("executor", event, {
-            event: event.kind,
-            ...withMaybeString("executor", asString(event.data?.executor) || asString(event.target?.id)),
-          });
-          spans.push(span);
-          executorSpans.set(event.executionId, span);
-          break;
-        }
-        case "executor.finished":
-        case "executor.stream_finished": {
-          const span = executorSpans.get(event.executionId);
-          if (!span) break;
-          span.finishedAt = event.timestamp;
-          break;
-        }
-        case "tool.executed":
-          spans.push(createSpan("tool", event, {
-            finishedAt: event.timestamp,
-            ...withMaybeString("toolName", asString(event.data?.toolName)),
-          }));
-          break;
-        case "execution.failed": {
-          const message = asString(event.data?.message) || `Execution failed (${event.errorKind ?? "unknown"})`;
-          error = error ?? message;
-          const span = providerSpans.get(event.executionId) ?? executorSpans.get(event.executionId);
-          if (span) {
-            span.error = message;
-            span.finishedAt = span.finishedAt ?? event.timestamp;
-          }
-          break;
-        }
-      }
-    },
-
-    getTrace() {
-      const totalTokensInput = spans.reduce((sum, span) => sum + span.tokensInput, 0);
-      const totalTokensOutput = spans.reduce((sum, span) => sum + span.tokensOutput, 0);
-      const totalCachedTokensInput = spans.reduce((sum, span) => sum + span.cachedTokensInput, 0);
-      finishedAt ??= new Date().toISOString();
-      return {
-        spanId,
-        startedAt,
-        finishedAt,
-        spans,
-        totalTokensInput,
-        totalTokensOutput,
-        totalCachedTokensInput,
-        rawTrace: rawSegments.join("\n\n"),
-        ...(error ? { error } : {}),
-      };
-    },
-  };
-
-  function appendLilSegment(event: AuditEvent): void {
-    const lilText = asString(event.data?.lilText)?.trim();
-    if (!lilText) return;
-    rawSegments.push(`;${traceSegmentLabel(event)}:${rawSegmentIndex++}\n${lilText}`);
-  }
-
-  function appendTimingComment(event: AuditEvent): void {
-    const startedAt = asString(event.data?.startedAt);
-    const finishedAt = asString(event.data?.finishedAt);
-    const rawDurationMs = event.data?.durationMs;
-    const durationMs = typeof rawDurationMs === "number" && Number.isFinite(rawDurationMs) && rawDurationMs >= 0
-      ? Math.round(rawDurationMs)
-      : undefined;
-    if (!startedAt && !finishedAt && durationMs === undefined) return;
-
-    rawSegments.push(`;timing ${JSON.stringify(compactObject({
-      kind: traceTimingKind(event),
-      event: event.kind,
-      requestId: event.requestId,
-      executionId: event.executionId,
-      ...(event.parentExecutionId ? { parentExecutionId: event.parentExecutionId } : {}),
-      startedAt,
-      finishedAt: finishedAt ?? (durationMs !== undefined ? event.timestamp : undefined),
-      durationMs,
-      provider: asString(event.data?.provider),
-      model: asString(event.data?.model),
-      toolName: asString(event.data?.toolName),
-      executor: asString(event.data?.executor) || asString(event.data?.executorId),
-      driver: asString(event.data?.driver),
-      source: asString(event.data?.source),
-      matched: typeof event.data?.matched === "boolean" ? event.data.matched : undefined,
-      status: typeof event.data?.status === "number" ? event.data.status : undefined,
-      bytes: typeof event.data?.bytes === "number" ? event.data.bytes : undefined,
-    }))}`);
-  }
-}
-
-function traceTimingKind(event: AuditEvent): string {
-  if (event.kind.startsWith("upstream_auth.")) return "upstream_auth";
-  if (event.kind.startsWith("admission.")) return "admission";
-  if (event.kind.startsWith("response.")) return "response";
-  if (event.kind.startsWith("provider.")) return "provider";
-  if (event.kind.startsWith("executor.")) return "executor";
-  if (event.kind.startsWith("remote_mcp.")) return "remote_mcp";
-  if (event.kind.startsWith("tool.")) return "tool";
-  return "request";
-}
-
-function traceSegmentLabel(event: AuditEvent): string {
-  switch (event.kind) {
-    case "request.received":
-      return "request";
-    case "provider.request":
-      return "provider-request";
-    case "provider.response":
-      return "provider-response";
-    case "provider.response_chunk":
-      return "provider-response-chunk";
-    case "tool.executed":
-      return "tool";
-    default:
-      return event.kind.replace(/\./g, "-") || "trace";
-  }
-}
-
-export function renderProgramAsLil(program: Program): string {
-  return program.code
-    .map((instruction) => {
-      const name = opcodeName(instruction.opcode) ?? `OP_${instruction.opcode}`;
-      const value = formatInstructionValue(program, instruction.value);
-      return value ? `${name} ${value}` : name;
-    })
-    .join("\n");
-}
-
-function createSpan(
-  kind: TraceSpanKind,
-  event: AuditEvent,
-  input: Partial<Omit<TraceSpan, "kind" | "requestId" | "executionId" | "startedAt">> = {},
-): TraceSpan {
-  return {
-    kind,
-    event: input.event ?? event.kind,
-    requestId: event.requestId,
-    executionId: event.executionId,
-    ...(event.parentExecutionId ? { parentExecutionId: event.parentExecutionId } : {}),
-    startedAt: event.timestamp,
-    ...withMaybeString("model", input.model),
-    ...withMaybeString("provider", input.provider),
-    ...withMaybeString("toolName", input.toolName),
-    ...withMaybeString("executor", input.executor),
-    ...(input.finishedAt ? { finishedAt: input.finishedAt } : {}),
-    tokensInput: input.tokensInput ?? 0,
-    tokensOutput: input.tokensOutput ?? 0,
-    cachedTokensInput: input.cachedTokensInput ?? 0,
-    requestBytes: input.requestBytes ?? 0,
-    responseBytes: input.responseBytes ?? 0,
-    ...withMaybeString("error", input.error),
-  };
-}
-
-function formatInstructionValue(program: Program, value: Program["code"][number]["value"]): string {
-  switch (value.kind) {
-    case "none":
-      return "";
-    case "string":
-      return JSON.stringify(value.value);
-    case "float":
-    case "int":
-      return String(value.value);
-    case "json":
-      return formatBytes(value.value);
-    case "ref": {
-      const bytes = program.buffers[value.value];
-      if (!bytes) {
-        return `@${value.value}`;
-      }
-      return `@${value.value}=${formatBytes(bytes)}`;
-    }
-    case "key_string":
-      return `${JSON.stringify(value.key)}=${JSON.stringify(value.value)}`;
-    case "key_json":
-      return `${JSON.stringify(value.key)}=${formatBytes(value.value)}`;
-  }
-}
-
-function formatBytes(bytes: Uint8Array): string {
-  const text = decoder.decode(bytes);
-  if (text.includes("\uFFFD")) {
-    return `base64:${toBase64(bytes)}`;
-  }
-  const trimmed = text.trim();
-  if (trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed.startsWith("\"")) {
-    return trimmed;
-  }
-  return JSON.stringify(text);
-}
-
-function toBase64(bytes: Uint8Array): string {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary);
-}
-
-function asString(value: unknown): string | undefined {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-function asNumber(value: unknown): number {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
-}
-
-function withMaybeString<K extends string>(key: K, value: string | undefined): Partial<Record<K, string>> {
-  return value ? { [key]: value } as Record<K, string> : {};
-}
-
-function compactObject<T extends Record<string, unknown>>(value: T): Record<string, unknown> {
-  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
-}

package/src/timing.ts

@@ -1,36 +0,0 @@
-import { createAuditEvent } from "./router/audit.ts";
-import type { AuditEvent } from "./router/execution-types.ts";
-
-export type TimingEventInput = {
-  observe?: ((event: AuditEvent) => void) | undefined;
-  kind: string;
-  requestId: string;
-  executionId: string;
-  parentExecutionId?: string | undefined;
-  startedAtMs: number;
-  finishedAtMs?: number | undefined;
-  data?: Record<string, unknown> | undefined;
-};
-
-export function observeTimingEvent(input: TimingEventInput): void {
-  if (!input.observe) return;
-
-  const finishedAtMs = input.finishedAtMs;
-  const data: Record<string, unknown> = {
-    ...(input.data ?? {}),
-    startedAt: new Date(input.startedAtMs).toISOString(),
-  };
-  if (finishedAtMs !== undefined) {
-    data.finishedAt = new Date(finishedAtMs).toISOString();
-    data.durationMs = Math.max(0, finishedAtMs - input.startedAtMs);
-  }
-
-  input.observe(createAuditEvent({
-    kind: input.kind,
-    requestId: input.requestId,
-    executionId: input.executionId,
-    ...(input.parentExecutionId ? { parentExecutionId: input.parentExecutionId } : {}),
-    timestamp: new Date(finishedAtMs ?? input.startedAtMs).toISOString(),
-    data,
-  }));
-}