theorum 0.1.4 → 0.1.6

package/src/kernel/engine/delta.ts

@@ -1,440 +0,0 @@
-import type { GroundingEvent, GroundingSource, TurnEvent, TurnTokens } from '../types.ts';
-import { asRecord } from './record.ts';
-
-function deltaText(delta: Record<string, unknown>): string {
-  if (typeof delta.text === 'string') {
-    return delta.text;
-  }
-  const { content } = delta;
-  if (typeof content === 'string') {
-    return content;
-  }
-  const nested = asRecord(content);
-  if (nested && typeof nested.text === 'string') {
-    return nested.text;
-  }
-  return '';
-}
-
-function deltaMedia(delta: Record<string, unknown>): TurnEvent | undefined {
-  const mimeType = delta.mimeType ?? delta.mime_type;
-  const { data } = delta;
-  if (typeof mimeType === 'string' && typeof data === 'string' && data) {
-    return { type: 'media', media: { mimeType, data } };
-  }
-  return undefined;
-}
-
-function eventIfText(type: 'thought' | 'text', delta: Record<string, unknown>): TurnEvent[] {
-  const text = deltaText(delta);
-  if (!text) {
-    return [];
-  }
-  return [{ type, text }];
-}
-
-function eventsFromImage(delta: Record<string, unknown>): TurnEvent[] {
-  const media = deltaMedia(delta);
-  if (media) {
-    return [media];
-  }
-  return [];
-}
-
-function eventsFromAudio(delta: Record<string, unknown>): TurnEvent[] {
-  const media = deltaMedia(delta);
-  if (media) {
-    return [media];
-  }
-  // Google TTS deltas may ship data without a mime; treat as raw PCM.
-  const { data } = delta;
-  if (typeof data === 'string' && data) {
-    return [{ type: 'media', media: { mimeType: 'audio/pcm', data } }];
-  }
-  return [];
-}
-
-function eventsFromDelta(deltaValue: unknown): TurnEvent[] {
-  const delta = asRecord(deltaValue);
-  if (!delta) {
-    return [];
-  }
-  const deltaType = String(delta.type ?? '');
-  if (deltaType === 'thought_summary' || deltaType === 'thought') {
-    return eventIfText('thought', delta);
-  }
-  if (deltaType === 'text') {
-    return eventIfText('text', delta);
-  }
-  if (deltaType === 'image') {
-    return eventsFromImage(delta);
-  }
-  if (deltaType === 'audio' || deltaType === 'output_audio') {
-    return eventsFromAudio(delta);
-  }
-  return [];
-}
-
-function mediaFromRecord(rec: Record<string, unknown>): TurnEvent | undefined {
-  const mimeType = rec.mimeType ?? rec.mime_type;
-  const { data } = rec;
-  if (typeof mimeType === 'string' && typeof data === 'string' && data) {
-    return { type: 'media', media: { mimeType, data } };
-  }
-  return undefined;
-}
-
-function mediaFromOutputItem(item: unknown): TurnEvent | undefined {
-  const rec = asRecord(item);
-  if (!rec) {
-    return undefined;
-  }
-  if (rec.type !== 'image' && rec.type !== 'media' && rec.type !== 'audio') {
-    return undefined;
-  }
-  return mediaFromRecord(rec);
-}
-
-function mediaFromOutputs(outputs: unknown): TurnEvent | undefined {
-  if (!Array.isArray(outputs)) {
-    return undefined;
-  }
-  for (const item of outputs) {
-    const media = mediaFromOutputItem(item);
-    if (media) {
-      return media;
-    }
-  }
-  return undefined;
-}
-
-function mediaFromComplete(event: Record<string, unknown>): TurnEvent | undefined {
-  const interaction = asRecord(event.interaction) ?? event;
-  const directImage = asRecord(interaction.output_image);
-  if (directImage) {
-    const media = mediaFromRecord(directImage);
-    if (media) {
-      return media;
-    }
-  }
-  const directAudio = asRecord(interaction.output_audio);
-  if (directAudio) {
-    const media = mediaFromRecord(directAudio);
-    if (media) {
-      return media;
-    }
-    // Google TTS convenience field: base64 PCM without mime.
-    const { data } = directAudio;
-    if (typeof data === 'string' && data) {
-      return { type: 'media', media: { mimeType: 'audio/pcm', data } };
-    }
-  }
-  return mediaFromOutputs(interaction.outputs);
-}
-
-function sourceFromMaps(maps: Record<string, unknown>): GroundingSource | undefined {
-  const uri = maps.uri ?? maps.googleMapsUri ?? maps.google_maps_uri;
-  if (typeof uri !== 'string' || !uri) {
-    return undefined;
-  }
-  const title = maps.title ?? maps.name;
-  return {
-    type: 'maps',
-    uri,
-    title: typeof title === 'string' && title ? title : uri,
-  };
-}
-
-function sourceFromWeb(web: Record<string, unknown>): GroundingSource | undefined {
-  const uri = web.uri;
-  if (typeof uri !== 'string' || !uri) {
-    return undefined;
-  }
-  const title = web.title ?? web.domain;
-  return {
-    type: 'web',
-    uri,
-    title: typeof title === 'string' && title ? title : uri,
-  };
-}
-
-function pushUniqueSource(sources: GroundingSource[], source: GroundingSource | undefined): void {
-  if (!source) {
-    return;
-  }
-  if (!sources.some((item) => item.uri === source.uri && item.type === source.type)) {
-    sources.push(source);
-  }
-}
-
-function groundingChunks(metadata: Record<string, unknown>): unknown[] {
-  const chunks = metadata.groundingChunks ?? metadata.grounding_chunks;
-  if (Array.isArray(chunks)) {
-    return chunks;
-  }
-  return [];
-}
-
-function searchHtml(metadata: Record<string, unknown>): string | undefined {
-  const searchEntryPoint = asRecord(metadata.searchEntryPoint ?? metadata.search_entry_point);
-  const renderedContent = searchEntryPoint?.renderedContent ?? searchEntryPoint?.rendered_content;
-  if (typeof renderedContent === 'string' && renderedContent.trim()) {
-    return renderedContent;
-  }
-  return undefined;
-}
-
-function sourcesFromChunks(chunks: unknown[]): GroundingSource[] {
-  const sources: GroundingSource[] = [];
-  for (const chunk of chunks) {
-    const record = asRecord(chunk);
-    if (!record) {
-      continue;
-    }
-    const maps = asRecord(record.maps);
-    if (maps) {
-      pushUniqueSource(sources, sourceFromMaps(maps));
-    }
-    const web = asRecord(record.web);
-    if (web) {
-      pushUniqueSource(sources, sourceFromWeb(web));
-    }
-  }
-  return sources;
-}
-
-function mergeGrounding(
-  a: GroundingEvent | undefined,
-  b: GroundingEvent | undefined,
-): GroundingEvent | undefined {
-  if (!a) {
-    return b;
-  }
-  if (!b) {
-    return a;
-  }
-  const chunks = [...(a.chunks ?? []), ...(b.chunks ?? [])];
-  const sources = [...a.sources];
-  for (const source of b.sources) {
-    pushUniqueSource(sources, source);
-  }
-  return {
-    metadata: b.metadata ?? a.metadata,
-    ...(chunks.length > 0 ? { chunks } : {}),
-    searchHtml: b.searchHtml ?? a.searchHtml,
-    sources,
-  };
-}
-
-function groundingFromMetadata(metadataValue: unknown): GroundingEvent | undefined {
-  const metadata = asRecord(metadataValue);
-  if (!metadata) {
-    return undefined;
-  }
-  const chunks = groundingChunks(metadata);
-  const sources = sourcesFromChunks(chunks);
-  const html = searchHtml(metadata);
-  if (chunks.length === 0 && sources.length === 0 && !html) {
-    return { metadata, sources };
-  }
-  return {
-    metadata,
-    ...(chunks.length > 0 ? { chunks } : {}),
-    ...(html ? { searchHtml: html } : {}),
-    sources,
-  };
-}
-
-function groundingMetadataFromRecord(record: Record<string, unknown>): unknown {
-  return record.groundingMetadata ?? record.grounding_metadata;
-}
-
-function groundingFromStep(stepValue: unknown): GroundingEvent | undefined {
-  const step = asRecord(stepValue);
-  if (!step) {
-    return undefined;
-  }
-  let grounding = groundingFromMetadata(groundingMetadataFromRecord(step));
-  const content = step.content;
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      grounding = mergeGrounding(
-        grounding,
-        groundingFromMetadata(groundingMetadataFromRecord(asRecord(block) ?? {})),
-      );
-    }
-  }
-  return grounding;
-}
-
-function groundingFromEvent(event: Record<string, unknown>): TurnEvent | undefined {
-  let grounding = groundingFromMetadata(groundingMetadataFromRecord(event));
-  grounding = mergeGrounding(grounding, groundingFromStep(event.step));
-  grounding = mergeGrounding(grounding, groundingFromStep(event.delta));
-  const interaction = asRecord(event.interaction);
-  if (interaction) {
-    grounding = mergeGrounding(
-      grounding,
-      groundingFromMetadata(groundingMetadataFromRecord(interaction)),
-    );
-  }
-  const steps = interaction?.steps;
-  if (Array.isArray(steps)) {
-    for (const step of steps) {
-      grounding = mergeGrounding(grounding, groundingFromStep(step));
-    }
-  }
-  if (!grounding) {
-    return undefined;
-  }
-  return { type: 'grounding', grounding };
-}
-
-const INPUT_KEYS = [
-  'total_input_tokens',
-  'totalInputTokens',
-  'prompt_token_count',
-  'promptTokenCount',
-  'prompt_tokens',
-  'input_tokens',
-  'inputTokens',
-  'input',
-] as const;
-
-const OUTPUT_KEYS = [
-  'total_output_tokens',
-  'totalOutputTokens',
-  'candidates_token_count',
-  'candidatesTokenCount',
-  'candidates_tokens',
-  'completion_tokens',
-  'output_tokens',
-  'outputTokens',
-  'output',
-] as const;
-
-const THINKING_KEYS = [
-  'total_thought_tokens',
-  'totalThoughtTokens',
-  'thoughts_token_count',
-  'thoughtsTokenCount',
-  'thoughts_tokens',
-  'thinking_tokens',
-  'thinkingTokens',
-  'thinking',
-] as const;
-
-const TOOL_KEYS = [
-  'total_tool_use_tokens',
-  'totalToolUseTokens',
-  'tool_use_token_count',
-  'toolUseTokenCount',
-  'tool_tokens',
-  'toolTokens',
-  'toolUse',
-] as const;
-
-const TOTAL_KEYS = [
-  'total_tokens',
-  'totalTokens',
-  'total_token_count',
-  'totalTokenCount',
-  'total',
-] as const;
-
-function pickNumericField(record: Record<string, unknown>, keys: readonly string[]): number {
-  for (const key of keys) {
-    const val = record[key];
-    if (val !== undefined && val !== null) {
-      const n = Number(val);
-      if (!Number.isNaN(n)) {
-        return n;
-      }
-    }
-  }
-  return 0;
-}
-
-function extractUsageTokens(raw: unknown): TurnTokens | undefined {
-  if (!raw || typeof raw !== 'object') {
-    return undefined;
-  }
-  const r = raw as Record<string, unknown>;
-  const input = pickNumericField(r, INPUT_KEYS);
-  const output = pickNumericField(r, OUTPUT_KEYS);
-  const thinking = pickNumericField(r, THINKING_KEYS);
-  const toolUse = pickNumericField(r, TOOL_KEYS);
-  const total = pickNumericField(r, TOTAL_KEYS) || input + output + thinking + toolUse;
-  if (input > 0 || output > 0 || thinking > 0 || toolUse > 0 || total > 0) {
-    return { input, output, thinking, toolUse, total };
-  }
-  return undefined;
-}
-
-const USAGE_KEYS = ['usage', 'usage_metadata', 'usageMetadata'] as const;
-
-function findUsageObject(target: Record<string, unknown>, event: Record<string, unknown>): unknown {
-  for (const key of USAGE_KEYS) {
-    if (target[key]) return target[key];
-  }
-  for (const key of USAGE_KEYS) {
-    if (event[key]) return event[key];
-  }
-  return undefined;
-}
-
-function extractTokenEvent(
-  event: Record<string, unknown>,
-  interaction?: Record<string, unknown>,
-): TurnEvent | undefined {
-  const target = interaction ?? asRecord(event.interaction) ?? event;
-  const usage = extractUsageTokens(findUsageObject(target, event));
-  const interactionId = typeof target.id === 'string' ? target.id : undefined;
-  if (!usage) {
-    return undefined;
-  }
-  return {
-    type: 'tokens',
-    tokens: usage,
-    ...(interactionId ? { interactionId } : {}),
-  };
-}
-
-function eventsFromComplete(event: Record<string, unknown>, alreadyText: boolean): TurnEvent[] {
-  const interaction = asRecord(event.interaction) ?? event;
-  const outputText = interaction.output_text;
-  const events: TurnEvent[] = [];
-  if (!alreadyText && typeof outputText === 'string' && outputText) {
-    events.push({ type: 'text', text: outputText });
-  }
-  const media = mediaFromComplete(event);
-  if (media) {
-    events.push(media);
-  }
-  const tokenEvent = extractTokenEvent(event, interaction);
-  if (tokenEvent) {
-    events.push(tokenEvent);
-  }
-  const groundingEvent = groundingFromEvent(event);
-  if (groundingEvent) {
-    events.push(groundingEvent);
-  }
-  return events;
-}
-
-function tryStructured(text: string): TurnEvent | undefined {
-  try {
-    return { type: 'structured', structured: JSON.parse(text) };
-  } catch {
-    return undefined;
-  }
-}
-
-export {
-  eventsFromComplete,
-  eventsFromDelta,
-  extractTokenEvent,
-  extractUsageTokens,
-  groundingFromEvent,
-  tryStructured,
-};

