@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/scopes.js

@@ -0,0 +1,40 @@
+import { ifMatchHeaders } from './idempotency.js';
+const page = (p) => ({ ...(p.after === undefined ? {} : { after: p.after }), ...(p.limit === undefined ? {} : { limit: p.limit }) });
+/** Scopes (work graph): projects, tasks, dependencies, assignments to agents or people, comments and activity.
+ * Scopes never runs agents; the assignee's runtime (Henry, Fleets or Flocks) does. Updates, archives and assignee
+ * changes take the `version` you read (sent as If-Match); a stale one is a 409. Archiving needs scopes:admin. */
+export function scopesModule(client) {
+    return {
+        whoami: () => client.request('scopes_whoami'),
+        workload: (projectId) => client.request('scopes_getWorkload', projectId === undefined ? {} : { project_id: projectId }),
+        projects: {
+            list: (filter = {}) => client.request('scopes_listProjects', filter),
+            get: (project) => client.request('scopes_getProject', { project }),
+            create: (body) => client.request('scopes_createProject', { body }),
+            update: (project, version, body) => client.request('scopes_updateProject', { project, body }, { headers: ifMatchHeaders('scopes_updateProject', version) }),
+            archive: (project, version) => client.request('scopes_archiveProject', { project }, { headers: ifMatchHeaders('scopes_archiveProject', version) }),
+            graph: (project) => client.request('scopes_getGraph', { project }),
+            ready: (project, unassigned) => client.request('scopes_listReady', unassigned === undefined ? { project } : { project, unassigned }),
+            tasks: (project, filter = {}) => client.request('scopes_listProjectTasks', { ...filter, project }),
+            createTask: (project, body) => client.request('scopes_createTask', { project, body }),
+            activity: (project, p = {}) => client.request('scopes_getProjectActivity', { project, ...page(p) }),
+        },
+        tasks: {
+            list: (filter = {}) => client.request('scopes_listTasks', filter),
+            get: (task) => client.request('scopes_getTask', { task }),
+            update: (task, version, body) => client.request('scopes_updateTask', { task, body }, { headers: ifMatchHeaders('scopes_updateTask', version) }),
+            archive: (task, version) => client.request('scopes_archiveTask', { task }, { headers: ifMatchHeaders('scopes_archiveTask', version) }),
+            assign: (task, version, body) => client.request('scopes_assignTask', { task, body }, { headers: ifMatchHeaders('scopes_assignTask', version) }),
+            unassign: (task, version) => client.request('scopes_unassignTask', { task }, { headers: ifMatchHeaders('scopes_unassignTask', version) }),
+            assignments: (task) => client.request('scopes_listAssignments', { task }),
+            dependencies: (task) => client.request('scopes_listDependencies', { task }),
+            addDependency: (task, body) => client.request('scopes_addDependency', { task, body }),
+            comments: (task) => client.request('scopes_listComments', { task }),
+            addComment: (task, body) => client.request('scopes_addComment', { task, body }),
+            activity: (task, p = {}) => client.request('scopes_getTaskActivity', { task, ...page(p) }),
+        },
+        dependencies: {
+            remove: (dependency) => client.request('scopes_removeDependency', { dependency }),
+        },
+    };
+}

package/dist/taps.d.ts

