@ziggs-ai/agent-sdk 0.1.12 → 0.2.0

package/src/server/proactive/ProactiveTrigger.ts

@@ -1,83 +0,0 @@
-import { publishOffer, pullOffers, claimOffer, type Creds } from '@ziggs-ai/api-client';
-import type { PublishOfferPayload, PullOffersOptions } from '@ziggs-ai/api-client';
-import { runtimeLog } from '../../shared/runtimeLog.js';
-
-interface TickContext {
-  agentId: string;
-  marketplace: {
-    publishOffer: (payload: PublishOfferPayload) => Promise<unknown>;
-    pullOffers: (options?: PullOffersOptions) => Promise<unknown[]>;
-    claimOffer: (agreementId: string) => Promise<unknown>;
-  };
-}
-
-interface ProactiveTriggerOptions {
-  interval: number;
-  creds: Creds;
-  onTick: (ctx: TickContext) => Promise<void>;
-  onError?: (err: unknown) => void;
-  runImmediately?: boolean;
-}
-
-export class ProactiveTrigger {
-  private interval: number;
-  private creds: Creds;
-  private onTick: (ctx: TickContext) => Promise<void>;
-  private onError: (err: unknown) => void;
-  private runImmediately: boolean;
-  private _running: boolean;
-  private _timer: ReturnType<typeof setTimeout> | null;
-
-  constructor({ interval, creds, onTick, onError, runImmediately = false }: ProactiveTriggerOptions) {
-    if (!interval || typeof interval !== 'number' || interval < 1000) throw new Error('ProactiveTrigger: interval must be a number >= 1000ms');
-    if (!creds?.operatorKey || !creds?.agentId) throw new Error('ProactiveTrigger: creds.operatorKey and creds.agentId are required');
-    if (typeof onTick !== 'function') throw new Error('ProactiveTrigger: onTick must be a function');
-    this.interval = interval;
-    this.creds = creds;
-    this.onTick = onTick;
-    this.onError = onError ?? ((err) => runtimeLog.error('ProactiveTrigger', `tick error: ${String(err)}`));
-    this.runImmediately = runImmediately;
-    this._running = false;
-    this._timer = null;
-  }
-
-  start(): void {
-    if (this._running) return;
-    this._running = true;
-    runtimeLog.debug(
-      'ProactiveTrigger',
-      `started (agentId=${this.creds.agentId}, interval=${this.interval}ms)`,
-    );
-    if (this.runImmediately) this._tick();
-    else this._schedule();
-  }
-
-  stop(): void {
-    this._running = false;
-    if (this._timer) { clearTimeout(this._timer); this._timer = null; }
-    runtimeLog.debug('ProactiveTrigger', `stopped (agentId=${this.creds.agentId})`);
-  }
-
-  private _schedule(): void {
-    if (!this._running) return;
-    this._timer = setTimeout(() => this._tick(), this.interval);
-  }
-
-  private async _tick(): Promise<void> {
-    if (!this._running) return;
-    try { await this.onTick(this._buildContext()); } catch (err) { this.onError(err); }
-    this._schedule();
-  }
-
-  private _buildContext(): TickContext {
-    const creds = this.creds;
-    return {
-      agentId: creds.agentId,
-      marketplace: {
-        publishOffer: (payload) => publishOffer(payload, creds),
-        pullOffers: (options) => pullOffers(options, creds),
-        claimOffer: (agreementId) => claimOffer(agreementId, creds),
-      },
-    };
-  }
-}

package/src/server/runLauncher.ts

