@gakim-digital/dexter-bridge 0.5.0

package/src/agentOutput.js

@@ -0,0 +1,232 @@
+const TOKEN_FIELDS = [
+  'inputTokens',
+  'outputTokens',
+  'cachedInputTokens',
+  'cacheWriteInputTokens',
+  'reasoningOutputTokens',
+];
+
+function nonNegativeNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+function optionalNonNegativeNumber(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+
+function firstDefined(record, keys) {
+  for (const key of keys) {
+    if (record?.[key] !== undefined && record?.[key] !== null) return record[key];
+  }
+  return undefined;
+}
+
+export function normalizeCompanionTokenUsage(value = {}) {
+  const inputTokens = nonNegativeNumber(firstDefined(value, ['inputTokens', 'input_tokens']));
+  const outputTokens = nonNegativeNumber(firstDefined(value, ['outputTokens', 'output_tokens']));
+  const cachedInputTokens = nonNegativeNumber(firstDefined(value, [
+    'cachedInputTokens',
+    'cached_input_tokens',
+    'cacheReadInputTokens',
+    'cache_read_input_tokens',
+  ]));
+  const cacheWriteInputTokens = nonNegativeNumber(firstDefined(value, [
+    'cacheWriteInputTokens',
+    'cache_write_input_tokens',
+    'cacheCreationInputTokens',
+    'cache_creation_input_tokens',
+  ]));
+  const reasoningOutputTokens = nonNegativeNumber(firstDefined(value, [
+    'reasoningOutputTokens',
+    'reasoning_output_tokens',
+  ]));
+  const explicitTotal = nonNegativeNumber(firstDefined(value, ['totalTokens', 'total_tokens']));
+  const totalTokens = explicitTotal || inputTokens + outputTokens + reasoningOutputTokens;
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    cacheWriteInputTokens,
+    reasoningOutputTokens,
+    totalTokens,
+  };
+}
+
+function usageHasReportedTokens(usage) {
+  return TOKEN_FIELDS.some((field) => usage[field] > 0) || usage.totalTokens > 0;
+}
+
+function normalizeModelUsage(modelUsage) {
+  if (!modelUsage || typeof modelUsage !== 'object' || Array.isArray(modelUsage)) return [];
+  return Object.entries(modelUsage).flatMap(([model, raw]) => {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return [];
+    const usage = normalizeCompanionTokenUsage(raw);
+    const estimatedCostUSD = optionalNonNegativeNumber(firstDefined(raw, ['costUSD', 'cost_usd', 'estimatedCostUSD']));
+    return [{ model, ...usage, ...(estimatedCostUSD === undefined ? {} : { estimatedCostUSD }) }];
+  });
+}
+
+function parseWholeJson(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+export function parseClaudeOutput(stdout) {
+  const parsed = parseWholeJson(stdout);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return {
+      resultText: String(stdout || '').trim(),
+      tokenUsage: normalizeCompanionTokenUsage(),
+      modelUsage: [],
+      usageAvailable: false,
+      usageSource: 'claude-code',
+      usageAccuracy: 'unavailable',
+    };
+  }
+
+  const hasEnvelope = typeof parsed.result === 'string' || parsed.usage || parsed.total_cost_usd !== undefined || parsed.modelUsage;
+  if (!hasEnvelope) {
+    return {
+      resultText: String(stdout || '').trim(),
+      tokenUsage: normalizeCompanionTokenUsage(),
+      modelUsage: [],
+      usageAvailable: false,
+      usageSource: 'claude-code',
+      usageAccuracy: 'unavailable',
+    };
+  }
+
+  const tokenUsage = normalizeCompanionTokenUsage(parsed.usage || {});
+  const modelUsage = normalizeModelUsage(parsed.modelUsage || parsed.model_usage);
+  const estimatedCostUSD = optionalNonNegativeNumber(parsed.total_cost_usd ?? parsed.totalCostUsd);
+  return {
+    resultText: typeof parsed.result === 'string' ? parsed.result.trim() : '',
+    tokenUsage,
+    model: typeof parsed.model === 'string' ? parsed.model : undefined,
+    sessionId: typeof parsed.session_id === 'string'
+      ? parsed.session_id
+      : typeof parsed.sessionId === 'string'
+        ? parsed.sessionId
+        : undefined,
+    modelUsage,
+    ...(estimatedCostUSD === undefined ? {} : { estimatedCostUSD }),
+    usageAvailable: usageHasReportedTokens(tokenUsage) || estimatedCostUSD !== undefined || modelUsage.length > 0,
+    usageSource: 'claude-code',
+    usageAccuracy: 'reported',
+  };
+}
+
+function parseJsonLines(stdout) {
+  return String(stdout || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .flatMap((line) => {
+      try {
+        const parsed = JSON.parse(line);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? [parsed] : [];
+      } catch {
+        return [];
+      }
+    });
+}
+
+export function parseCodexOutput(stdout) {
+  const events = parseJsonLines(stdout);
+  if (!events.length) {
+    return {
+      resultText: String(stdout || '').trim(),
+      tokenUsage: normalizeCompanionTokenUsage(),
+      modelUsage: [],
+      usageAvailable: false,
+      usageSource: 'codex',
+      usageAccuracy: 'unavailable',
+    };
+  }
+
+  let resultText = '';
+  let sessionId;
+  const accumulator = createCompanionUsageAccumulator('codex');
+  for (const event of events) {
+    if (
+      (event.type === 'thread.started' || event.type === 'thread.resumed') &&
+      typeof (event.thread_id || event.threadId) === 'string'
+    ) {
+      sessionId = event.thread_id || event.threadId;
+    }
+    if (event.type === 'item.completed' && event.item?.type === 'agent_message' && typeof event.item.text === 'string') {
+      resultText = event.item.text.trim();
+    }
+    if (event.type === 'turn.completed' && event.usage && typeof event.usage === 'object') {
+      accumulator.add({ tokenUsage: event.usage, usageAvailable: true, usageAccuracy: 'reported', usageSource: 'codex' });
+    }
+  }
+  const usage = accumulator.snapshot();
+  return {
+    resultText: resultText || String(stdout || '').trim(),
+    tokenUsage: usage.tokenUsage,
+    modelUsage: [],
+    sessionId,
+    usageAvailable: usage.usageAvailable,
+    usageSource: 'codex',
+    usageAccuracy: usage.usageAvailable ? 'reported' : 'unavailable',
+  };
+}
+
+export function parseAgentOutput(agent, stdout) {
+  return agent === 'codex' ? parseCodexOutput(stdout) : parseClaudeOutput(stdout);
+}
+
+export function createCompanionUsageAccumulator(source) {
+  const totals = normalizeCompanionTokenUsage();
+  const modelTotals = new Map();
+  let estimatedCostUSD = 0;
+  let hasEstimatedCost = false;
+  let usageAvailable = false;
+  let accuracy = 'unavailable';
+
+  return {
+    add(report = {}) {
+      const usage = normalizeCompanionTokenUsage(report.tokenUsage || report.usage || report);
+      for (const field of TOKEN_FIELDS) totals[field] += usage[field];
+      totals.totalTokens += usage.totalTokens;
+      usageAvailable = usageAvailable || Boolean(report.usageAvailable) || usageHasReportedTokens(usage);
+      if (report.usageAccuracy === 'reported') accuracy = 'reported';
+
+      const cost = optionalNonNegativeNumber(report.estimatedCostUSD);
+      if (cost !== undefined) {
+        estimatedCostUSD += cost;
+        hasEstimatedCost = true;
+      }
+
+      for (const item of Array.isArray(report.modelUsage) ? report.modelUsage : []) {
+        if (!item || typeof item !== 'object' || typeof item.model !== 'string' || !item.model.trim()) continue;
+        const current = modelTotals.get(item.model) || { model: item.model, ...normalizeCompanionTokenUsage(), estimatedCostUSD: 0 };
+        const itemUsage = normalizeCompanionTokenUsage(item);
+        for (const field of TOKEN_FIELDS) current[field] += itemUsage[field];
+        current.totalTokens += itemUsage.totalTokens;
+        const itemCost = optionalNonNegativeNumber(item.estimatedCostUSD);
+        if (itemCost !== undefined) current.estimatedCostUSD += itemCost;
+        modelTotals.set(item.model, current);
+      }
+    },
+    snapshot() {
+      return {
+        tokenUsage: { ...totals },
+        ...(hasEstimatedCost ? { estimatedCostUSD } : {}),
+        modelUsage: Array.from(modelTotals.values()),
+        usageAvailable,
+        usageSource: source,
+        usageAccuracy: usageAvailable ? accuracy : 'unavailable',
+      };
+    },
+  };
+}

package/src/api.js

@@ -0,0 +1,165 @@
+import {
+  BRIDGE_VERSION,
+  companionModelMetadata,
+  normalizeApiBaseUrl,
+  normalizeAgentName,
+  normalizeCompanionModelName,
+} from './config.js';
+
+export class DexterBridgeApiError extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.name = 'DexterBridgeApiError';
+    this.status = status;
+    this.body = body;
+  }
+}
+
+function bearerHeaders(deviceToken) {
+  return deviceToken ? { Authorization: `Bearer ${deviceToken}` } : {};
+}
+
+function bridgeMetadata(agent, model, metadata) {
+  const normalizedAgent = normalizeAgentName(agent);
+  const normalizedModel = normalizeCompanionModelName(model, normalizedAgent);
+  const modelMetadata = companionModelMetadata(normalizedAgent, normalizedModel);
+  return {
+    shell: 'npx',
+    agent: normalizedAgent,
+    model: normalizedModel,
+    modelLabel: modelMetadata.modelLabel,
+    models: modelMetadata.models,
+    ...(metadata && typeof metadata === 'object' ? metadata : {}),
+  };
+}
+
+export async function requestJson(apiBaseUrl, path, {
+  method = 'GET',
+  body,
+  deviceToken,
+  fetchImpl = fetch,
+} = {}) {
+  const response = await fetchImpl(`${normalizeApiBaseUrl(apiBaseUrl)}${path}`, {
+    method,
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      ...bearerHeaders(deviceToken),
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const parsed = await response.json().catch(() => null);
+  if (!response.ok || parsed?.success === false) {
+    throw new DexterBridgeApiError(
+      parsed?.error || parsed?.message || `Dexter API request failed with status ${response.status}`,
+      response.status,
+      parsed,
+    );
+  }
+  return parsed;
+}
+
+export function claimPairing(apiBaseUrl, {
+  pairingCode,
+  pairingToken,
+  deviceName,
+  agent,
+  model,
+  metadata,
+  fetchImpl,
+}) {
+  const normalizedAgent = normalizeAgentName(agent);
+  const normalizedModel = normalizeCompanionModelName(model, normalizedAgent);
+  return requestJson(apiBaseUrl, '/ai/framer/companion/claim', {
+    method: 'POST',
+    fetchImpl,
+    body: {
+      pairingCode,
+      pairingToken,
+      deviceName,
+      platform: process.platform,
+      companionVersion: BRIDGE_VERSION,
+      metadata: bridgeMetadata(normalizedAgent, normalizedModel, metadata),
+    },
+  });
+}
+
+export function heartbeat(apiBaseUrl, {
+  deviceToken,
+  status = 'ready',
+  agent,
+  model,
+  metadata,
+  fetchImpl,
+}) {
+  const normalizedAgent = normalizeAgentName(agent);
+  const normalizedModel = normalizeCompanionModelName(model, normalizedAgent);
+  return requestJson(apiBaseUrl, '/ai/framer/companion/heartbeat', {
+    method: 'POST',
+    deviceToken,
+    fetchImpl,
+    body: {
+      status,
+      platform: process.platform,
+      companionVersion: BRIDGE_VERSION,
+      metadata: bridgeMetadata(normalizedAgent, normalizedModel, metadata),
+    },
+  });
+}
+
+export function disconnectDevice(apiBaseUrl, {
+  deviceToken,
+  fetchImpl,
+}) {
+  return requestJson(apiBaseUrl, '/ai/framer/companion/device/self', {
+    method: 'DELETE',
+    deviceToken,
+    fetchImpl,
+    body: {
+      platform: process.platform,
+      companionVersion: BRIDGE_VERSION,
+    },
+  });
+}
+
+export function pollRun(apiBaseUrl, {
+  deviceToken,
+  waitMs = 25000,
+  agent,
+  model,
+  metadata,
+  fetchImpl,
+}) {
+  const normalizedAgent = normalizeAgentName(agent);
+  const normalizedModel = normalizeCompanionModelName(model, normalizedAgent);
+  return requestJson(apiBaseUrl, '/ai/framer/companion/runs/poll', {
+    method: 'POST',
+    deviceToken,
+    fetchImpl,
+    body: {
+      waitMs,
+      platform: process.platform,
+      companionVersion: BRIDGE_VERSION,
+      status: 'polling',
+      metadata: bridgeMetadata(normalizedAgent, normalizedModel, metadata),
+    },
+  });
+}
+
+export function postRunEvent(apiBaseUrl, {
+  deviceToken,
+  runId,
+  event,
+  fetchImpl,
+}) {
+  return requestJson(apiBaseUrl, `/ai/framer/companion/runs/${encodeURIComponent(runId)}/events`, {
+    method: 'POST',
+    deviceToken,
+    fetchImpl,
+    body: {
+      event,
+      platform: process.platform,
+      companionVersion: BRIDGE_VERSION,
+    },
+  });
+}