@@ -0,0 +1,118 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Taps: ask a human to approve, choose or answer, and read or manage what follows.
+ * An org API key may raise, read, cancel and manage taps; responding and agent lineage
+ * requests need a `genesis login` human session. GET needs taps:read, the rest taps:write.
+ * A repeated create with the same body `idempotency_key` returns the original tap. */
+export declare function tapsModule(client: GenesisClient): {
+    create: (body: In<"taps_createTap">["body"]) => Promise<{
+        tap: import("./index.js").components["schemas"]["Taps.Tap"];
+    }>;
+    list: (q?: In<"taps_listTaps">) => Promise<{
+        taps: import("./index.js").components["schemas"]["Taps.Tap"][];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    get: (id: string) => Promise<{
+        tap: import("./index.js").components["schemas"]["Taps.Tap"];
+    }>;
+    cancel: (id: string) => Promise<void>;
+    /** Human only: an org API key gets 403 human_required. */
+    respond: (id: string, body: In<"taps_respondToTap">["body"]) => Promise<{
+        response: import("./index.js").components["schemas"]["Taps.TapResponse"];
+        tap: import("./index.js").components["schemas"]["Taps.Tap"];
+    }>;
+    events: (id: string) => Promise<{
+        events: import("./index.js").components["schemas"]["Taps.TapEvent"][];
+    }>;
+    routingRules: {
+        list: () => Promise<{
+            rules: import("./index.js").components["schemas"]["Taps.RoutingRule"][];
+        }>;
+        create: (body: In<"taps_createRoutingRule">["body"]) => Promise<{
+            rule: import("./index.js").components["schemas"]["Taps.RoutingRule"];
+        }>;
+        setEnabled: (id: string, enabled: boolean) => Promise<{
+            rule: import("./index.js").components["schemas"]["Taps.RoutingRule"];
+        }>;
+        delete: (id: string) => Promise<void>;
+    };
+    escalationPolicies: {
+        list: () => Promise<{
+            policies: import("./index.js").components["schemas"]["Taps.EscalationPolicyRecord"][];
+        }>;
+        create: (body: In<"taps_createEscalationPolicy">["body"]) => Promise<{
+            policy: import("./index.js").components["schemas"]["Taps.EscalationPolicyRecord"];
+        }>;
+        update: (id: string, body: In<"taps_updateEscalationPolicy">["body"]) => Promise<{
+            policy: import("./index.js").components["schemas"]["Taps.EscalationPolicyRecord"];
+        }>;
+        delete: (id: string) => Promise<void>;
+    };
+    settings: {
+        get: () => Promise<{
+            settings: import("./index.js").components["schemas"]["Taps.Settings"];
+        }>;
+        update: (body: In<"taps_updateSettings">["body"]) => Promise<{
+            settings: import("./index.js").components["schemas"]["Taps.Settings"];
+        }>;
+    };
+    garden: {
+        get: () => Promise<{
+            connected: boolean;
+            mode: string;
+            requires_separate_login: boolean;
+            organization_id: string;
+            principal_id: string;
+            principal_kind: string;
+            platform_id: string;
+            taps_base_url: string;
+            hitl_available: boolean;
+            agent_lineage_available: boolean;
+            billing_metered_by_garden: boolean;
+            keystone_authority: boolean;
+            sigil_lineage_required_for_agents: boolean;
+            hitl_surfaces: string[];
+            next_steps: string[];
+        }>;
+        enable: () => Promise<{
+            connected: boolean;
+            mode: string;
+            requires_separate_login: boolean;
+            organization_id: string;
+            principal_id: string;
+            principal_kind: string;
+            platform_id: string;
+            taps_base_url: string;
+            hitl_available: boolean;
+            agent_lineage_available: boolean;
+            billing_metered_by_garden: boolean;
+            keystone_authority: boolean;
+            sigil_lineage_required_for_agents: boolean;
+            hitl_surfaces: string[];
+            next_steps: string[];
+        }>;
+    };
+    lineage: {
+        /** Human only. */
+        challenge: (body: In<"taps_createAgentLineageChallenge">["body"]) => Promise<{
+            challenge: import("./index.js").components["schemas"]["Taps.AgentChallenge"];
+        }>;
+        requests: {
+            /** Human only. */
+            create: (body: In<"taps_createAgentLineageRequest">["body"]) => Promise<{
+                request: import("./index.js").components["schemas"]["Taps.AgentLineageRequest"];
+                tap: import("./index.js").components["schemas"]["Taps.Tap"];
+            }>;
+            list: (q?: In<"taps_listAgentLineageRequests">) => Promise<{
+                requests: import("./index.js").components["schemas"]["Taps.AgentLineageRequest"][];
+                limit: number;
+                offset: number;
+            }>;
+            get: (id: string) => Promise<{
+                request: import("./index.js").components["schemas"]["Taps.AgentLineageRequest"];
+            }>;
+        };
+    };
+};

package/dist/taps.js

@@ -0,0 +1,45 @@
+/** Taps: ask a human to approve, choose or answer, and read or manage what follows.
+ * An org API key may raise, read, cancel and manage taps; responding and agent lineage
+ * requests need a `genesis login` human session. GET needs taps:read, the rest taps:write.
+ * A repeated create with the same body `idempotency_key` returns the original tap. */
+export function tapsModule(client) {
+    return {
+        create: (body) => client.request('taps_createTap', { body }),
+        list: (q = {}) => client.request('taps_listTaps', q),
+        get: (id) => client.request('taps_getTap', { id }),
+        cancel: (id) => client.request('taps_cancelTap', { id }),
+        /** Human only: an org API key gets 403 human_required. */
+        respond: (id, body) => client.request('taps_respondToTap', { id, body }),
+        events: (id) => client.request('taps_listTapEvents', { id }),
+        routingRules: {
+            list: () => client.request('taps_listRoutingRules'),
+            create: (body) => client.request('taps_createRoutingRule', { body }),
+            setEnabled: (id, enabled) => client.request('taps_updateRoutingRule', { id, body: { enabled } }),
+            delete: (id) => client.request('taps_deleteRoutingRule', { id }),
+        },
+        escalationPolicies: {
+            list: () => client.request('taps_listEscalationPolicies'),
+            create: (body) => client.request('taps_createEscalationPolicy', { body }),
+            update: (id, body) => client.request('taps_updateEscalationPolicy', { id, body }),
+            delete: (id) => client.request('taps_deleteEscalationPolicy', { id }),
+        },
+        settings: {
+            get: () => client.request('taps_getSettings'),
+            update: (body) => client.request('taps_updateSettings', { body }),
+        },
+        garden: {
+            get: () => client.request('taps_getGardenIntegration'),
+            enable: () => client.request('taps_enableGardenIntegration', { body: {} }),
+        },
+        lineage: {
+            /** Human only. */
+            challenge: (body) => client.request('taps_createAgentLineageChallenge', { body }),
+            requests: {
+                /** Human only. */
+                create: (body) => client.request('taps_createAgentLineageRequest', { body }),
+                list: (q = {}) => client.request('taps_listAgentLineageRequests', q),
+                get: (id) => client.request('taps_getAgentLineageRequest', { id }),
+            },
+        },
+    };
+}