@agenthippo-ai/agenthippo 0.1.0

package/out/scripts/analytics/agentide-litellm-otel.config.yaml

@@ -0,0 +1,160 @@
+
+
+# AgentIDE LiteLLM configuration with OpenTelemetry
+# Use this instead of agentide-litellm.config.yaml for lightweight analytics
+#
+# This config uses OTEL instead of Langfuse for observability.
+# Traces are sent to localhost:4318 (OTEL Collector HTTP) which writes to files.
+# Query traces with DuckDB using scripts/analytics/query-analytics.sh
+#
+# Usage:
+#   LITELLM_CONFIG_PATH=scripts/analytics/agentide-litellm-otel.config.yaml \
+#   ./scripts/agentide-litellm.sh
+#
+# The script automatically sets these defaults when otel callback is detected:
+#   OTEL_EXPORTER=otlp_http               # Use OTLP HTTP exporter
+#   OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318  # OTEL Collector HTTP endpoint
+#
+# Optional overrides:
+#   OTEL_SERVICE_NAME=agentide-litellm   # Service name in traces
+#   DEBUG_OTEL=true                      # Enable OTEL debug logging
+
+litellm_settings:
+  telemetry: false  # Disables sending data to LiteLLM's remote servers
+  drop_params: true
+  num_retries: 2
+  # request_timeout: 60
+  reasoning_effort: medium  # Default reasoning effort (e.g. for Codex); overridable per request
+  # set_verbose: True # Turn this on to see the exact JSON being sent in your logs
+
+  stream_usage: true  # Ensures usage metadata is sent in the stream
+  # Optional: force all metadata to be sent to OTEL/callbacks
+  always_include_usage_in_stream: true
+
+  # OpenTelemetry callback - sends traces to OTEL Collector
+  # Make sure OTEL Collector is running: ./scripts/analytics/start-analytics.sh
+  # callbacks: ["agentide_litellm_hooks_v1.structured_genai_otel"]  # , "agentide_litellm_hooks.tool_order_sanitizer"]
+  # callbacks: ["agentide_litellm_hooks_v1.structured_genai_otel", "agentide_litellm_hooks_v1.reasoning_params_sanitizer"]
+  callbacks: ["agentide_litellm_hooks_v1.structured_genai_otel", "agentide_litellm_hooks_v1.codex_proxy_sanitizer", "agentide_litellm_hooks_v1.tool_order_sanitizer", "agentide_litellm_hooks_v1.empty_thinking_sanitizer", "agentide_litellm_hooks_v1.reasoning_params_sanitizer"]
+  turn_off_message_logging: false
+
+callback_settings:
+  otel:
+    message_logging: true          # critical for seeing tool_calls, arguments, responses
+
+model_list:
+
+  - model_name: litellm/gpt-4.1-nano
+    litellm_params:
+      model: openai/gpt-4.1-nano
+      api_base: https://api.openai.com/v1
+      drop_params: true
+      additional_drop_params: ["user", "max_output_tokens", "reasoning.effort", "reasoning_effort"]      # Must be set at specific model -- global does not work: Force LiteLLM to remove this specific field before sending the request
+
+# Add this under (existing) model_list:
+# model_list:
+#   - model_name: ...
+  - model_name: litellm/claude-opus-4-7
+    litellm_params:
+      model: anthropic/claude-opus-4-7
+      reasoning_effort: "medium"
+      additional_drop_params: ["user", "max_output_tokens"]
+      store: false
+      api_key: os.environ/ANTHROPIC_SETUP_TOKEN
+    model_info:
+      upstream_provider: "anthropic-setup-token"
+
+# Add this under (existing) model_list:
+# model_list:
+#   - model_name: ...
+  - model_name: litellm/claude-haiku-4-5-20251001
+    litellm_params:
+      model: anthropic/claude-haiku-4-5-20251001
+      top_p: null
+      drop_params: true
+      api_base: https://api.anthropic.com
+
+  - model_name: litellm/claude-sonnet-4-6
+    litellm_params:
+      model: anthropic/claude-sonnet-4-6
+      api_base: https://api.anthropic.com
+
+
+# Add this under (existing) model_list:
+# model_list:
+#   - model_name: ...
+  - model_name: litellm/gpt-5.3-codex
+    litellm_params:
+      model: openai/gpt-5.3-codex
+      store: false
+      api_key: os.environ/OPENAI_CODEX_API_KEY
+      api_base: https://chatgpt.com/backend-api/codex
+      reasoning_effort: "medium"
+      additional_drop_params: ["user", "max_output_tokens"]      # Must be set at specific model -- global does not work: Force LiteLLM to remove this specific field before sending the request
+
+  - model_name: litellm/gpt-5.5
+    litellm_params:
+      model: openai/gpt-5.5
+      store: false
+      api_key: os.environ/OPENAI_API_KEY
+      api_base: https://api.openai.com/v1
+      reasoning_effort: "medium"
+      additional_drop_params: ["user", "max_output_tokens"]      # Must be set at specific model -- global does not work: Force LiteLLM to remove this specific field before sending the request
+
+# Add this under (existing) model_list:
+# model_list:
+#   - model_name: ...
+  - model_name: litellm/gpt-5.1-codex-mini
+    litellm_params:
+      model: openai/gpt-5.1-codex-mini
+      reasoning_effort: "medium"
+      additional_drop_params: ["user", "max_output_tokens", "temperature"]
+      store: false
+      api_key: os.environ/OPENAI_CODEX_API_KEY
+      api_base: https://chatgpt.com/backend-api/codex
+
+# Add this under (existing) model_list:
+# model_list:
+#   - model_name: ...
+  - model_name: litellm/claude-opus-4-6-subs
+    litellm_params:
+      model: anthropic/claude-opus-4-6
+      reasoning_effort: "medium"
+      max_tokens: 64000
+      additional_drop_params: ["user", "max_output_tokens"]
+      store: false
+      api_key: os.environ/ANTHROPIC_SETUP_TOKEN
+
+
+  - model_name: litellm/claude-haiku-4-5-subs
+    litellm_params:
+      model: anthropic/claude-haiku-4-5
+      reasoning_effort: "medium"
+      additional_drop_params: ["user", "max_output_tokens"]
+      store: false
+      api_key: os.environ/ANTHROPIC_SETUP_TOKEN
+
+# Add this under (existing) model_list:
+# model_list:
+#   - model_name: ...
+  - model_name: litellm/claude-opus-4-7-test
+    litellm_params:
+      model: anthropic/claude-opus-4-7
+      reasoning_effort: "medium"
+      additional_drop_params: ["user", "max_output_tokens"]
+      store: false
+    model_info:
+      upstream_provider: "anthropic"
+
+# Add this under (existing) model_list:
+# model_list:
+#   - model_name: ...
+  - model_name: litellm/gpt-5.4-nano
+    litellm_params:
+      model: openai/gpt-5.4-nano
+      reasoning_effort: "medium"
+      additional_drop_params: ["user", "max_output_tokens"]
+      store: false
+      api_base: https://api.openai.com/v1
+    model_info:
+      upstream_provider: "openai"

