@runloop/reflex-client 0.1.0

package/src/react/agents.ts

@@ -0,0 +1,2149 @@
+/**
+ * Generated by orval v8.18.0 🍺
+ * Do not edit manually.
+ * Reflex API
+ * OpenAPI spec version: 1.0.0
+ */
+import {
+  useMutation,
+  useQuery
+} from '@tanstack/react-query';
+import type {
+  MutationFunction,
+  QueryFunction,
+  QueryKey,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult
+} from '@tanstack/react-query';
+
+import type {
+  Agent
+} from './model/agent.js';
+
+import type {
+  AgentServiceStatusesResponse
+} from './model/agentServiceStatusesResponse.js';
+
+import type {
+  AgentView
+} from './model/agentView.js';
+
+import type {
+  AgentViewsResponse
+} from './model/agentViewsResponse.js';
+
+import type {
+  ArchiveAllAgents200
+} from './model/archiveAllAgents200.js';
+
+import type {
+  ArchiveAllAgentsBody
+} from './model/archiveAllAgentsBody.js';
+
+import type {
+  AxonEvent
+} from './model/axonEvent.js';
+
+import type {
+  CreateAgentBody
+} from './model/createAgentBody.js';
+
+import type {
+  CreateAgentResponse
+} from './model/createAgentResponse.js';
+
+import type {
+  CreateAgentSnapshotBody
+} from './model/createAgentSnapshotBody.js';
+
+import type {
+  EnqueueAgentMessage201
+} from './model/enqueueAgentMessage201.js';
+
+import type {
+  EnqueueAgentMessageBody
+} from './model/enqueueAgentMessageBody.js';
+
+import type {
+  GetAgentQueue200Item
+} from './model/getAgentQueue200Item.js';
+
+import type {
+  ListAgents200
+} from './model/listAgents200.js';
+
+import type {
+  ListAgentsParams
+} from './model/listAgentsParams.js';
+
+import type {
+  RemoveQueuedAgentMessage200
+} from './model/removeQueuedAgentMessage200.js';
+
+import type {
+  ReorderAgentQueue200Item
+} from './model/reorderAgentQueue200Item.js';
+
+import type {
+  ReorderAgentQueueBody
+} from './model/reorderAgentQueueBody.js';
+
+import type {
+  SendAgentControlResponseBody
+} from './model/sendAgentControlResponseBody.js';
+
+import type {
+  SendAgentMessageBody
+} from './model/sendAgentMessageBody.js';
+
+import type {
+  SetAgentMarkBody
+} from './model/setAgentMarkBody.js';
+
+import type {
+  Snapshot
+} from './model/snapshot.js';
+
+import type {
+  SwitchAgentSubscriptionBody
+} from './model/switchAgentSubscriptionBody.js';
+
+import type {
+  UpdateAgentBody
+} from './model/updateAgentBody.js';
+
+import type {
+  UpdateQueuedAgentMessage200
+} from './model/updateQueuedAgentMessage200.js';
+
+import type {
+  UpdateQueuedAgentMessageBody
+} from './model/updateQueuedAgentMessageBody.js';
+
+import { apiFetch } from '../react-mutator.js';
+
+
+type AwaitedInput<T> = PromiseLike<T> | T;
+
+      type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+
+
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+
+
+
+const withQueryKey = <T extends object, K>(query: T, queryKey: K): T & { queryKey: K } => {
+  const result = { queryKey } as T & { queryKey: K };
+  for (const key of Object.keys(query)) {
+    // The explicit queryKey always wins, matching the previous
+    // `{ ...query, queryKey }` spread where it was set last.
+    if (key === 'queryKey') continue;
+    Object.defineProperty(result, key, {
+      enumerable: true,
+      configurable: true,
+      get: () => (query as Record<string, unknown>)[key],
+    });
+  }
+  return result;
+};
+
+/**
+ * @summary List the agents in the active organization.
+ */
+export const listAgents = (
+    params?: ListAgentsParams,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<ListAgents200>(
+      {url: `/agents`, method: 'GET',
+        params, signal
+    },
+      options);
+    }
+
+
+
+
+export const getListAgentsQueryKey = (params?: ListAgentsParams,) => {
+    return [
+    `/agents`, ...(params ? [params] : [])
+    ] as const;
+    }
+
+
+export const getListAgentsQueryOptions = <TData = Awaited<ReturnType<typeof listAgents>>, TError = unknown>(params?: ListAgentsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAgents>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getListAgentsQueryKey(params);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof listAgents>>> = ({ signal }) => listAgents(params, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof listAgents>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type ListAgentsQueryResult = NonNullable<Awaited<ReturnType<typeof listAgents>>>
+export type ListAgentsQueryError = unknown
+
+
+/**
+ * @summary List the agents in the active organization.
+ */
+
+export function useListAgents<TData = Awaited<ReturnType<typeof listAgents>>, TError = unknown>(
+ params?: ListAgentsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAgents>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getListAgentsQueryOptions(params,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * Returns as soon as the run is created; the devbox provisions in the background. Watch the agent status or event stream for progress.
+ * @summary Create and launch a new agent run.
+ */
+export const createAgent = (
+    createAgentBody: CreateAgentBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<CreateAgentResponse>(
+      {url: `/agents`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: createAgentBody, signal
+    },
+      options);
+    }
+
+
+
+export const getCreateAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAgent>>, TError,{data: CreateAgentBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof createAgent>>, TError,{data: CreateAgentBody}, TContext> => {
+
+const mutationKey = ['createAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createAgent>>, {data: CreateAgentBody}> = (props) => {
+          const {data} = props ?? {};
+
+          return  createAgent(data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type CreateAgentMutationResult = NonNullable<Awaited<ReturnType<typeof createAgent>>>
+    export type CreateAgentMutationBody = CreateAgentBody
+    export type CreateAgentMutationError = unknown
+
+    /**
+ * @summary Create and launch a new agent run.
+ */
+export const useCreateAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAgent>>, TError,{data: CreateAgentBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof createAgent>>,
+        TError,
+        {data: CreateAgentBody},
+        TContext
+      > => {
+      return useMutation(getCreateAgentMutationOptions(options));
+    }
+    /**
+ * @summary Get a single agent by id.
+ */
+export const getAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getGetAgentQueryKey = (id: string,) => {
+    return [
+    `/agents/${id}`
+    ] as const;
+    }
+
+
+export const getGetAgentQueryOptions = <TData = Awaited<ReturnType<typeof getAgent>>, TError = unknown>(id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgent>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getGetAgentQueryKey(id);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAgent>>> = ({ signal }) => getAgent(id, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAgent>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type GetAgentQueryResult = NonNullable<Awaited<ReturnType<typeof getAgent>>>
+export type GetAgentQueryError = unknown
+
+
+/**
+ * @summary Get a single agent by id.
+ */
+
+export function useGetAgent<TData = Awaited<ReturnType<typeof getAgent>>, TError = unknown>(
+ id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgent>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getGetAgentQueryOptions(id,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * @summary Update an agent's name or pinned state.
+ */
+export const updateAgent = (
+    id: string,
+    updateAgentBody: UpdateAgentBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}`, method: 'PATCH',
+      headers: {'Content-Type': 'application/json', },
+      data: updateAgentBody, signal
+    },
+      options);
+    }
+
+
+
+export const getUpdateAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateAgent>>, TError,{id: string;data: UpdateAgentBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof updateAgent>>, TError,{id: string;data: UpdateAgentBody}, TContext> => {
+
+const mutationKey = ['updateAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateAgent>>, {id: string;data: UpdateAgentBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  updateAgent(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type UpdateAgentMutationResult = NonNullable<Awaited<ReturnType<typeof updateAgent>>>
+    export type UpdateAgentMutationBody = UpdateAgentBody
+    export type UpdateAgentMutationError = unknown
+
+    /**
+ * @summary Update an agent's name or pinned state.
+ */
+export const useUpdateAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateAgent>>, TError,{id: string;data: UpdateAgentBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof updateAgent>>,
+        TError,
+        {id: string;data: UpdateAgentBody},
+        TContext
+      > => {
+      return useMutation(getUpdateAgentMutationOptions(options));
+    }
+    /**
+ * @summary Force stop the agent and shut down its devbox.
+ */
+export const killAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}`, method: 'DELETE', signal
+    },
+      options);
+    }
+
+
+
+export const getKillAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof killAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof killAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['killAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof killAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  killAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type KillAgentMutationResult = NonNullable<Awaited<ReturnType<typeof killAgent>>>
+
+    export type KillAgentMutationError = unknown
+
+    /**
+ * @summary Force stop the agent and shut down its devbox.
+ */
+export const useKillAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof killAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof killAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getKillAgentMutationOptions(options));
+    }
+    /**
+ * @summary Archive the agent run.
+ */
+export const archiveAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}/archive`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getArchiveAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof archiveAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof archiveAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['archiveAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof archiveAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  archiveAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type ArchiveAgentMutationResult = NonNullable<Awaited<ReturnType<typeof archiveAgent>>>
+
+    export type ArchiveAgentMutationError = unknown
+
+    /**
+ * @summary Archive the agent run.
+ */
+export const useArchiveAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof archiveAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof archiveAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getArchiveAgentMutationOptions(options));
+    }
+    /**
+ * @summary Mark the agent's run as completed without shutting down its devbox.
+ */
+export const completeAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/complete`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getCompleteAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof completeAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof completeAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['completeAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof completeAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  completeAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type CompleteAgentMutationResult = NonNullable<Awaited<ReturnType<typeof completeAgent>>>
+
+    export type CompleteAgentMutationError = unknown
+
+    /**
+ * @summary Mark the agent's run as completed without shutting down its devbox.
+ */
+export const useCompleteAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof completeAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof completeAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getCompleteAgentMutationOptions(options));
+    }
+    /**
+ * @summary Answer a pending control request from the agent.
+ */
+export const sendAgentControlResponse = (
+    id: string,
+    sendAgentControlResponseBody: SendAgentControlResponseBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/control-response`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: sendAgentControlResponseBody, signal
+    },
+      options);
+    }
+
+
+
+export const getSendAgentControlResponseMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof sendAgentControlResponse>>, TError,{id: string;data: SendAgentControlResponseBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof sendAgentControlResponse>>, TError,{id: string;data: SendAgentControlResponseBody}, TContext> => {
+
+const mutationKey = ['sendAgentControlResponse'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof sendAgentControlResponse>>, {id: string;data: SendAgentControlResponseBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  sendAgentControlResponse(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type SendAgentControlResponseMutationResult = NonNullable<Awaited<ReturnType<typeof sendAgentControlResponse>>>
+    export type SendAgentControlResponseMutationBody = SendAgentControlResponseBody
+    export type SendAgentControlResponseMutationError = unknown
+
+    /**
+ * @summary Answer a pending control request from the agent.
+ */
+export const useSendAgentControlResponse = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof sendAgentControlResponse>>, TError,{id: string;data: SendAgentControlResponseBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof sendAgentControlResponse>>,
+        TError,
+        {id: string;data: SendAgentControlResponseBody},
+        TContext
+      > => {
+      return useMutation(getSendAgentControlResponseMutationOptions(options));
+    }
+    /**
+ * @summary Fetch the platform logs for the agent's devbox.
+ */
+export const getAgentDevboxLogs = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/devbox-logs`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getGetAgentDevboxLogsQueryKey = (id: string,) => {
+    return [
+    `/agents/${id}/devbox-logs`
+    ] as const;
+    }
+
+
+export const getGetAgentDevboxLogsQueryOptions = <TData = Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError = unknown>(id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getGetAgentDevboxLogsQueryKey(id);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAgentDevboxLogs>>> = ({ signal }) => getAgentDevboxLogs(id, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type GetAgentDevboxLogsQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentDevboxLogs>>>
+export type GetAgentDevboxLogsQueryError = unknown
+
+
+/**
+ * @summary Fetch the platform logs for the agent's devbox.
+ */
+
+export function useGetAgentDevboxLogs<TData = Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError = unknown>(
+ id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxLogs>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getGetAgentDevboxLogsQueryOptions(id,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * @summary Get the live status, size, and architecture of the agent's devbox.
+ */
+export const getAgentDevboxStatus = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/devbox-status`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getGetAgentDevboxStatusQueryKey = (id: string,) => {
+    return [
+    `/agents/${id}/devbox-status`
+    ] as const;
+    }
+
+
+export const getGetAgentDevboxStatusQueryOptions = <TData = Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError = unknown>(id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getGetAgentDevboxStatusQueryKey(id);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAgentDevboxStatus>>> = ({ signal }) => getAgentDevboxStatus(id, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type GetAgentDevboxStatusQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentDevboxStatus>>>
+export type GetAgentDevboxStatusQueryError = unknown
+
+
+/**
+ * @summary Get the live status, size, and architecture of the agent's devbox.
+ */
+
+export function useGetAgentDevboxStatus<TData = Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError = unknown>(
+ id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentDevboxStatus>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getGetAgentDevboxStatusQueryOptions(id,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * @summary Interrupt the agent's current turn.
+ */
+export const interruptAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/interrupt`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getInterruptAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof interruptAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof interruptAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['interruptAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof interruptAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  interruptAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type InterruptAgentMutationResult = NonNullable<Awaited<ReturnType<typeof interruptAgent>>>
+
+    export type InterruptAgentMutationError = unknown
+
+    /**
+ * @summary Interrupt the agent's current turn.
+ */
+export const useInterruptAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof interruptAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof interruptAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getInterruptAgentMutationOptions(options));
+    }
+    /**
+ * Marks a run blocked / in review / completed for triage. A null mark clears it. The server also clears the mark when the run starts its next turn or is archived.
+ * @summary Set or clear the agent's triage mark.
+ */
+export const setAgentMark = (
+    id: string,
+    setAgentMarkBody: SetAgentMarkBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}/mark`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: setAgentMarkBody, signal
+    },
+      options);
+    }
+
+
+
+export const getSetAgentMarkMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof setAgentMark>>, TError,{id: string;data: SetAgentMarkBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof setAgentMark>>, TError,{id: string;data: SetAgentMarkBody}, TContext> => {
+
+const mutationKey = ['setAgentMark'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof setAgentMark>>, {id: string;data: SetAgentMarkBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  setAgentMark(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type SetAgentMarkMutationResult = NonNullable<Awaited<ReturnType<typeof setAgentMark>>>
+    export type SetAgentMarkMutationBody = SetAgentMarkBody
+    export type SetAgentMarkMutationError = unknown
+
+    /**
+ * @summary Set or clear the agent's triage mark.
+ */
+export const useSetAgentMark = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof setAgentMark>>, TError,{id: string;data: SetAgentMarkBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof setAgentMark>>,
+        TError,
+        {id: string;data: SetAgentMarkBody},
+        TContext
+      > => {
+      return useMutation(getSetAgentMarkMutationOptions(options));
+    }
+    /**
+ * @summary Send a message to the agent's chat.
+ */
+export const sendAgentMessage = (
+    id: string,
+    sendAgentMessageBody: SendAgentMessageBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<AxonEvent>(
+      {url: `/agents/${encodeURIComponent(String(id))}/message`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: sendAgentMessageBody, signal
+    },
+      options);
+    }
+
+
+
+export const getSendAgentMessageMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof sendAgentMessage>>, TError,{id: string;data: SendAgentMessageBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof sendAgentMessage>>, TError,{id: string;data: SendAgentMessageBody}, TContext> => {
+
+const mutationKey = ['sendAgentMessage'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof sendAgentMessage>>, {id: string;data: SendAgentMessageBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  sendAgentMessage(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type SendAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof sendAgentMessage>>>
+    export type SendAgentMessageMutationBody = SendAgentMessageBody
+    export type SendAgentMessageMutationError = unknown
+
+    /**
+ * @summary Send a message to the agent's chat.
+ */
+export const useSendAgentMessage = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof sendAgentMessage>>, TError,{id: string;data: SendAgentMessageBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof sendAgentMessage>>,
+        TError,
+        {id: string;data: SendAgentMessageBody},
+        TContext
+      > => {
+      return useMutation(getSendAgentMessageMutationOptions(options));
+    }
+    /**
+ * @summary Pin the agent.
+ */
+export const pinAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/pin`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getPinAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof pinAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof pinAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['pinAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof pinAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  pinAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type PinAgentMutationResult = NonNullable<Awaited<ReturnType<typeof pinAgent>>>
+
+    export type PinAgentMutationError = unknown
+
+    /**
+ * @summary Pin the agent.
+ */
+export const usePinAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof pinAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof pinAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getPinAgentMutationOptions(options));
+    }
+    /**
+ * @summary List the messages queued for the agent.
+ */
+export const getAgentQueue = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<GetAgentQueue200Item[]>(
+      {url: `/agents/${encodeURIComponent(String(id))}/queue`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getGetAgentQueueQueryKey = (id: string,) => {
+    return [
+    `/agents/${id}/queue`
+    ] as const;
+    }
+
+
+export const getGetAgentQueueQueryOptions = <TData = Awaited<ReturnType<typeof getAgentQueue>>, TError = unknown>(id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentQueue>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getGetAgentQueueQueryKey(id);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAgentQueue>>> = ({ signal }) => getAgentQueue(id, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAgentQueue>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type GetAgentQueueQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentQueue>>>
+export type GetAgentQueueQueryError = unknown
+
+
+/**
+ * @summary List the messages queued for the agent.
+ */
+
+export function useGetAgentQueue<TData = Awaited<ReturnType<typeof getAgentQueue>>, TError = unknown>(
+ id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentQueue>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getGetAgentQueueQueryOptions(id,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * Queued messages are delivered one per turn whenever the agent next accepts input, even when no client is connected.
+ * @summary Add a message to the agent's queue.
+ */
+export const enqueueAgentMessage = (
+    id: string,
+    enqueueAgentMessageBody: EnqueueAgentMessageBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<EnqueueAgentMessage201>(
+      {url: `/agents/${encodeURIComponent(String(id))}/queue`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: enqueueAgentMessageBody, signal
+    },
+      options);
+    }
+
+
+
+export const getEnqueueAgentMessageMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof enqueueAgentMessage>>, TError,{id: string;data: EnqueueAgentMessageBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof enqueueAgentMessage>>, TError,{id: string;data: EnqueueAgentMessageBody}, TContext> => {
+
+const mutationKey = ['enqueueAgentMessage'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof enqueueAgentMessage>>, {id: string;data: EnqueueAgentMessageBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  enqueueAgentMessage(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type EnqueueAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof enqueueAgentMessage>>>
+    export type EnqueueAgentMessageMutationBody = EnqueueAgentMessageBody
+    export type EnqueueAgentMessageMutationError = unknown
+
+    /**
+ * @summary Add a message to the agent's queue.
+ */
+export const useEnqueueAgentMessage = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof enqueueAgentMessage>>, TError,{id: string;data: EnqueueAgentMessageBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof enqueueAgentMessage>>,
+        TError,
+        {id: string;data: EnqueueAgentMessageBody},
+        TContext
+      > => {
+      return useMutation(getEnqueueAgentMessageMutationOptions(options));
+    }
+    /**
+ * Edits the text and, when `attachments` is present, replaces the attachment list with the one sent.
+ * @summary Edit a queued message.
+ */
+export const updateQueuedAgentMessage = (
+    id: string,
+    msgId: string,
+    updateQueuedAgentMessageBody: UpdateQueuedAgentMessageBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<UpdateQueuedAgentMessage200>(
+      {url: `/agents/${encodeURIComponent(String(id))}/queue/${encodeURIComponent(String(msgId))}`, method: 'PATCH',
+      headers: {'Content-Type': 'application/json', },
+      data: updateQueuedAgentMessageBody, signal
+    },
+      options);
+    }
+
+
+
+export const getUpdateQueuedAgentMessageMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, TError,{id: string;msgId: string;data: UpdateQueuedAgentMessageBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, TError,{id: string;msgId: string;data: UpdateQueuedAgentMessageBody}, TContext> => {
+
+const mutationKey = ['updateQueuedAgentMessage'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, {id: string;msgId: string;data: UpdateQueuedAgentMessageBody}> = (props) => {
+          const {id,msgId,data} = props ?? {};
+
+          return  updateQueuedAgentMessage(id,msgId,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type UpdateQueuedAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof updateQueuedAgentMessage>>>
+    export type UpdateQueuedAgentMessageMutationBody = UpdateQueuedAgentMessageBody
+    export type UpdateQueuedAgentMessageMutationError = unknown
+
+    /**
+ * @summary Edit a queued message.
+ */
+export const useUpdateQueuedAgentMessage = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateQueuedAgentMessage>>, TError,{id: string;msgId: string;data: UpdateQueuedAgentMessageBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof updateQueuedAgentMessage>>,
+        TError,
+        {id: string;msgId: string;data: UpdateQueuedAgentMessageBody},
+        TContext
+      > => {
+      return useMutation(getUpdateQueuedAgentMessageMutationOptions(options));
+    }
+    /**
+ * @summary Remove a message from the agent's queue.
+ */
+export const removeQueuedAgentMessage = (
+    id: string,
+    msgId: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<RemoveQueuedAgentMessage200>(
+      {url: `/agents/${encodeURIComponent(String(id))}/queue/${encodeURIComponent(String(msgId))}`, method: 'DELETE', signal
+    },
+      options);
+    }
+
+
+
+export const getRemoveQueuedAgentMessageMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, TError,{id: string;msgId: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, TError,{id: string;msgId: string}, TContext> => {
+
+const mutationKey = ['removeQueuedAgentMessage'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, {id: string;msgId: string}> = (props) => {
+          const {id,msgId} = props ?? {};
+
+          return  removeQueuedAgentMessage(id,msgId,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type RemoveQueuedAgentMessageMutationResult = NonNullable<Awaited<ReturnType<typeof removeQueuedAgentMessage>>>
+
+    export type RemoveQueuedAgentMessageMutationError = unknown
+
+    /**
+ * @summary Remove a message from the agent's queue.
+ */
+export const useRemoveQueuedAgentMessage = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof removeQueuedAgentMessage>>, TError,{id: string;msgId: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof removeQueuedAgentMessage>>,
+        TError,
+        {id: string;msgId: string},
+        TContext
+      > => {
+      return useMutation(getRemoveQueuedAgentMessageMutationOptions(options));
+    }
+    /**
+ * @summary Reorder the agent's queued messages.
+ */
+export const reorderAgentQueue = (
+    id: string,
+    reorderAgentQueueBody: ReorderAgentQueueBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<ReorderAgentQueue200Item[]>(
+      {url: `/agents/${encodeURIComponent(String(id))}/queue/order`, method: 'PUT',
+      headers: {'Content-Type': 'application/json', },
+      data: reorderAgentQueueBody, signal
+    },
+      options);
+    }
+
+
+
+export const getReorderAgentQueueMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof reorderAgentQueue>>, TError,{id: string;data: ReorderAgentQueueBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof reorderAgentQueue>>, TError,{id: string;data: ReorderAgentQueueBody}, TContext> => {
+
+const mutationKey = ['reorderAgentQueue'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof reorderAgentQueue>>, {id: string;data: ReorderAgentQueueBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  reorderAgentQueue(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type ReorderAgentQueueMutationResult = NonNullable<Awaited<ReturnType<typeof reorderAgentQueue>>>
+    export type ReorderAgentQueueMutationBody = ReorderAgentQueueBody
+    export type ReorderAgentQueueMutationError = unknown
+
+    /**
+ * @summary Reorder the agent's queued messages.
+ */
+export const useReorderAgentQueue = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof reorderAgentQueue>>, TError,{id: string;data: ReorderAgentQueueBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof reorderAgentQueue>>,
+        TError,
+        {id: string;data: ReorderAgentQueueBody},
+        TContext
+      > => {
+      return useMutation(getReorderAgentQueueMutationOptions(options));
+    }
+    /**
+ * @summary Resume the agent's devbox if it is suspended.
+ */
+export const resumeAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/resume`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getResumeAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof resumeAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof resumeAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['resumeAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof resumeAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  resumeAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type ResumeAgentMutationResult = NonNullable<Awaited<ReturnType<typeof resumeAgent>>>
+
+    export type ResumeAgentMutationError = unknown
+
+    /**
+ * @summary Resume the agent's devbox if it is suspended.
+ */
+export const useResumeAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof resumeAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof resumeAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getResumeAgentMutationOptions(options));
+    }
+    /**
+ * @summary Fetch the log for one service on the agent's devbox.
+ */
+export const getAgentServiceLogs = (
+    id: string,
+    serviceId: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/services/${encodeURIComponent(String(serviceId))}/logs`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getGetAgentServiceLogsQueryKey = (id: string,
+    serviceId: string,) => {
+    return [
+    `/agents/${id}/services/${serviceId}/logs`
+    ] as const;
+    }
+
+
+export const getGetAgentServiceLogsQueryOptions = <TData = Awaited<ReturnType<typeof getAgentServiceLogs>>, TError = unknown>(id: string,
+    serviceId: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceLogs>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getGetAgentServiceLogsQueryKey(id,serviceId);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAgentServiceLogs>>> = ({ signal }) => getAgentServiceLogs(id,serviceId, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, enabled: id !== null && id !== undefined && serviceId !== null && serviceId !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceLogs>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type GetAgentServiceLogsQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentServiceLogs>>>
+export type GetAgentServiceLogsQueryError = unknown
+
+
+/**
+ * @summary Fetch the log for one service on the agent's devbox.
+ */
+
+export function useGetAgentServiceLogs<TData = Awaited<ReturnType<typeof getAgentServiceLogs>>, TError = unknown>(
+ id: string,
+    serviceId: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceLogs>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getGetAgentServiceLogsQueryOptions(id,serviceId,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * @summary Get the live status of every service on the agent's devbox.
+ */
+export const getAgentServiceStatuses = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<AgentServiceStatusesResponse>(
+      {url: `/agents/${encodeURIComponent(String(id))}/services/status`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getGetAgentServiceStatusesQueryKey = (id: string,) => {
+    return [
+    `/agents/${id}/services/status`
+    ] as const;
+    }
+
+
+export const getGetAgentServiceStatusesQueryOptions = <TData = Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError = unknown>(id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getGetAgentServiceStatusesQueryKey(id);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAgentServiceStatuses>>> = ({ signal }) => getAgentServiceStatuses(id, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type GetAgentServiceStatusesQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentServiceStatuses>>>
+export type GetAgentServiceStatusesQueryError = unknown
+
+
+/**
+ * @summary Get the live status of every service on the agent's devbox.
+ */
+
+export function useGetAgentServiceStatuses<TData = Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError = unknown>(
+ id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentServiceStatuses>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getGetAgentServiceStatusesQueryOptions(id,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * This ends the run: per-run state is stripped from the disk, the capture starts asynchronously, and the devbox shuts down once it completes. Poll the snapshot's status route until the capture finishes.
+ * @summary Capture a reusable snapshot of the agent's devbox disk.
+ */
+export const createAgentSnapshot = (
+    id: string,
+    createAgentSnapshotBody: CreateAgentSnapshotBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Snapshot>(
+      {url: `/agents/${encodeURIComponent(String(id))}/snapshots`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: createAgentSnapshotBody, signal
+    },
+      options);
+    }
+
+
+
+export const getCreateAgentSnapshotMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAgentSnapshot>>, TError,{id: string;data: CreateAgentSnapshotBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof createAgentSnapshot>>, TError,{id: string;data: CreateAgentSnapshotBody}, TContext> => {
+
+const mutationKey = ['createAgentSnapshot'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createAgentSnapshot>>, {id: string;data: CreateAgentSnapshotBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  createAgentSnapshot(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type CreateAgentSnapshotMutationResult = NonNullable<Awaited<ReturnType<typeof createAgentSnapshot>>>
+    export type CreateAgentSnapshotMutationBody = CreateAgentSnapshotBody
+    export type CreateAgentSnapshotMutationError = unknown
+
+    /**
+ * @summary Capture a reusable snapshot of the agent's devbox disk.
+ */
+export const useCreateAgentSnapshot = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAgentSnapshot>>, TError,{id: string;data: CreateAgentSnapshotBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof createAgentSnapshot>>,
+        TError,
+        {id: string;data: CreateAgentSnapshotBody},
+        TContext
+      > => {
+      return useMutation(getCreateAgentSnapshotMutationOptions(options));
+    }
+    /**
+ * @summary Stop the agent's run and shut down its devbox.
+ */
+export const stopAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}/stop`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getStopAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof stopAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof stopAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['stopAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof stopAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  stopAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type StopAgentMutationResult = NonNullable<Awaited<ReturnType<typeof stopAgent>>>
+
+    export type StopAgentMutationError = unknown
+
+    /**
+ * @summary Stop the agent's run and shut down its devbox.
+ */
+export const useStopAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof stopAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof stopAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getStopAgentMutationOptions(options));
+    }
+    /**
+ * @summary Get the agent's full event history.
+ */
+export const getAgentStream = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<AxonEvent[]>(
+      {url: `/agents/${encodeURIComponent(String(id))}/stream`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getGetAgentStreamQueryKey = (id: string,) => {
+    return [
+    `/agents/${id}/stream`
+    ] as const;
+    }
+
+
+export const getGetAgentStreamQueryOptions = <TData = Awaited<ReturnType<typeof getAgentStream>>, TError = unknown>(id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentStream>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getGetAgentStreamQueryKey(id);
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof getAgentStream>>> = ({ signal }) => getAgentStream(id, requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAgentStream>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type GetAgentStreamQueryResult = NonNullable<Awaited<ReturnType<typeof getAgentStream>>>
+export type GetAgentStreamQueryError = unknown
+
+
+/**
+ * @summary Get the agent's full event history.
+ */
+
+export function useGetAgentStream<TData = Awaited<ReturnType<typeof getAgentStream>>, TError = unknown>(
+ id: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAgentStream>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getGetAgentStreamQueryOptions(id,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+
+/**
+ * @summary Switch the model-provider subscription a running agent uses.
+ */
+export const switchAgentSubscription = (
+    id: string,
+    switchAgentSubscriptionBody: SwitchAgentSubscriptionBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}/subscription`, method: 'PUT',
+      headers: {'Content-Type': 'application/json', },
+      data: switchAgentSubscriptionBody, signal
+    },
+      options);
+    }
+
+
+
+export const getSwitchAgentSubscriptionMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof switchAgentSubscription>>, TError,{id: string;data: SwitchAgentSubscriptionBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof switchAgentSubscription>>, TError,{id: string;data: SwitchAgentSubscriptionBody}, TContext> => {
+
+const mutationKey = ['switchAgentSubscription'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof switchAgentSubscription>>, {id: string;data: SwitchAgentSubscriptionBody}> = (props) => {
+          const {id,data} = props ?? {};
+
+          return  switchAgentSubscription(id,data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type SwitchAgentSubscriptionMutationResult = NonNullable<Awaited<ReturnType<typeof switchAgentSubscription>>>
+    export type SwitchAgentSubscriptionMutationBody = SwitchAgentSubscriptionBody
+    export type SwitchAgentSubscriptionMutationError = unknown
+
+    /**
+ * @summary Switch the model-provider subscription a running agent uses.
+ */
+export const useSwitchAgentSubscription = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof switchAgentSubscription>>, TError,{id: string;data: SwitchAgentSubscriptionBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof switchAgentSubscription>>,
+        TError,
+        {id: string;data: SwitchAgentSubscriptionBody},
+        TContext
+      > => {
+      return useMutation(getSwitchAgentSubscriptionMutationOptions(options));
+    }
+    /**
+ * @summary Unarchive the agent run.
+ */
+export const unarchiveAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<Agent>(
+      {url: `/agents/${encodeURIComponent(String(id))}/unarchive`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getUnarchiveAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof unarchiveAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof unarchiveAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['unarchiveAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof unarchiveAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  unarchiveAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type UnarchiveAgentMutationResult = NonNullable<Awaited<ReturnType<typeof unarchiveAgent>>>
+
+    export type UnarchiveAgentMutationError = unknown
+
+    /**
+ * @summary Unarchive the agent run.
+ */
+export const useUnarchiveAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof unarchiveAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof unarchiveAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getUnarchiveAgentMutationOptions(options));
+    }
+    /**
+ * @summary Unpin the agent.
+ */
+export const unpinAgent = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<void>(
+      {url: `/agents/${encodeURIComponent(String(id))}/unpin`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getUnpinAgentMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof unpinAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof unpinAgent>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['unpinAgent'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof unpinAgent>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  unpinAgent(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type UnpinAgentMutationResult = NonNullable<Awaited<ReturnType<typeof unpinAgent>>>
+
+    export type UnpinAgentMutationError = unknown
+
+    /**
+ * @summary Unpin the agent.
+ */
+export const useUnpinAgent = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof unpinAgent>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof unpinAgent>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getUnpinAgentMutationOptions(options));
+    }
+    /**
+ * @summary Record that the current user has viewed the agent.
+ */
+export const recordAgentView = (
+    id: string,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<AgentView>(
+      {url: `/agents/${encodeURIComponent(String(id))}/view`, method: 'POST', signal
+    },
+      options);
+    }
+
+
+
+export const getRecordAgentViewMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof recordAgentView>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof recordAgentView>>, TError,{id: string}, TContext> => {
+
+const mutationKey = ['recordAgentView'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof recordAgentView>>, {id: string}> = (props) => {
+          const {id} = props ?? {};
+
+          return  recordAgentView(id,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type RecordAgentViewMutationResult = NonNullable<Awaited<ReturnType<typeof recordAgentView>>>
+
+    export type RecordAgentViewMutationError = unknown
+
+    /**
+ * @summary Record that the current user has viewed the agent.
+ */
+export const useRecordAgentView = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof recordAgentView>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof recordAgentView>>,
+        TError,
+        {id: string},
+        TContext
+      > => {
+      return useMutation(getRecordAgentViewMutationOptions(options));
+    }
+    /**
+ * Still running agents are stopped first, which shuts down their devboxes. The sweep can be narrowed by owner and created date range.
+ * @summary Archive every matching agent run in the active organization.
+ */
+export const archiveAllAgents = (
+    archiveAllAgentsBody: ArchiveAllAgentsBody,
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<ArchiveAllAgents200>(
+      {url: `/agents/archive-all`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: archiveAllAgentsBody, signal
+    },
+      options);
+    }
+
+
+
+export const getArchiveAllAgentsMutationOptions = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof archiveAllAgents>>, TError,{data: ArchiveAllAgentsBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof archiveAllAgents>>, TError,{data: ArchiveAllAgentsBody}, TContext> => {
+
+const mutationKey = ['archiveAllAgents'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof archiveAllAgents>>, {data: ArchiveAllAgentsBody}> = (props) => {
+          const {data} = props ?? {};
+
+          return  archiveAllAgents(data,requestOptions)
+        }
+
+
+
+
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type ArchiveAllAgentsMutationResult = NonNullable<Awaited<ReturnType<typeof archiveAllAgents>>>
+    export type ArchiveAllAgentsMutationBody = ArchiveAllAgentsBody
+    export type ArchiveAllAgentsMutationError = unknown
+
+    /**
+ * @summary Archive every matching agent run in the active organization.
+ */
+export const useArchiveAllAgents = <TError = unknown,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof archiveAllAgents>>, TError,{data: ArchiveAllAgentsBody}, TContext>, request?: SecondParameter<typeof apiFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof archiveAllAgents>>,
+        TError,
+        {data: ArchiveAllAgentsBody},
+        TContext
+      > => {
+      return useMutation(getArchiveAllAgentsMutationOptions(options));
+    }
+    /**
+ * @summary List the current user's per-agent last-viewed timestamps.
+ */
+export const listAgentViews = (
+
+ options?: SecondParameter<typeof apiFetch>,signal?: AbortSignal
+) => {
+
+
+      return apiFetch<AgentViewsResponse>(
+      {url: `/agents/views`, method: 'GET', signal
+    },
+      options);
+    }
+
+
+
+
+export const getListAgentViewsQueryKey = () => {
+    return [
+    `/agents/views`
+    ] as const;
+    }
+
+
+export const getListAgentViewsQueryOptions = <TData = Awaited<ReturnType<typeof listAgentViews>>, TError = unknown>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAgentViews>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getListAgentViewsQueryKey();
+
+
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof listAgentViews>>> = ({ signal }) => listAgentViews(requestOptions, signal);
+
+
+
+
+
+   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof listAgentViews>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type ListAgentViewsQueryResult = NonNullable<Awaited<ReturnType<typeof listAgentViews>>>
+export type ListAgentViewsQueryError = unknown
+
+
+/**
+ * @summary List the current user's per-agent last-viewed timestamps.
+ */
+
+export function useListAgentViews<TData = Awaited<ReturnType<typeof listAgentViews>>, TError = unknown>(
+  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAgentViews>>, TError, TData>, request?: SecondParameter<typeof apiFetch>}
+
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getListAgentViewsQueryOptions(options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+
+
+
+
+