@ziggs-ai/agent-sdk 0.1.12 → 0.2.0

package/dist/server/ZiggsEffectHandler.js

@@ -0,0 +1,319 @@
+import { OutboxBuffer } from './OutboxBuffer.js';
+import { runtimeLog } from '../shared/runtimeLog.js';
+import { buildLlmIngestPayload, buildToolIngestPayload, isTelemetryIngestEnabled, sendTelemetry, } from './telemetryIngest.js';
+const CONTEXT_CACHE_MAX = 256;
+/**
+ * Compose a `ContextSnapshot` for a chatId via the grant-fenced aggregate read
+ * (`GET /context/snapshot`, ZIG-775 follow-up). The backend assembles history +
+ * agreements + roster through the same `assertScopeAccess` + temporal fence as
+ * the per-type context reads, and annotates `*IsYou` / self server-side against
+ * the acting agent. This function only preserves the never-throw/degrade
+ * contract that the cognition code depends on — the shape is unchanged.
+ */
+const emptySnapshot = (agentId, chatMissing = false) => ({
+    history: [],
+    agreements: [],
+    users: [],
+    agents: [{ agentId, role: 'self', isYou: true }],
+    latestSequence: null,
+    ...(chatMissing ? { chatMissing: true } : {}),
+});
+async function buildSnapshot(deps, chatId, agentId, opts = {}) {
+    try {
+        // Server returns 200 + chatMissing:true for a deleted chat, so its
+        // annotations (roster, *IsYou, self) are already applied — pass through.
+        const snap = await deps.contextReadClient.snapshot(chatId, {
+            maxMessages: opts.limit,
+        });
+        return snap;
+    }
+    catch (err) {
+        // Defensive: server normally signals a dead chat as 200 + chatMissing, but
+        // a raw 404 degrades the same way so message wakes still skip it.
+        if (err?.status === 404) {
+            return emptySnapshot(agentId, true);
+        }
+        runtimeLog.warn('ZiggsEffectHandler', `snapshot fetch failed: ${err?.message ?? err}`);
+        return emptySnapshot(agentId);
+    }
+}
+const OP_ARTIFACT_MAX_CHARS = 900;
+function clipForOperationArtifact(value) {
+    if (value == null)
+        return value;
+    if (typeof value === 'string') {
+        return value.length > OP_ARTIFACT_MAX_CHARS ? `${value.slice(0, OP_ARTIFACT_MAX_CHARS - 1)}…` : value;
+    }
+    try {
+        const s = JSON.stringify(value);
+        if (s.length <= OP_ARTIFACT_MAX_CHARS)
+            return value;
+        return `${s.slice(0, OP_ARTIFACT_MAX_CHARS - 1)}…`;
+    }
+    catch {
+        return String(value).slice(0, OP_ARTIFACT_MAX_CHARS);
+    }
+}
+function previewToolArgs(args) {
+    const keys = Object.keys(args);
+    if (keys.length === 0)
+        return undefined;
+    const out = {};
+    for (let i = 0; i < keys.length && i < 16; i++) {
+        const k = keys[i];
+        out[k] = clipForOperationArtifact(args[k]);
+    }
+    return out;
+}
+/**
+ * Chat timeline: `Message.tsx` parses `entryType: artifact`, `content_type: operation` with
+ * `operation_*:{json}` where json includes `state` and `tool`.
+ */
+async function emitToolOperationArtifact(client, chatId, phase, payload) {
+    const prefix = phase === 'started' ? 'operation_started' : phase === 'completed' ? 'operation_completed' : 'operation_error';
+    const text = `${prefix}:${JSON.stringify(payload)}`;
+    try {
+        await client.write({
+            chatId,
+            text,
+            content_type: 'operation',
+            visibility: 'agent-private',
+        });
+    }
+    catch (e) {
+        runtimeLog.warn('ZiggsEffectHandler', `tool operation artifact (${phase}): ${e?.message ?? String(e)}`);
+    }
+}
+/**
+ * The single tool-execution path for BOTH cognitions (ZIG-775).
+ *
+ * Executing a tool is more than calling its handler: it emits the operation
+ * timeline artifacts (started / completed / error) and tool telemetry, and
+ * resolves the invoking user + roster. The FSM reaches this via
+ * `eff({ kind: 'tool-call' })` inside `runTurn`; the Claude Agent SDK bridge
+ * (`toolManagerToSdkMcp`) emits the SAME effect — so a hosted Claude-brain
+ * agent's tool activity is as observable as an FSM agent's (needed for
+ * hired-agent visibility, ZIG-535). A caller cannot run a tool and skip these
+ * side effects — that is the whole point of funneling both paths here.
+ *
+ * `eff` is threaded into the tool context so eff-backed tools
+ * (`ziggs_context_snapshot`, `ziggs_send_message`) resolve through this same path
+ * regardless of which cognition invoked them.
+ */
+export async function executeToolWithSideEffects(deps, eff, effect, roster) {
+    const toolT0 = Date.now();
+    const args = effect.args || {};
+    const argsPreview = previewToolArgs(args);
+    await emitToolOperationArtifact(deps.artifactsClient, effect.sessionId, 'started', {
+        state: 'started',
+        tool: effect.name,
+        ...(argsPreview ? { args: argsPreview } : {}),
+    });
+    try {
+        const lastUser = roster.users.find((u) => u.userId || u.id);
+        // Accumulate token usage from any nested LLM call the tool makes (llmTool),
+        // so it can be folded into the turn's authoritative token count (ZIG-813).
+        let nestedUsage;
+        const reportUsage = (u) => {
+            if (!u)
+                return;
+            const p = u.prompt_tokens ?? u.promptTokens ?? 0;
+            const c = u.completion_tokens ?? u.completionTokens ?? 0;
+            const t = u.total_tokens ?? u.totalTokens ?? p + c;
+            nestedUsage = {
+                prompt_tokens: (nestedUsage?.prompt_tokens ?? 0) + p,
+                completion_tokens: (nestedUsage?.completion_tokens ?? 0) + c,
+                total_tokens: (nestedUsage?.total_tokens ?? 0) + t,
+            };
+        };
+        const result = await deps.toolManager.executeTool(effect.name, args, {
+            operatorKey: deps.operatorKey,
+            agentId: deps.agentId,
+            chatId: effect.sessionId,
+            taskService: deps.taskService,
+            agreementService: deps.agreementService,
+            contextReadClient: deps.contextReadClient,
+            sendMessage: deps.messageSender,
+            eff,
+            agents: roster.agents,
+            users: roster.users,
+            senderId: effect.senderId ?? lastUser?.userId ?? lastUser?.id,
+            senderType: effect.senderType ?? (lastUser ? 'USER' : undefined),
+            onBehalfOfAgreementId: effect.onBehalfOfAgreementId,
+            memory: effect.memory,
+            reportUsage,
+            turnScratch: {},
+        });
+        await emitToolOperationArtifact(deps.artifactsClient, effect.sessionId, 'completed', {
+            state: 'completed',
+            tool: effect.name,
+            result: clipForOperationArtifact(result),
+        });
+        sendTelemetry(deps.telemetryClient, buildToolIngestPayload({
+            sessionId: effect.sessionId,
+            tool: effect.name,
+            durationMs: Date.now() - toolT0,
+            ok: true,
+            runId: effect.runId,
+            stateId: effect.stateId,
+        }), isTelemetryIngestEnabled(deps.telemetryIngest));
+        return { ok: true, result, ...(nestedUsage ? { usage: nestedUsage } : {}) };
+    }
+    catch (error) {
+        const errMsg = error?.message ?? String(error);
+        runtimeLog.warn('ZiggsEffectHandler', `tool-call "${effect.name}" failed: ${errMsg}`);
+        await emitToolOperationArtifact(deps.artifactsClient, effect.sessionId, 'error', {
+            state: 'failed',
+            tool: effect.name,
+            error: errMsg,
+        });
+        sendTelemetry(deps.telemetryClient, buildToolIngestPayload({
+            sessionId: effect.sessionId,
+            tool: effect.name,
+            durationMs: Date.now() - toolT0,
+            ok: false,
+            runId: effect.runId,
+            stateId: effect.stateId,
+        }), isTelemetryIngestEnabled(deps.telemetryIngest));
+        return { ok: false, error: errMsg };
+    }
+}
+/**
+ * Build a single shared EffectHandler. The handler is stateful — it caches
+ * the latest ContextSnapshot per sessionId so tool-call effects can resolve
+ * session-coupled deps (the `agents` roster) without forcing the Agent to
+ * pass them through. Cache is bounded with simple LRU eviction (re-set on
+ * read promotes the entry; oldest entry drops when size exceeds the cap).
+ */
+export function createZiggsEffectHandler(deps) {
+    const contextCache = new Map();
+    const outbox = new OutboxBuffer();
+    const cachePut = (sessionId, snap) => {
+        if (contextCache.has(sessionId))
+            contextCache.delete(sessionId);
+        contextCache.set(sessionId, snap);
+        if (contextCache.size > CONTEXT_CACHE_MAX) {
+            const oldest = contextCache.keys().next().value;
+            if (oldest !== undefined)
+                contextCache.delete(oldest);
+        }
+    };
+    const cacheGet = (sessionId) => {
+        const snap = contextCache.get(sessionId);
+        if (snap !== undefined) {
+            contextCache.delete(sessionId);
+            contextCache.set(sessionId, snap);
+        }
+        return snap;
+    };
+    const dispatch = async (effect) => {
+        switch (effect.kind) {
+            case 'read-context': {
+                // Grant-fenced aggregate read: the backend composes the ContextSnapshot
+                // (GET /context/snapshot) through the same access + temporal fence as
+                // the per-type reads. Every producer — ClaudeSdkAgent.tick, runTurn,
+                // and the on-demand ziggs_context_snapshot tool — routes through here.
+                const snap = await buildSnapshot(deps, effect.sessionId, deps.agentId, {
+                    limit: effect.opts?.maxMessages,
+                });
+                const me = snap.agents.find((a) => a?.isYou)?.agentId || null;
+                outbox.merge(effect.sessionId, snap.history, me);
+                cachePut(effect.sessionId, snap);
+                return snap;
+            }
+            case 'llm-call': {
+                if (!deps.llm)
+                    throw new Error('llm-call effect requires an LLM adapter — none configured for this cognition');
+                const t0 = Date.now();
+                const r = await deps.llm.chatMessages(effect.messages, effect.tools);
+                sendTelemetry(deps.telemetryClient, buildLlmIngestPayload(r, {
+                    sessionId: effect.sessionId,
+                    durationMs: Date.now() - t0,
+                    runId: effect.runId,
+                    stateId: effect.stateId,
+                }), isTelemetryIngestEnabled(deps.telemetryIngest));
+                return r;
+            }
+            case 'stream-text': {
+                if (!deps.llm)
+                    throw new Error('stream-text effect requires an LLM adapter — none configured for this cognition');
+                const { sessionId, receiverId, messageId, messages } = effect;
+                let text = '';
+                let usage;
+                if (deps.llm.chatMessagesStream) {
+                    const streamed = await deps.llm.chatMessagesStream(messages, (chunk) => {
+                        // Live-stream display is best-effort. The transport's send rejects
+                        // empty/whitespace-only content (WebSocketClient: content.trim() === ''),
+                        // and a whitespace-only chunk (e.g. a leading newline) is truthy yet
+                        // still throws — which, uncaught, aborts the whole stream and loses the
+                        // entire reply (e.g. a composer's final synthesis). Swallow chunk-send
+                        // failures; `text` accumulates independently and the final send-message
+                        // (below, in runTurn) carries the full reply regardless.
+                        try {
+                            if (chunk && chunk.trim())
+                                deps.chunkSender?.(sessionId, receiverId, chunk, messageId);
+                        }
+                        catch { /* ignore — streaming display only */ }
+                    });
+                    text = streamed.text;
+                    usage = streamed.usage;
+                }
+                else {
+                    const r = await deps.llm.chatMessages(messages);
+                    text = r.content ?? '';
+                    usage = r.usage;
+                    if (text)
+                        deps.chunkSender?.(sessionId, receiverId, text, messageId);
+                }
+                return { text, usage };
+            }
+            case 'tool-call': {
+                // Roster comes from the cached snapshot (populated by read-context). Both
+                // cognitions land here — the FSM via runTurn's executeTool, the Claude
+                // Agent SDK via the toolManagerToSdkMcp bridge — so tool side effects are
+                // emitted exactly once, in one place (ZIG-775).
+                const cached = cacheGet(effect.sessionId);
+                return executeToolWithSideEffects(deps, handler, effect, {
+                    agents: cached?.agents || [],
+                    users: cached?.users || [],
+                });
+            }
+            case 'send-message': {
+                await deps.messageSender(effect.text, effect.receiverId, effect.sessionId, effect.messageId);
+                outbox.track(effect.sessionId, { text: effect.text, receiverId: effect.receiverId });
+                return { ok: true };
+            }
+            case 'record-event': {
+                // Routes through ArtifactsClient as an agent-private artifact —
+                // visible to this agent across turns, not to other chat parties.
+                try {
+                    if (effect.entry.kind === 'thought' && typeof effect.entry.text === 'string') {
+                        await deps.artifactsClient.recordThought(effect.sessionId, effect.entry.text);
+                    }
+                    else {
+                        await deps.artifactsClient.write({
+                            chatId: effect.sessionId,
+                            text: JSON.stringify(effect.entry),
+                            content_type: String(effect.entry.kind ?? 'event'),
+                            visibility: 'agent-private',
+                        });
+                    }
+                }
+                catch (err) {
+                    runtimeLog.warn('ZiggsEffectHandler', `record-event failed: ${err?.message ?? String(err)}`);
+                }
+                return { ok: true };
+            }
+            default: {
+                const exhaustive = effect;
+                throw new Error(`ZiggsEffectHandler: unknown effect kind ${exhaustive.kind}`);
+            }
+        }
+    };
+    const handler = async (effect) => {
+        const response = await dispatch(effect);
+        deps.effectTap?.(effect, response);
+        return response;
+    };
+    return handler;
+}