package/out/scripts/analytics/default-seed-scripts.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "seedScripts": [
+    "generate-default-charts.py",
+    "duckdbLocator.js",
+    "wow-model-widget.js",
+    "session-timeline-widget.js",
+    "session-comparison-widget.js",
+    "hotspot-analysis-widget.js",
+    "token-cost-flamegraph-widget.js"
+  ]
+}

package/out/scripts/analytics/duckdbLocator.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/* Copyright (c) AgentHippo.ai. All rights reserved. */
+
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+function findDuckdb() {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir() || '';
+  const candidates = [
+    'duckdb',
+    'duckdb.exe',
+    path.join(home, '.agent-hippo', 'bin', 'duckdb.exe'),
+    path.join(home, '.agent-hippo', 'bin', 'duckdb'),
+    '/opt/homebrew/bin/duckdb',
+    '/usr/local/bin/duckdb',
+  ];
+  for (const candidate of candidates) {
+    try {
+      execFileSync(candidate, ['--version'], { stdio: 'ignore' });
+      return candidate;
+    } catch {
+      // continue
+    }
+  }
+  return null;
+}
+
+module.exports = { findDuckdb };

package/out/scripts/analytics/fleet-local-adapter.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Formal local fleet adapter: produces the same fleet view as the in-process adapter.
+ * Extension writes input to a predefined path and sets env AGENTIDE_FLEET_LOCAL_INPUT_PATH;
+ * this script reads from that path. Fallback: stdin (for testing).
+ * Input JSON: { source, filters, duckdbPath, duckdbBinaryPath?, scheduledRequests }
+ * Writes to stdout: { source: 'local', sessions: FleetSessionRow[] }
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const fs = require('fs');
+const path = require('path');
+
+const execFileAsync = promisify(execFile);
+
+const SOURCE_ID = 'local';
+const FLEET_LIMIT = 500;
+
+function sqlLiteral(s) {
+	if (s == null || s === '') return "''";
+	const str = String(s);
+	return "'" + str.replace(/\\/g, '\\\\').replace(/'/g, "''") + "'";
+}
+
+function buildWhereConditions(filters) {
+	const conditions = ['session_id IS NOT NULL'];
+	const scope = (filters && filters.scope) || 'global';
+	const projectId = filters && filters.projectId;
+	const agentId = filters && filters.agentId;
+	if (scope === 'workspace') {
+		if (!projectId) {
+			conditions.push('1 = 0');
+		} else {
+			conditions.push(`(project_id = ${sqlLiteral(projectId)} OR project_id IS NULL)`);
+		}
+	}
+	if (agentId) {
+		conditions.push(`agent_id = ${sqlLiteral(agentId)}`);
+	}
+	return conditions.join(' AND ');
+}
+
+function normalizeStatus(session) {
+	const now = Date.now();
+	const startedMs = session.startedAt ? new Date(session.startedAt).getTime() : NaN;
+	const endedMs = session.endedAt ? new Date(session.endedAt).getTime() : NaN;
+	if (Number.isFinite(startedMs) && startedMs > now + 60_000) return 'scheduled';
+	if (!Number.isFinite(endedMs) || endedMs <= 0 || (Number.isFinite(startedMs) && endedMs < startedMs)) return 'in_progress';
+	if (endedMs > now - 90_000) return 'in_progress';
+	return 'done';
+}
+
+function toRow(sessionId, agentId, startedAt, endedAt, status, taskTitle, model, engine, turns, totalTokens) {
+	const now = new Date().toISOString();
+	return {
+		source: SOURCE_ID,
+		sessionId,
+		agentId,
+		status,
+		startedAt: startedAt || '',
+		endedAt: endedAt || '',
+		taskTitle: taskTitle || 'Task',
+		model: model || 'unknown',
+		engine: engine || '',
+		channelType: 'none',
+		channelTarget: '',
+		turns: Number.isFinite(turns) ? turns : 0,
+		totalTokens: Number.isFinite(totalTokens) ? totalTokens : 0,
+		disconnectCapable: false,
+		updatedAt: now,
+	};
+}
+
+async function queryFleetSessions(duckdbPath, duckdbBinary, conditions) {
+	const limit = Math.min(Math.max(1, FLEET_LIMIT), 10000);
+	const sqlWithEngine = `
+SELECT
+	session_id as sessionId,
+	agent_id as agentId,
+	MIN(to_timestamp(start_ms / 1000)) as startedAt,
+	MAX(to_timestamp((start_ms + COALESCE(duration_ms, 0)) / 1000)) as endedAt,
+	COUNT(*) as turns,
+	COALESCE(SUM(input_tokens), 0) + COALESCE(SUM(output_tokens), 0) as totalTokens,
+	COALESCE(arg_max(COALESCE(model, 'unknown'), start_ms), 'unknown') as model,
+	COALESCE(arg_max(COALESCE(engine, ''), start_ms), '') as engine
+FROM spans
+WHERE ${conditions}
+GROUP BY session_id, agent_id
+ORDER BY MAX(start_ms) DESC
+LIMIT ${limit}`;
+	const sqlWithoutEngine = `
+SELECT
+	session_id as sessionId,
+	agent_id as agentId,
+	MIN(to_timestamp(start_ms / 1000)) as startedAt,
+	MAX(to_timestamp((start_ms + COALESCE(duration_ms, 0)) / 1000)) as endedAt,
+	COUNT(*) as turns,
+	COALESCE(SUM(input_tokens), 0) + COALESCE(SUM(output_tokens), 0) as totalTokens,
+	COALESCE(arg_max(COALESCE(model, 'unknown'), start_ms), 'unknown') as model
+FROM spans
+WHERE ${conditions}
+GROUP BY session_id, agent_id
+ORDER BY MAX(start_ms) DESC
+LIMIT ${limit}`;
+	const binary = duckdbBinary || 'duckdb';
+	try {
+		const { stdout } = await execFileAsync(binary, [duckdbPath, '-json', '-c', sqlWithEngine], {
+			timeout: 30_000,
+			maxBuffer: 5 * 1024 * 1024,
+		});
+		const rows = stdout.trim() ? JSON.parse(stdout) : [];
+		return Array.isArray(rows) ? rows.map((r) => ({ ...r, engine: r.engine != null ? r.engine : '' })) : [];
+	} catch (err) {
+		const msg = (err && err.message) || String(err);
+		if (/engine|column|referenced/.test(msg)) {
+			const { stdout } = await execFileAsync(binary, [duckdbPath, '-json', '-c', sqlWithoutEngine], {
+				timeout: 30_000,
+				maxBuffer: 5 * 1024 * 1024,
+			});
+			const rows = stdout.trim() ? JSON.parse(stdout) : [];
+			return Array.isArray(rows) ? rows.map((r) => ({ ...r, engine: '' })) : [];
+		}
+		throw err;
+	}
+}
+
+function readStdin() {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		process.stdin.setEncoding('utf8');
+		process.stdin.on('data', (chunk) => chunks.push(chunk));
+		process.stdin.on('end', () => resolve(chunks.join('')));
+		process.stdin.on('error', reject);
+	});
+}
+
+function readInput() {
+	const inputPath = process.env.AGENTIDE_FLEET_LOCAL_INPUT_PATH;
+	if (inputPath && typeof inputPath === 'string') {
+		try {
+			return Promise.resolve(fs.readFileSync(inputPath, 'utf-8'));
+		} catch (e) {
+			process.stderr.write(`fleet-local-adapter: failed to read ${inputPath}: ${(e && e.message) || e}\n`);
+			process.exit(1);
+		}
+	}
+	return readStdin();
+}
+
+async function main() {
+	const raw = await readInput();
+	let input;
+	try {
+		input = JSON.parse(raw);
+	} catch (_) {
+		process.stderr.write('fleet-local-adapter: invalid JSON\n');
+		process.exit(1);
+	}
+	const duckdbPath = input.duckdbPath;
+	const duckdbBinaryPath = input.duckdbBinaryPath;
+	const filters = input.filters || {};
+	const scheduledRequests = Array.isArray(input.scheduledRequests) ? input.scheduledRequests : [];
+	if (!duckdbPath || typeof duckdbPath !== 'string') {
+		process.stderr.write('fleet-local-adapter: missing duckdbPath\n');
+		process.exit(1);
+	}
+	const conditions = buildWhereConditions(filters);
+	let sessions = [];
+	try {
+		sessions = await queryFleetSessions(duckdbPath, duckdbBinaryPath, conditions);
+	} catch (err) {
+		process.stderr.write(`fleet-local-adapter: DuckDB query failed: ${(err && err.message) || err}\n`);
+		// Continue with scheduled only
+	}
+	const now = Date.now();
+	const sessionsById = new Map();
+
+	for (const session of sessions) {
+		const status = normalizeStatus(session);
+		const taskTitle = session.agentPack != null ? session.agentPack : (session.agentId != null ? session.agentId : (session.sessionId != null ? session.sessionId : 'Task'));
+		sessionsById.set(session.sessionId, toRow(
+			session.sessionId,
+			session.agentId,
+			session.startedAt,
+			session.endedAt,
+			status,
+			taskTitle,
+			session.model,
+			session.engine != null ? session.engine : '',
+			session.turns,
+			session.totalTokens,
+		));
+	}
+
+	for (const s of scheduledRequests) {
+		const runAtIso = s.runAt != null ? new Date(Number(s.runAt)).toISOString() : new Date().toISOString();
+		const messageText = (s.messageText != null && typeof s.messageText === 'string') ? s.messageText : '';
+		const messagePreview = messageText.length > 80 ? messageText.slice(0, 77) + '...' : messageText;
+		const sessionId = (s.sessionId != null && typeof s.sessionId === 'string') ? s.sessionId.trim() : '';
+		if (!sessionId) continue;
+		const existing = sessionsById.get(sessionId);
+		if (existing) {
+			if (existing.status === 'done' && Number(s.runAt) >= now - 2 * 60_000) {
+				existing.status = 'scheduled';
+				existing.startedAt = runAtIso;
+				existing.endedAt = '';
+			}
+			if (!existing.taskTitle || existing.taskTitle === existing.sessionId || existing.taskTitle === (existing.agentId || '')) {
+				existing.taskTitle = messagePreview || existing.taskTitle;
+			}
+			if (!existing.agentId && s.agentId) existing.agentId = s.agentId;
+			continue;
+		}
+		sessionsById.set(sessionId, toRow(
+			sessionId,
+			s.agentId,
+			runAtIso,
+			'',
+			'scheduled',
+			messagePreview || s.agentId || sessionId || 'Scheduled task',
+			s.model != null ? s.model : 'scheduled',
+			s.engine != null ? s.engine : '',
+			0,
+			0,
+		));
+	}
+
+	const rows = Array.from(sessionsById.values()).sort((a, b) => {
+		const order = (st) => (st === 'in_progress' ? 0 : st === 'scheduled' ? 1 : 2);
+		const d = order(a.status) - order(b.status);
+		if (d !== 0) return d;
+		const aStart = (a.startedAt && new Date(a.startedAt).getTime()) || 0;
+		const bStart = (b.startedAt && new Date(b.startedAt).getTime()) || 0;
+		return bStart - aStart;
+	});
+
+	const out = { source: SOURCE_ID, sessions: rows };
+	process.stdout.write(JSON.stringify(out));
+}
+
+main().catch((err) => {
+	process.stderr.write(`fleet-local-adapter: ${(err && err.message) || err}\n`);
+	process.exit(1);
+});