package/src/kernel/engine/hash.ts

@@ -1,11 +0,0 @@
-const HEX_PAD = 2;
-const HEX_RADIX = 16;
-
-function hexSha256(bytes: Uint8Array): string {
-  return [...bytes].map((b) => b.toString(HEX_RADIX).padStart(HEX_PAD, '0')).join('');
-}
-
-export async function sha256(text: string): Promise<string> {
-  const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
-  return hexSha256(new Uint8Array(buf));
-}

package/src/kernel/engine/record.ts

@@ -1,8 +0,0 @@
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    return value as Record<string, unknown>;
-  }
-  return undefined;
-}
-
-export { asRecord };

package/src/kernel/engine/repair.ts

@@ -1,56 +0,0 @@
-import type { Profile, TurnHistoryMessage, TurnRepairRequest } from '../types.ts';
-
-const MAX_REPAIR_HISTORY_EXCHANGES = 2;
-const MAX_REPAIR_HISTORY_MESSAGES = MAX_REPAIR_HISTORY_EXCHANGES * 2;
-
-function scopeHistory(history: TurnHistoryMessage[] | undefined): TurnHistoryMessage[] {
-  if (!history || history.length === 0) {
-    return [];
-  }
-  return history.slice(-MAX_REPAIR_HISTORY_MESSAGES);
-}
-
-function formatHistoryBlock(messages: TurnHistoryMessage[]): string {
-  if (messages.length === 0) {
-    return '';
-  }
-  const lines = messages.map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`);
-  return `### RECENT CONVERSATION CONTEXT (LAST ${messages.length} TURNS)\n${lines.join('\n')}\n\n`;
-}
-
-function synthesizeRepairPrompt(args: {
-  profile: Profile;
-  repair: TurnRepairRequest;
-  history?: TurnHistoryMessage[];
-}): string {
-  const { profile, repair, history } = args;
-  const guidance =
-    repair.guidance ||
-    profile.outputs.validation?.repairGuidance ||
-    'Revise the previous output so it satisfies the validator rejection. Preserve the intended user-facing substance unless the guidance says otherwise.';
-
-  const historyBlock = formatHistoryBlock(scopeHistory(history));
-
-  let prompt = `## OUTPUT REPAIR REQUEST\n\n`;
-  prompt += `The previous assistant output was rejected by a host validator and must be revised.\n\n`;
-
-  prompt += `### PREVIOUS OUTPUT\n\`\`\`\n${repair.previousOutput.trim()}\n\`\`\`\n\n`;
-  prompt += `### VALIDATOR REJECTION\n${repair.rejection.trim()}\n\n`;
-
-  if (guidance.trim()) {
-    prompt += `### REPAIR GUIDANCE\n${guidance.trim()}\n\n`;
-  }
-
-  if (historyBlock) {
-    prompt += historyBlock;
-  }
-
-  prompt += `### INSTRUCTIONS\n`;
-  prompt += `1. Inspect the previous output and validator rejection.\n`;
-  prompt += `2. Apply the repair guidance without inventing unsupported facts.\n`;
-  prompt += `3. Return only the corrected assistant output required by the active profile.`;
-
-  return prompt;
-}
-
-export { synthesizeRepairPrompt };