@onesi/genesis 0.1.13 → 0.2.0

package/dist/traces.d.ts

@@ -0,0 +1,574 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Traces: research runs, sources, monitors, crawl, extract, verify and usage.
+ * Billable calls (runs.create, search, crawl, batchScrape, extract, scrape, map) need one stable
+ * idempotency key; reuse it to replay instead of running and metering twice. runs.create and search
+ * send the key as given (the service enforces its 8-256 character rule); the newer calls refuse a
+ * missing or malformed key before sending. */
+export declare function tracesModule(client: GenesisClient): {
+    runs: {
+        create: (body: In<"traces_createRun">["body"], idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        list: (q?: In<"traces_listRuns">) => Promise<{
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        evidence: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        steps: (id: string) => Promise<{
+            steps?: {
+                [key: string]: unknown;
+            }[];
+            total?: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        /** Server-Sent Events, read to the end as text (the stream ends at `timeout`, default 30 s, max 300 s). */
+        stream: (id: string, q?: Omit<In<"traces_streamRun">, "id">) => Promise<unknown>;
+        cancel: (id: string) => Promise<{
+            status?: "cancelled";
+        } & {
+            [key: string]: unknown;
+        }>;
+        pause: (id: string) => Promise<{
+            status?: "paused";
+        } & {
+            [key: string]: unknown;
+        }>;
+        resume: (id: string) => Promise<{
+            status?: "running";
+        } & {
+            [key: string]: unknown;
+        }>;
+        retry: (id: string) => Promise<{
+            status?: string;
+            retry_count?: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    search: (body: In<"traces_search">["body"], idempotencyKey: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    sources: {
+        list: (q?: In<"traces_listSources">) => Promise<{
+            items: import("./index.js").components["schemas"]["Traces.Source"][];
+            total: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            id: string;
+            url: string;
+            source_type: "documentation" | "academic_paper" | "code_repository" | "encyclopedia" | "standard" | "web" | "dataset" | "news_feed" | "api_reference";
+            title?: string;
+            domain?: string;
+            discovered_at?: string;
+            last_fetched_at?: string;
+            last_checked_at?: string;
+            content_hash?: string;
+            status: "discovered" | "fetched" | "processing" | "processed" | "error" | "unavailable";
+            fetch_count?: number;
+            error_message?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at?: string;
+            updated_at?: string;
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"traces_createSource">["body"]) => Promise<{
+            id: string;
+            url: string;
+            source_type: "documentation" | "academic_paper" | "code_repository" | "encyclopedia" | "standard" | "web" | "dataset" | "news_feed" | "api_reference";
+            title?: string;
+            domain?: string;
+            discovered_at?: string;
+            last_fetched_at?: string;
+            last_checked_at?: string;
+            content_hash?: string;
+            status: "discovered" | "fetched" | "processing" | "processed" | "error" | "unavailable";
+            fetch_count?: number;
+            error_message?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at?: string;
+            updated_at?: string;
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        update: (id: string, body: In<"traces_updateSource">["body"]) => Promise<{
+            id: string;
+            url: string;
+            source_type: "documentation" | "academic_paper" | "code_repository" | "encyclopedia" | "standard" | "web" | "dataset" | "news_feed" | "api_reference";
+            title?: string;
+            domain?: string;
+            discovered_at?: string;
+            last_fetched_at?: string;
+            last_checked_at?: string;
+            content_hash?: string;
+            status: "discovered" | "fetched" | "processing" | "processed" | "error" | "unavailable";
+            fetch_count?: number;
+            error_message?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at?: string;
+            updated_at?: string;
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        delete: (id: string) => Promise<{
+            status: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        check: (id: string) => Promise<{
+            id?: string;
+            source_id?: string;
+            checked_at?: string;
+            content_changed?: boolean;
+            previous_hash?: string;
+            current_hash?: string;
+            response_code?: number;
+            check_method?: string;
+            next_check_at?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        health: (id: string) => Promise<{
+            source_id: string;
+            status: string;
+            fetch_count?: number;
+            last_fetched_at?: string;
+            last_checked_at?: string;
+            content_hash?: string;
+            content_type?: string;
+            etag?: string;
+            last_modified?: string;
+            response_code?: number;
+            error_message?: string;
+            staleness_hours?: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    monitors: {
+        list: (q?: In<"traces_listMonitors">) => Promise<{
+            items: import("./index.js").components["schemas"]["Traces.Monitor"][];
+            total: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            id: string;
+            tenant_id?: string;
+            name: string;
+            description?: string;
+            source_id?: string;
+            query?: string;
+            condition?: {
+                [key: string]: unknown;
+            };
+            check_interval_seconds?: number;
+            status: "active" | "paused" | "triggered" | "error";
+            last_checked_at?: string;
+            last_triggered_at?: string;
+            webhook_url?: string;
+            created_at?: string;
+            updated_at?: string;
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"traces_createMonitor">["body"]) => Promise<{
+            id: string;
+            tenant_id?: string;
+            name: string;
+            description?: string;
+            source_id?: string;
+            query?: string;
+            condition?: {
+                [key: string]: unknown;
+            };
+            check_interval_seconds?: number;
+            status: "active" | "paused" | "triggered" | "error";
+            last_checked_at?: string;
+            last_triggered_at?: string;
+            webhook_url?: string;
+            created_at?: string;
+            updated_at?: string;
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        update: (id: string, body: In<"traces_updateMonitor">["body"]) => Promise<{
+            id: string;
+            tenant_id?: string;
+            name: string;
+            description?: string;
+            source_id?: string;
+            query?: string;
+            condition?: {
+                [key: string]: unknown;
+            };
+            check_interval_seconds?: number;
+            status: "active" | "paused" | "triggered" | "error";
+            last_checked_at?: string;
+            last_triggered_at?: string;
+            webhook_url?: string;
+            created_at?: string;
+            updated_at?: string;
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        delete: (id: string) => Promise<{
+            status: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        check: (id: string) => Promise<{
+            status?: "checked" | "triggered" | "error";
+            monitor?: import("./index.js").components["schemas"]["Traces.Monitor"];
+            last_checked_at?: string;
+            triggered?: boolean;
+            alert?: import("./index.js").components["schemas"]["Traces.MonitorAlert"];
+            error?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        alerts: (id: string, q?: Omit<In<"traces_listMonitorAlerts">, "id">) => Promise<{
+            items: import("./index.js").components["schemas"]["Traces.MonitorAlert"][];
+            total: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        acknowledgeAlert: (id: string, alertId: string) => Promise<{
+            id: string;
+            monitor_id: string;
+            run_id?: string;
+            alert_type?: string;
+            details?: {
+                [key: string]: unknown;
+            };
+            acknowledged?: boolean;
+            acknowledged_at?: string;
+            created_at?: string;
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    crawl: {
+        create: (body: In<"traces_createCrawl">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            id: string;
+            status: "queued" | "running" | "paused" | "completed" | "failed" | "cancelled";
+            type?: string;
+            created_at?: string;
+            updated_at?: string;
+            run?: {
+                [key: string]: unknown;
+            };
+            links?: {
+                [key: string]: unknown;
+            };
+            url?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        cancel: (id: string) => Promise<{
+            id: string;
+            status: "queued" | "running" | "paused" | "completed" | "failed" | "cancelled";
+            type?: string;
+            created_at?: string;
+            updated_at?: string;
+            run?: {
+                [key: string]: unknown;
+            };
+            links?: {
+                [key: string]: unknown;
+            };
+            url?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    batchScrape: {
+        create: (body: In<"traces_createBatchScrape">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            id: string;
+            status: "queued" | "running" | "paused" | "completed" | "failed" | "cancelled";
+            type?: string;
+            created_at?: string;
+            updated_at?: string;
+            run?: {
+                [key: string]: unknown;
+            };
+            links?: {
+                [key: string]: unknown;
+            };
+            total?: number;
+            urls?: string[];
+        } & {
+            [key: string]: unknown;
+        }>;
+        cancel: (id: string) => Promise<{
+            id: string;
+            status: "queued" | "running" | "paused" | "completed" | "failed" | "cancelled";
+            type?: string;
+            created_at?: string;
+            updated_at?: string;
+            run?: {
+                [key: string]: unknown;
+            };
+            links?: {
+                [key: string]: unknown;
+            };
+            total?: number;
+            urls?: string[];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    extract: (body: In<"traces_extract">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    extractStructured: (body: In<"traces_extractStructured">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    scrape: (body: In<"traces_scrape">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    map: (body: In<"traces_map">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    evidence: {
+        list: (q?: In<"traces_listEvidence">) => Promise<{
+            items: {
+                [key: string]: unknown;
+            }[];
+            total: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    /** Binary body; the generic client reads non-JSON as text, so fetch the bytes with your own HTTP client when you need them intact. */
+    artifacts: {
+        get: (id: string) => Promise<unknown>;
+    };
+    ingest: {
+        create: (body: In<"traces_ingestEvidence">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        status: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        evaluate: (body: In<"traces_evaluateIngestFallback">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    verify: (body: In<"traces_verifyClaim">["body"]) => Promise<{
+        [key: string]: unknown;
+    }>;
+    /** Agent spans exported by platform services (Henry first). `list` returns recent traces, or with
+     * `trace_id` that trace's spans; `get` reads every span of one trace (32 lowercase hex). */
+    spans: {
+        list: (q?: In<"traces_listSpans">) => Promise<({
+            trace_id: string;
+            spans: import("./index.js").components["schemas"]["Traces.Span"][];
+        } & {
+            [key: string]: unknown;
+        }) | ({
+            traces: import("./index.js").components["schemas"]["Traces.TraceSummary"][];
+            next_page_token: string | null;
+        } & {
+            [key: string]: unknown;
+        })>;
+        get: (traceId: string) => Promise<({
+            trace_id: string;
+            spans: import("./index.js").components["schemas"]["Traces.Span"][];
+        } & {
+            [key: string]: unknown;
+        }) | ({
+            traces: import("./index.js").components["schemas"]["Traces.TraceSummary"][];
+            next_page_token: string | null;
+        } & {
+            [key: string]: unknown;
+        })>;
+    };
+    verdicts: {
+        list: (q?: In<"traces_listVerdicts">) => Promise<{
+            items: {
+                [key: string]: unknown;
+            }[];
+            total: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    coding: {
+        resolve: (body: In<"traces_resolveLibrary">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        docs: (body: In<"traces_getLibraryDocs">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    usage: {
+        events: (q?: In<"traces_listUsageEvents">) => Promise<{
+            [key: string]: unknown;
+        }>;
+        summary: (q?: In<"traces_getUsageSummary">) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    health: () => Promise<{
+        [key: string]: unknown;
+    }>;
+    /** Native Traces API keys (not Genesis API keys). The secret is returned once, on create and rotate. */
+    apiKeys: {
+        list: (q?: In<"traces_listApiKeys">) => Promise<{
+            items: import("./index.js").components["schemas"]["Traces.ApiKey"][];
+            total: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (id: string) => Promise<{
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+            id: string;
+            name: string;
+            key_prefix?: string;
+            principal_id?: string;
+            principal_kind?: "human" | "agent" | "service";
+            entitlements?: ("traces:read" | "traces:write" | "traces:delete" | "traces:admin" | "traces:export")[];
+            last_used_at?: string;
+            expires_at?: string;
+            revoked_at?: string;
+            created_at?: string;
+            updated_at?: string;
+            secret?: string;
+            status?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"traces_createApiKey">["body"]) => Promise<{
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+            id: string;
+            name: string;
+            key_prefix?: string;
+            principal_id?: string;
+            principal_kind?: "human" | "agent" | "service";
+            entitlements?: ("traces:read" | "traces:write" | "traces:delete" | "traces:admin" | "traces:export")[];
+            last_used_at?: string;
+            expires_at?: string;
+            revoked_at?: string;
+            created_at?: string;
+            updated_at?: string;
+            secret?: string;
+            status?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        rotate: (id: string) => Promise<{
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+            id: string;
+            name: string;
+            key_prefix?: string;
+            principal_id?: string;
+            principal_kind?: "human" | "agent" | "service";
+            entitlements?: ("traces:read" | "traces:write" | "traces:delete" | "traces:admin" | "traces:export")[];
+            last_used_at?: string;
+            expires_at?: string;
+            revoked_at?: string;
+            created_at?: string;
+            updated_at?: string;
+            secret?: string;
+            status?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        revoke: (id: string) => Promise<{
+            platform_id?: string;
+            org_id?: string;
+            workspace_id?: string;
+            project_id?: string;
+            environment_id?: string;
+            id: string;
+            name: string;
+            key_prefix?: string;
+            principal_id?: string;
+            principal_kind?: "human" | "agent" | "service";
+            entitlements?: ("traces:read" | "traces:write" | "traces:delete" | "traces:admin" | "traces:export")[];
+            last_used_at?: string;
+            expires_at?: string;
+            revoked_at?: string;
+            created_at?: string;
+            updated_at?: string;
+            secret?: string;
+            status?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+};

package/dist/traces.js

@@ -0,0 +1,97 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Traces: research runs, sources, monitors, crawl, extract, verify and usage.
+ * Billable calls (runs.create, search, crawl, batchScrape, extract, scrape, map) need one stable
+ * idempotency key; reuse it to replay instead of running and metering twice. runs.create and search
+ * send the key as given (the service enforces its 8-256 character rule); the newer calls refuse a
+ * missing or malformed key before sending. */
+export function tracesModule(client) {
+    const keyed = async (id, input, idempotencyKey) => client.request(id, input, { headers: idempotencyHeaders(id, idempotencyKey) });
+    return {
+        runs: {
+            create: (body, idempotencyKey) => client.request('traces_createRun', { body }, { headers: { 'idempotency-key': idempotencyKey } }),
+            list: (q = {}) => client.request('traces_listRuns', q),
+            get: (id) => client.request('traces_getRun', { id }),
+            evidence: (id) => client.request('traces_getRunEvidence', { id }),
+            steps: (id) => client.request('traces_getRunSteps', { id }),
+            /** Server-Sent Events, read to the end as text (the stream ends at `timeout`, default 30 s, max 300 s). */
+            stream: (id, q = {}) => client.request('traces_streamRun', { id, ...q }),
+            cancel: (id) => client.request('traces_cancelRun', { id }),
+            pause: (id) => client.request('traces_pauseRun', { id }),
+            resume: (id) => client.request('traces_resumeRun', { id }),
+            retry: (id) => client.request('traces_retryRun', { id }),
+        },
+        search: (body, idempotencyKey) => client.request('traces_search', { body }, { headers: { 'idempotency-key': idempotencyKey } }),
+        sources: {
+            list: (q = {}) => client.request('traces_listSources', q),
+            get: (id) => client.request('traces_getSource', { id }),
+            create: (body) => client.request('traces_createSource', { body }),
+            update: (id, body) => client.request('traces_updateSource', { id, body }),
+            delete: (id) => client.request('traces_deleteSource', { id }),
+            check: (id) => client.request('traces_checkSource', { id }),
+            health: (id) => client.request('traces_getSourceHealth', { id }),
+        },
+        monitors: {
+            list: (q = {}) => client.request('traces_listMonitors', q),
+            get: (id) => client.request('traces_getMonitor', { id }),
+            create: (body) => client.request('traces_createMonitor', { body }),
+            update: (id, body) => client.request('traces_updateMonitor', { id, body }),
+            delete: (id) => client.request('traces_deleteMonitor', { id }),
+            check: (id) => client.request('traces_checkMonitor', { id }),
+            alerts: (id, q = {}) => client.request('traces_listMonitorAlerts', { id, ...q }),
+            acknowledgeAlert: (id, alertId) => client.request('traces_acknowledgeMonitorAlert', { id, alert_id: alertId }),
+        },
+        crawl: {
+            create: (body, key) => keyed('traces_createCrawl', { body }, key),
+            get: (id) => client.request('traces_getCrawl', { id }),
+            cancel: (id) => client.request('traces_cancelCrawl', { id }),
+        },
+        batchScrape: {
+            create: (body, key) => keyed('traces_createBatchScrape', { body }, key),
+            get: (id) => client.request('traces_getBatchScrape', { id }),
+            cancel: (id) => client.request('traces_cancelBatchScrape', { id }),
+        },
+        extract: (body, key) => keyed('traces_extract', { body }, key),
+        extractStructured: (body, key) => keyed('traces_extractStructured', { body }, key),
+        scrape: (body, key) => keyed('traces_scrape', { body }, key),
+        map: (body, key) => keyed('traces_map', { body }, key),
+        evidence: {
+            list: (q = {}) => client.request('traces_listEvidence', q),
+            get: (id) => client.request('traces_getEvidence', { id }),
+        },
+        /** Binary body; the generic client reads non-JSON as text, so fetch the bytes with your own HTTP client when you need them intact. */
+        artifacts: { get: (id) => client.request('traces_getArtifact', { id }) },
+        ingest: {
+            create: (body) => client.request('traces_ingestEvidence', { body }),
+            status: (id) => client.request('traces_getIngestStatus', { id }),
+            evaluate: (body) => client.request('traces_evaluateIngestFallback', { body }),
+        },
+        verify: (body) => client.request('traces_verifyClaim', { body }),
+        /** Agent spans exported by platform services (Henry first). `list` returns recent traces, or with
+         * `trace_id` that trace's spans; `get` reads every span of one trace (32 lowercase hex). */
+        spans: {
+            list: (q = {}) => client.request('traces_listSpans', q),
+            get: (traceId) => client.request('traces_listSpans', { trace_id: traceId }),
+        },
+        verdicts: {
+            list: (q = {}) => client.request('traces_listVerdicts', q),
+            get: (id) => client.request('traces_getVerdict', { id }),
+        },
+        coding: {
+            resolve: (body) => client.request('traces_resolveLibrary', { body }),
+            docs: (body) => client.request('traces_getLibraryDocs', { body }),
+        },
+        usage: {
+            events: (q = {}) => client.request('traces_listUsageEvents', q),
+            summary: (q = {}) => client.request('traces_getUsageSummary', q),
+        },
+        health: () => client.request('traces_getHealth'),
+        /** Native Traces API keys (not Genesis API keys). The secret is returned once, on create and rotate. */
+        apiKeys: {
+            list: (q = {}) => client.request('traces_listApiKeys', q),
+            get: (id) => client.request('traces_getApiKey', { id }),
+            create: (body) => client.request('traces_createApiKey', { body }),
+            rotate: (id) => client.request('traces_rotateApiKey', { id }),
+            revoke: (id) => client.request('traces_revokeApiKey', { id }),
+        },
+    };
+}