package/dist/server/agreements/AgreementService.d.ts

@@ -0,0 +1,50 @@
+import { type Agreement, type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput, type PublishOfferPayload, type DelegateAgreementData, type CounterAgreementData, type CreateAgreementBody, type ListAgreementsFilters, type GetMyAgreementsFilters, type ChatLinkType, type ArtifactLinkType, type UserRole } from '@ziggs-ai/api-client';
+export declare class AgreementService {
+    private creds;
+    constructor(operatorKey: string, agentId: string);
+    /** 1:1 proposal. Server defaults engagementKind to `service` when omitted. */
+    proposeDirect(payload: ProposeDirectInput): Promise<Agreement>;
+    /**
+     * Open buyer-broadcast. `payload.audience` selects who may see/claim it:
+     * 'everyone' (default, fully public) or 'org' (members of your active org).
+     * Server defaults engagementKind to `service`.
+     */
+    proposeBroadcast(payload: ProposeBroadcastInput): Promise<Agreement>;
+    /** @deprecated Alias for {@link proposeDirect}. */
+    propose(payload: ProposeAgreementData): Promise<Agreement>;
+    /**
+     * Seller-broadcast marketplace offer. `payload.audience` sets the `payer`
+     * sentinel: 'everyone' (default, public) or 'org' (your active org only).
+     */
+    publishOffer(payload: PublishOfferPayload): Promise<Agreement>;
+    delegate(payload: DelegateAgreementData): Promise<Agreement>;
+    respond(agreementId: string, action: 'approve' | 'reject'): Promise<Agreement>;
+    counter(agreementId: string, counter: CounterAgreementData): Promise<Agreement>;
+    getStatus(agreementId: string): Promise<unknown | null>;
+    list(filters?: ListAgreementsFilters): Promise<Agreement[]>;
+    mine(filters?: GetMyAgreementsFilters): Promise<Agreement[]>;
+    get(agreementId: string): Promise<Agreement | null>;
+    create(body: CreateAgreementBody): Promise<{
+        ok: boolean;
+        agreement: Agreement;
+    }>;
+    revoke(agreementId: string): Promise<{
+        ok: boolean;
+        agreement: Agreement;
+    }>;
+    fulfill(agreementId: string): Promise<{
+        ok: boolean;
+        agreement: Agreement;
+    }>;
+    linkToChat(agreementId: string, chatId: string, linkType?: ChatLinkType): Promise<unknown | null>;
+    getChats(agreementId: string): Promise<unknown[]>;
+    join(agreementId: string): Promise<{
+        chatId: string;
+        agentId: string | null;
+        isNew: boolean;
+    }>;
+    linkArtifact(agreementId: string, artifactId: string, linkType?: ArtifactLinkType): Promise<unknown | null>;
+    getArtifacts(agreementId: string): Promise<unknown[]>;
+    linkUser(agreementId: string, userId: string, role: UserRole): Promise<unknown | null>;
+    getUsers(agreementId: string): Promise<unknown[]>;
+}