@@ -1,146 +0,0 @@
-import { ConnectionPool } from './ConnectionPool.js';
-import { AgentHost, type AgentHostOptions } from '../AgentHost.js';
-import { createHealthServer } from './createHealthServer.js';
-import { runtimeLog } from '../shared/runtimeLog.js';
-import type { Server } from 'http';
-
-type AgentConfig = AgentHostOptions & {
-  ownAgentId?: string;
-  options?: { ownAgentId?: string; name?: string };
-};
-
-interface SingleOptions {
-  operatorKey?: string;
-  label?: string;
-  port?: number | string;
-  healthServer?: boolean;
-  onShutdown?: () => Promise<void>;
-}
-
-interface FleetOptions extends SingleOptions {
-  wsUrl?: string;
-  agentMeta?: Record<string, unknown>[];
-  primary?: AgentConfig | ((pool: ConnectionPool) => AgentConfig);
-  preWake?: string[];
-  poolOptions?: { maxActive?: number; idleTimeoutMs?: number };
-}
-
-export async function runLauncher(
-  configOrConfigs: AgentConfig | AgentConfig[],
-  opts: FleetOptions = {},
-): Promise<unknown> {
-  if (Array.isArray(configOrConfigs)) return runFleet(configOrConfigs, opts);
-  return runSingle(configOrConfigs, opts as SingleOptions);
-}
-
-async function runSingle(
-  config: AgentConfig,
-  { operatorKey, label = 'agent', port = process.env.PORT || 8080, healthServer = true, onShutdown }: SingleOptions = {},
-): Promise<{ agent: unknown; healthServer?: Server }> {
-  const effectiveKey = operatorKey ?? process.env.ZIGGS_OPERATOR_KEY;
-  const decorated = effectiveKey && !config.operatorKey ? { ...config, operatorKey: effectiveKey } : config;
-  const agent = new AgentHost(decorated);
-  try {
-    await agent.connectAsync();
-    runtimeLog.info(
-      label,
-      `"${(agent as unknown as Record<string, unknown>)['options'] ? ((agent as unknown as Record<string, {agentId?: string; name?: string | null}>)['options']?.agentId ?? (agent as unknown as Record<string, {name?: string | null}>)['options']?.name) : 'agent'}" connected`,
-    );
-  } catch (err) {
-    runtimeLog.warn(label, `Agent failed to connect at startup: ${(err as Error).message} — will retry`);
-  }
-
-  const server = healthServer ? createHealthServer({ port: Number(port), label }) : null;
-
-  process.on('SIGTERM', async () => {
-    runtimeLog.info(label, 'SIGTERM — shutting down');
-    agent.disconnect();
-    await agent.drain(30_000);
-    try {
-      await onShutdown?.();
-    } catch (err) {
-      runtimeLog.warn(label, `onShutdown error: ${(err as Error).message}`);
-    }
-    server?.close();
-    process.exit(0);
-  });
-
-  return { agent, healthServer: server ?? undefined };
-}
-
-async function runFleet(
-  configs: AgentConfig[],
-  {
-    operatorKey, wsUrl = process.env.WS_URL, port = process.env.PORT || 8080,
-    healthServer = true, label = 'launcher', agentMeta,
-    primary: primaryConfig, preWake = [], poolOptions, onShutdown,
-  }: FleetOptions = {},
-): Promise<{ pool: ConnectionPool; primary: unknown; healthServer?: Server }> {
-  const pool = new ConnectionPool(poolOptions);
-  const effectiveKey = operatorKey ?? process.env.ZIGGS_OPERATOR_KEY;
-  const decoratedConfigs = effectiveKey
-    ? configs.map(c => (c.operatorKey ? c : { ...c, operatorKey: effectiveKey }))
-    : configs;
-  pool.register(decoratedConfigs, agentMeta as Record<string, unknown>[]);
-  const server = healthServer ? createHealthServer({ port: Number(port), label, pool }) : null;
-
-  let resolvedPrimaryConfig: AgentConfig | undefined = typeof primaryConfig === 'function'
-    ? primaryConfig(pool)
-    : primaryConfig;
-  if (resolvedPrimaryConfig && effectiveKey && !resolvedPrimaryConfig.operatorKey) {
-    resolvedPrimaryConfig = { ...resolvedPrimaryConfig, operatorKey: effectiveKey };
-  }
-
-  const controlKey = effectiveKey ?? configs.find(c => c.operatorKey)?.operatorKey ?? resolvedPrimaryConfig?.operatorKey;
-  if (controlKey) {
-    pool.startControl({ wsUrl, operatorKey: controlKey });
-  } else {
-    runtimeLog.warn(label, 'No operatorKey provided — skipping control socket');
-  }
-
-  let primary: unknown = null;
-  if (resolvedPrimaryConfig) {
-    primary = new AgentHost(resolvedPrimaryConfig);
-    try {
-      await (primary as { connectAsync: () => Promise<void> }).connectAsync();
-      runtimeLog.info(
-        label,
-        `Primary agent "${resolvedPrimaryConfig.name || resolvedPrimaryConfig.ownAgentId || 'primary'}" connected`,
-      );
-    } catch (err) {
-      // Backend may not be ready yet — socket.io reconnects automatically.
-      // Don't crash the process; the primary agent will be live once it reconnects.
-      runtimeLog.warn(
-        label,
-        `Primary agent "${resolvedPrimaryConfig.name || resolvedPrimaryConfig.ownAgentId || 'primary'}" failed to connect at startup: ${(err as Error).message} — will retry`,
-      );
-    }
-  }
-
-  if (preWake.length > 0) {
-    await Promise.all(preWake.map(id =>
-      pool.wake(id)
-        .then(() => runtimeLog.debug(label, `Pre-woke "${id}"`))
-        .catch(err => runtimeLog.warn(label, `Could not pre-wake "${id}": ${(err as Error).message}`)),
-    ));
-  }
-
-  runtimeLog.info(label, `Ready — ${pool.size} agent(s) registered, ${pool.listActive().length} connected`);
-
-  process.on('SIGTERM', async () => {
-    runtimeLog.info(label, 'SIGTERM — shutting down');
-    pool.stopControl();
-    (primary as { disconnect?: () => void })?.disconnect?.();
-    await (primary as { drain?: (ms: number) => Promise<void> })?.drain?.(30_000);
-    await pool.disconnectAll();
-    try {
-      await onShutdown?.();
-    } catch (err) {
-      runtimeLog.warn(label, `onShutdown error: ${(err as Error).message}`);
-    }
-    server?.close();
-    process.exit(0);
-  });
-
-  return { pool, primary, healthServer: server ?? undefined };
-}

