@renai-labs/sdk 0.1.24 → 0.1.26

package/dist/generated/@tanstack/react-query.gen.js

@@ -27,6 +27,38 @@ const createQueryKey = (id, options, infinite, tags) => {
     }
     return [params];
 };
+export const activationGetQueryKey = (options) => createQueryKey("activationGet", options);
+/**
+ * Get the organization's onboarding checklist state
+ */
+export const activationGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().activation.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: activationGetQueryKey(options),
+});
+/**
+ * Dismiss the organization's onboarding checklist
+ */
+export const activationDismissMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().activation.dismiss({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
 export const agentListQueryKey = (options) => createQueryKey("agentList", options);
 /**
  * List and search agents
@@ -395,12 +427,12 @@ export const blueprintPushMutation = (options) => {
     return mutationOptions;
 };
 /**
- * Install a blueprint into a pod
+ * Add a blueprint to the caller's workspace
  */
-export const blueprintInstallMutation = (options) => {
+export const blueprintAddMutation = (options) => {
     const mutationOptions = {
         mutationFn: async (fnOptions) => {
-            const { data } = await RenClient.__registry.get().blueprint.install({
+            const { data } = await RenClient.__registry.get().blueprint.add({
                 ...options,
                 ...fnOptions,
                 throwOnError: true,
@@ -1347,6 +1379,198 @@ export const googleConnectMutation = (options) => {
     };
     return mutationOptions;
 };
+export const inferenceSubscriptionsListQueryKey = (options) => createQueryKey("inferenceSubscriptionsList", options);
+/**
+ * List organization subscription seats
+ */
+export const inferenceSubscriptionsListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().inference.subscriptions.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: inferenceSubscriptionsListQueryKey(options),
+});
+/**
+ * Begin connecting an Anthropic subscription over OAuth
+ */
+export const inferenceSubscriptionsOauthStartMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.subscriptions.oauth.start({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+/**
+ * Finish connecting an Anthropic subscription over OAuth
+ */
+export const inferenceSubscriptionsOauthCompleteMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.subscriptions.oauth.complete({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+/**
+ * Begin connecting a Codex subscription with a device code
+ */
+export const inferenceSubscriptionsCodexDeviceStartMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.subscriptions.codex.device.start({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+export const inferenceSubscriptionsCodexDevicePollQueryKey = (options) => createQueryKey("inferenceSubscriptionsCodexDevicePoll", options);
+/**
+ * Check whether a Codex device authorization has been approved
+ */
+export const inferenceSubscriptionsCodexDevicePollOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().inference.subscriptions.codex.device.poll({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: inferenceSubscriptionsCodexDevicePollQueryKey(options),
+});
+export const inferenceHarnessesCodexCatalogQueryKey = (options) => createQueryKey("inferenceHarnessesCodexCatalog", options);
+/**
+ * List the Codex models Ren publishes, and the reasoning efforts each accepts
+ */
+export const inferenceHarnessesCodexCatalogOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().inference.harnesses.codex.catalog({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: inferenceHarnessesCodexCatalogQueryKey(options),
+});
+/**
+ * Connect a Codex subscription with a workspace access token
+ */
+export const inferenceSubscriptionsConnectCodexMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.subscriptions.connectCodex({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+/**
+ * Remove a subscription seat
+ */
+export const inferenceSubscriptionsRemoveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.subscriptions.remove({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+/**
+ * Rename a subscription seat
+ */
+export const inferenceSubscriptionsRenameMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.subscriptions.rename({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+export const inferenceKeysListQueryKey = (options) => createQueryKey("inferenceKeysList", options);
+/**
+ * List inference keys
+ */
+export const inferenceKeysListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().inference.keys.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: inferenceKeysListQueryKey(options),
+});
+/**
+ * Create an inference key
+ */
+export const inferenceKeysCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.keys.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+/**
+ * Revoke an inference key
+ */
+export const inferenceKeysRevokeMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().inference.keys.revoke({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
 export const oauthAppListQueryKey = (options) => createQueryKey("oauthAppList", options);
 /**
  * List the org's OAuth apps
@@ -1938,7 +2162,7 @@ export const modelListOptions = (options) => queryOptions({
 /**
  * Start onboarding chat with Ren agent
  *
- * Creates a session on the user's private pod Ren project and sends the initial prompt with selected MCP/skill context.
+ * Starts a background session-creation job on the user's private pod Ren project and prepares the initial prompt with selected MCP/skill context. Poll session.createStatus with the returned jobId.
  */
 export const onboardingStartMutation = (options) => {
     const mutationOptions = {
@@ -3852,6 +4076,125 @@ export const skillVersionArchiveMutation = (options) => {
     };
     return mutationOptions;
 };
+export const taskListQueryKey = (options) => createQueryKey("taskList", options);
+/**
+ * List tasks
+ *
+ * The actionable set by default: `open` and `in_progress` tasks the caller can see, newest first. Pass `includeDone=true` for the full history, including `dismissed` items — do that before creating a task so a previously rejected suggestion is not resurrected.
+ */
+export const taskListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().task.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: taskListQueryKey(options),
+});
+export const taskListInfiniteQueryKey = (options) => createQueryKey("taskList", options, true);
+/**
+ * List tasks
+ *
+ * The actionable set by default: `open` and `in_progress` tasks the caller can see, newest first. Pass `includeDone=true` for the full history, including `dismissed` items — do that before creating a task so a previously rejected suggestion is not resurrected.
+ */
+export const taskListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === "object"
+            ? pageParam
+            : {
+                query: {
+                    offset: pageParam,
+                },
+            };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().task.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: taskListInfiniteQueryKey(options),
+});
+/**
+ * Create a task
+ *
+ * Create an action item. Org-visible by default; `visibility: "private"` keeps it to the calling user. Set `projectId` to bind it to a project (its pod is filled in automatically), or `podId` alone for a pod-wide task.
+ */
+export const taskCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().task.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a task
+ *
+ * Soft delete. The task leaves every list; its activity log survives.
+ */
+export const taskArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().task.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+export const taskGetQueryKey = (options) => createQueryKey("taskGet", options);
+/**
+ * Get a task
+ *
+ * Fetch one task by id, with its activity trail embedded by default. The trail says who created the task and records every status change and reassignment along with the actor behind it — read it before editing a task you did not create, so you do not undo somebody else's decision. Pass `includeEvents=false` when you only need the task's current state. Returns 404 when the task is outside the caller's visibility.
+ */
+export const taskGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().task.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    },
+    queryKey: taskGetQueryKey(options),
+});
+/**
+ * Update a task
+ *
+ * Partial patch of any mutable field — the single way to change a task. An omitted field is left alone; an explicit `null` clears one, so `assignedToUserId: null` unassigns the human owner and `assignedToProjectAgentId: null` unassigns the agent. Set `status` to `done` when the work is finished, or to `dismissed` to reject a suggestion — a dismissed task stays queryable, so it is not proposed again. The activity log stays precise: a patch touching only `status` records `task.status_changed` and one touching only the assignees records `task.assigned`.
+ */
+export const taskUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().task.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
 export const topologyGetQueryKey = (options) => createQueryKey("topologyGet", options);
 /**
  * Get agent-stack topology