package/dist/server/agreements/AgreementService.js

@@ -0,0 +1,85 @@
+import { proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement, getAgreementStatus, listAgreements, getMyAgreements, getAgreement, publishOffer as publishOfferApi, createAgreement, revokeAgreement, fulfillAgreement, linkAgreementToChat, getChatsForAgreement, joinAgreement, linkArtifactToAgreement, getArtifactsForAgreement, linkUserToAgreement, getUsersForAgreement, } from '@ziggs-ai/api-client';
+export class AgreementService {
+    creds;
+    constructor(operatorKey, agentId) {
+        if (!operatorKey)
+            throw new Error('AgreementService: operatorKey is required');
+        if (!agentId)
+            throw new Error('AgreementService: agentId is required (operator-token impersonation)');
+        this.creds = { operatorKey, agentId };
+    }
+    /** 1:1 proposal. Server defaults engagementKind to `service` when omitted. */
+    proposeDirect(payload) {
+        return proposeAgreement(payload, this.creds);
+    }
+    /**
+     * Open buyer-broadcast. `payload.audience` selects who may see/claim it:
+     * 'everyone' (default, fully public) or 'org' (members of your active org).
+     * Server defaults engagementKind to `service`.
+     */
+    proposeBroadcast(payload) {
+        return proposeBroadcastApi(payload, this.creds);
+    }
+    /** @deprecated Alias for {@link proposeDirect}. */
+    propose(payload) {
+        return proposeAgreement(payload, this.creds);
+    }
+    /**
+     * Seller-broadcast marketplace offer. `payload.audience` sets the `payer`
+     * sentinel: 'everyone' (default, public) or 'org' (your active org only).
+     */
+    publishOffer(payload) {
+        return publishOfferApi(payload, this.creds);
+    }
+    delegate(payload) {
+        return delegateAgreement(payload, this.creds);
+    }
+    respond(agreementId, action) {
+        return respondToAgreement(agreementId, action, this.creds);
+    }
+    counter(agreementId, counter) {
+        return counterAgreement(agreementId, counter || {}, this.creds);
+    }
+    getStatus(agreementId) {
+        return getAgreementStatus(agreementId, this.creds);
+    }
+    list(filters = {}) {
+        return listAgreements(filters, this.creds);
+    }
+    mine(filters = {}) {
+        return getMyAgreements(filters, this.creds);
+    }
+    get(agreementId) {
+        return getAgreement(agreementId, this.creds);
+    }
+    create(body) {
+        return createAgreement(body, this.creds);
+    }
+    revoke(agreementId) {
+        return revokeAgreement(agreementId, this.creds);
+    }
+    fulfill(agreementId) {
+        return fulfillAgreement(agreementId, this.creds);
+    }
+    linkToChat(agreementId, chatId, linkType = 'mention') {
+        return linkAgreementToChat(agreementId, chatId, linkType, this.creds);
+    }
+    getChats(agreementId) {
+        return getChatsForAgreement(agreementId, this.creds);
+    }
+    join(agreementId) {
+        return joinAgreement(agreementId, this.creds);
+    }
+    linkArtifact(agreementId, artifactId, linkType = 'produced') {
+        return linkArtifactToAgreement(agreementId, artifactId, linkType, this.creds);
+    }
+    getArtifacts(agreementId) {
+        return getArtifactsForAgreement(agreementId, this.creds);
+    }
+    linkUser(agreementId, userId, role) {
+        return linkUserToAgreement(agreementId, userId, role, this.creds);
+    }
+    getUsers(agreementId) {
+        return getUsersForAgreement(agreementId, this.creds);
+    }
+}