package/src/server/tasks/TaskService.ts

@@ -1,111 +0,0 @@
-import {
-  createTask, getTask, getActiveTasksForAgent, getActiveTasksForChat, getSubtasks,
-  updateTaskState, updateTaskPlanStep, cancelTask,
-  reportTask, setTaskSatisfaction, countTasks,
-  type Creds, type Task, type TaskState,
-} from '@ziggs-ai/api-client';
-import type { CountTasksFilters } from '@ziggs-ai/api-client';
-import { runtimeLog } from '../../shared/runtimeLog.js';
-
-function safeJsonStringify(value: unknown): unknown {
-  if (value === null || value === undefined) return value;
-  if (typeof value === 'string') return value;
-  if (typeof value !== 'object') return String(value);
-  const seen = new WeakSet();
-  try {
-    return JSON.stringify(value, (_key, val) => {
-      if (typeof val === 'object' && val !== null) {
-        if (seen.has(val)) return '[Circular]';
-        seen.add(val);
-      }
-      return val;
-    }, 2);
-  } catch {
-    return String(value);
-  }
-}
-
-export class TaskService {
-  private creds: Creds;
-
-  constructor(operatorKey: string, agentId: string) {
-    if (!operatorKey) throw new Error('TaskService: operatorKey is required');
-    if (!agentId) throw new Error('TaskService: agentId is required (operator-token impersonation)');
-    this.creds = { operatorKey, agentId };
-  }
-
-  async getTask(taskId: string): Promise<Task> {
-    return getTask(taskId, this.creds);
-  }
-
-  async getActiveTasksForAgent(agentId: string): Promise<Task[]> {
-    return getActiveTasksForAgent(agentId, this.creds);
-  }
-
-  async getActiveTasksForChat(chatId: string): Promise<Task[]> {
-    return getActiveTasksForChat(chatId, this.creds);
-  }
-
-  async getSubtasks(parentTaskId: string): Promise<Task[]> {
-    return getSubtasks(parentTaskId, this.creds);
-  }
-
-  async spawnUnderAgreement(agreementId: string, taskData: { description: string; parentTaskId?: string; plan?: unknown; planReviewTiming?: string; requireMidWorkPlanAck?: boolean; assigneeId?: string; inputArtifactIds?: string[] }): Promise<Task> {
-    if (!agreementId) throw new Error('TaskService.spawnUnderAgreement: agreementId is required');
-    try {
-      const result = await createTask({ ...taskData, agreementId } as Parameters<typeof createTask>[0], this.creds);
-      runtimeLog.info('TaskService', `Task spawned under agreement ${agreementId}: ${result?.taskId || 'unknown'}`);
-      return result;
-    } catch (error) {
-      const e = error as { message?: string; status?: number; body?: string };
-      runtimeLog.error('TaskService', `Task spawn failed (agreement ${agreementId}, assignee ${taskData.assigneeId ?? '-'}): status=${e.status ?? '?'} ${e.message}${e.body ? ` | body=${e.body}` : ''}`);
-      throw error;
-    }
-  }
-
-  async updateState(taskId: string, state: TaskState, result?: unknown): Promise<Task> {
-    try {
-      const data = result !== undefined ? { result: safeJsonStringify(result) } : {};
-      const updated = await updateTaskState(taskId, state, data, this.creds);
-      runtimeLog.info('TaskService', `Task state: ${taskId} → ${state}`);
-      return updated;
-    } catch (error) {
-      runtimeLog.error('TaskService', `Task state update failed: ${(error as Error).message}`);
-      throw error;
-    }
-  }
-
-  async updatePlanStep(taskId: string, stepId: string, status: string, result?: unknown): Promise<Task> {
-    try {
-      const updated = await updateTaskPlanStep(taskId, stepId, status, result, this.creds);
-      runtimeLog.info('TaskService', `Task plan step: ${taskId}/${stepId} → ${status}`);
-      return updated;
-    } catch (error) {
-      runtimeLog.error('TaskService', `Task plan step update failed: ${(error as Error).message}`);
-      throw error;
-    }
-  }
-
-  async cancel(taskId: string): Promise<Task> {
-    try {
-      const updated = await cancelTask(taskId, this.creds);
-      runtimeLog.info('TaskService', `Task cancelled: ${taskId}`);
-      return updated;
-    } catch (error) {
-      runtimeLog.error('TaskService', `Task cancel failed: ${(error as Error).message}`);
-      throw error;
-    }
-  }
-
-  async report(taskId: string, message = ''): Promise<Task> {
-    return reportTask(taskId, message, this.creds);
-  }
-
-  async setSatisfaction(taskId: string, satisfaction: 'positive' | 'negative'): Promise<Task> {
-    return setTaskSatisfaction(taskId, satisfaction, this.creds);
-  }
-
-  async count(filters: CountTasksFilters = {}): Promise<number> {
-    return countTasks(filters, this.creds);
-  }
-}