package/dist/server/createHealthServer.d.ts

@@ -0,0 +1,7 @@
+import { type Server } from 'http';
+import type { ConnectionPool } from './ConnectionPool.js';
+export declare function createHealthServer({ port, label, pool, }?: {
+    port?: number;
+    label?: string;
+    pool?: ConnectionPool;
+}): Server;

package/dist/server/createHealthServer.js

@@ -0,0 +1,75 @@
+import { createServer } from 'http';
+import { runtimeLog } from '../shared/runtimeLog.js';
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => {
+            try {
+                const raw = Buffer.concat(chunks).toString('utf8');
+                resolve(raw ? JSON.parse(raw) : {});
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+export function createHealthServer({ port = Number(process.env.PORT) || 8080, label = 'agents', pool, } = {}) {
+    const server = createServer(async (req, res) => {
+        const url = req.url ?? '/';
+        const wakeMatch = url.match(/^\/fleet-wake\/([^/?]+)/);
+        if (req.method === 'POST' && wakeMatch && pool) {
+            const agentId = decodeURIComponent(wakeMatch[1]);
+            try {
+                await pool.wake(agentId);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, agentId, active: pool.listActive().includes(agentId) }));
+            }
+            catch (err) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: err.message }));
+            }
+            return;
+        }
+        if (req.method === 'POST' && url === '/fleet-deliver' && pool) {
+            try {
+                const body = await readJsonBody(req);
+                const agentId = String(body.agentId ?? '');
+                const chatId = String(body.chatId ?? '');
+                const text = String(body.text ?? '');
+                const senderId = String(body.senderId ?? '');
+                if (!agentId || !chatId || !text || !senderId) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'agentId, chatId, text, senderId required' }));
+                    return;
+                }
+                const host = (await pool.wake(agentId));
+                await host.handleMessage(text, {
+                    chatId,
+                    entryType: 'message',
+                    content_type: 'text',
+                    sender: { id: senderId, type: 'USER' },
+                    receiver: { id: agentId, type: 'AGENT' },
+                });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, agentId }));
+            }
+            catch (err) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: err.message }));
+            }
+            return;
+        }
+        if (url === '/health' || url === '/') {
+            res.writeHead(200);
+            res.end('ok');
+            return;
+        }
+        res.writeHead(404);
+        res.end();
+    });
+    server.listen(port, () => runtimeLog.info(label, `health server on port ${port}`));
+    return server;
+}

package/dist/server/proactive/ProactiveTrigger.d.ts

@@ -0,0 +1,33 @@
+import { type Creds } from '@ziggs-ai/api-client';
+import type { PublishOfferPayload, PullOffersOptions } from '@ziggs-ai/api-client';
+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 declare class ProactiveTrigger {
+    private interval;
+    private creds;
+    private onTick;
+    private onError;
+    private runImmediately;
+    private _running;
+    private _timer;
+    constructor({ interval, creds, onTick, onError, runImmediately }: ProactiveTriggerOptions);
+    start(): void;
+    stop(): void;
+    private _schedule;
+    private _tick;
+    private _buildContext;
+}
+export {};

package/dist/server/proactive/ProactiveTrigger.js

@@ -0,0 +1,71 @@
+import { publishOffer, pullOffers, claimOffer } from '@ziggs-ai/api-client';
+import { runtimeLog } from '../../shared/runtimeLog.js';
+export class ProactiveTrigger {
+    interval;
+    creds;
+    onTick;
+    onError;
+    runImmediately;
+    _running;
+    _timer;
+    constructor({ interval, creds, onTick, onError, runImmediately = false }) {
+        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() {
+        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() {
+        this._running = false;
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        runtimeLog.debug('ProactiveTrigger', `stopped (agentId=${this.creds.agentId})`);
+    }
+    _schedule() {
+        if (!this._running)
+            return;
+        this._timer = setTimeout(() => this._tick(), this.interval);
+    }
+    async _tick() {
+        if (!this._running)
+            return;
+        try {
+            await this.onTick(this._buildContext());
+        }
+        catch (err) {
+            this.onError(err);
+        }
+        this._schedule();
+    }
+    _buildContext() {
+        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/dist/server/runLauncher.d.ts

@@ -0,0 +1,28 @@
+import { ConnectionPool } from './ConnectionPool.js';
+import { type AgentHostOptions } from '../AgentHost.js';
+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 declare function runLauncher(configOrConfigs: AgentConfig | AgentConfig[], opts?: FleetOptions): Promise<unknown>;
+export {};