package/src/server/telemetryIngest.ts

@@ -1,91 +0,0 @@
-import type { LlmResponse } from '../types.js';
-import type { TelemetryClient } from '@ziggs-ai/api-client';
-
-export function isTelemetryIngestEnabled(
-  explicit?: boolean,
-): boolean {
-  if (explicit === false) return false;
-  if (explicit === true) return true;
-  const env = process.env.ZIGGS_TELEMETRY_INGEST;
-  if (env === '0' || env === 'false') return false;
-  return true;
-}
-
-export function usageFromLlmResponse(response: LlmResponse): {
-  tokensTotal: number;
-  tokensInput: number;
-  tokensOutput: number;
-} {
-  const u = response.usage;
-  const tokensInput =
-    Number(u?.prompt_tokens ?? u?.promptTokens ?? 0) || 0;
-  const tokensOutput =
-    Number(u?.completion_tokens ?? u?.completionTokens ?? 0) || 0;
-  const tokensTotal =
-    Number(u?.total_tokens ?? u?.totalTokens ?? 0) ||
-    tokensInput + tokensOutput;
-  return { tokensTotal, tokensInput, tokensOutput };
-}
-
-export function buildLlmIngestPayload(
-  response: LlmResponse,
-  ctx: { sessionId?: string; durationMs: number; runId?: string; stateId?: string },
-): Record<string, unknown> {
-  const { tokensTotal, tokensInput, tokensOutput } =
-    usageFromLlmResponse(response);
-  const chatId = ctx.sessionId ?? null;
-  return {
-    source: 'agent',
-    chatId,
-    sessionId: chatId,
-    execution: {
-      llmCallsTotal: 1,
-      tokensTotal,
-      tokensInput,
-      tokensOutput,
-      ...(tokensTotal > 0 ? { tokensPerLlmCall: [tokensTotal] } : {}),
-    },
-    resource: { durationMs: Math.max(0, Math.round(ctx.durationMs)) },
-    meta: {
-      effect: 'llm-call',
-      ...(ctx.runId ? { runId: ctx.runId } : {}),
-      ...(ctx.stateId ? { stateId: ctx.stateId } : {}),
-    },
-  };
-}
-
-export function buildToolIngestPayload(
-  ctx: {
-    sessionId: string;
-    tool: string;
-    durationMs: number;
-    ok: boolean;
-    runId?: string;
-    stateId?: string;
-  },
-): Record<string, unknown> {
-  return {
-    source: 'agent',
-    chatId: ctx.sessionId,
-    sessionId: ctx.sessionId,
-    execution: { executionLoops: 1 },
-    resource: { durationMs: Math.max(0, Math.round(ctx.durationMs)) },
-    meta: {
-      effect: 'tool-call',
-      tool: ctx.tool,
-      ok: ctx.ok,
-      ...(ctx.runId ? { runId: ctx.runId } : {}),
-      ...(ctx.stateId ? { stateId: ctx.stateId } : {}),
-    },
-  };
-}
-
-/** Fire-and-forget; never throws to the effect handler. */
-export function sendTelemetry(
-  client: TelemetryClient | undefined,
-  payload: Record<string, unknown>,
-  enabled: boolean,
-): void {
-  if (!enabled || !client) return;
-  void client.send(payload).catch(() => {});
-}