@zyraxon-ai/client 19.0.3 → 19.0.5

package/src/generated/client.ts

@@ -1,1029 +0,0 @@
-import type {
-  HealthGetOutput,
-  LocationGetInput,
-  LocationGetOutput,
-  AgentsListInput,
-  AgentsListOutput,
-  SessionsListInput,
-  SessionsListOutput,
-  SessionsCreateInput,
-  SessionsCreateOutput,
-  SessionsActiveOutput,
-  SessionsGetInput,
-  SessionsGetOutput,
-  SessionsSwitchAgentInput,
-  SessionsSwitchAgentOutput,
-  SessionsSwitchModelInput,
-  SessionsSwitchModelOutput,
-  SessionsPromptInput,
-  SessionsPromptOutput,
-  SessionsCompactInput,
-  SessionsCompactOutput,
-  SessionsWaitInput,
-  SessionsWaitOutput,
-  SessionsStageInput,
-  SessionsStageOutput,
-  SessionsClearInput,
-  SessionsClearOutput,
-  SessionsCommitInput,
-  SessionsCommitOutput,
-  SessionsContextInput,
-  SessionsContextOutput,
-  SessionsHistoryInput,
-  SessionsHistoryOutput,
-  SessionsEventsInput,
-  SessionsEventsOutput,
-  SessionsInterruptInput,
-  SessionsInterruptOutput,
-  SessionsMessageInput,
-  SessionsMessageOutput,
-  MessagesListInput,
-  MessagesListOutput,
-  ModelsListInput,
-  ModelsListOutput,
-  ProvidersListInput,
-  ProvidersListOutput,
-  ProvidersGetInput,
-  ProvidersGetOutput,
-  IntegrationsListInput,
-  IntegrationsListOutput,
-  IntegrationsGetInput,
-  IntegrationsGetOutput,
-  IntegrationsConnectKeyInput,
-  IntegrationsConnectKeyOutput,
-  IntegrationsConnectOauthInput,
-  IntegrationsConnectOauthOutput,
-  IntegrationsAttemptStatusInput,
-  IntegrationsAttemptStatusOutput,
-  IntegrationsAttemptCompleteInput,
-  IntegrationsAttemptCompleteOutput,
-  IntegrationsAttemptCancelInput,
-  IntegrationsAttemptCancelOutput,
-  CredentialsUpdateInput,
-  CredentialsUpdateOutput,
-  CredentialsRemoveInput,
-  CredentialsRemoveOutput,
-  PermissionsListRequestsInput,
-  PermissionsListRequestsOutput,
-  PermissionsListSavedInput,
-  PermissionsListSavedOutput,
-  PermissionsRemoveSavedInput,
-  PermissionsRemoveSavedOutput,
-  PermissionsCreateInput,
-  PermissionsCreateOutput,
-  PermissionsListInput,
-  PermissionsListOutput,
-  PermissionsGetInput,
-  PermissionsGetOutput,
-  PermissionsReplyInput,
-  PermissionsReplyOutput,
-  FilesListInput,
-  FilesListOutput,
-  FilesFindInput,
-  FilesFindOutput,
-  CommandsListInput,
-  CommandsListOutput,
-  SkillsListInput,
-  SkillsListOutput,
-  EventsSubscribeOutput,
-  PtysListInput,
-  PtysListOutput,
-  PtysCreateInput,
-  PtysCreateOutput,
-  PtysGetInput,
-  PtysGetOutput,
-  PtysUpdateInput,
-  PtysUpdateOutput,
-  PtysRemoveInput,
-  PtysRemoveOutput,
-  QuestionsListRequestsInput,
-  QuestionsListRequestsOutput,
-  QuestionsListInput,
-  QuestionsListOutput,
-  QuestionsReplyInput,
-  QuestionsReplyOutput,
-  QuestionsRejectInput,
-  QuestionsRejectOutput,
-  ReferencesListInput,
-  ReferencesListOutput,
-  ProjectCopiesCreateInput,
-  ProjectCopiesCreateOutput,
-  ProjectCopiesRemoveInput,
-  ProjectCopiesRemoveOutput,
-  ProjectCopiesRefreshInput,
-  ProjectCopiesRefreshOutput,
-} from "./types"
-import { ClientError } from "./client-error"
-
-export interface ClientOptions {
-  readonly baseUrl: string
-  readonly fetch?: typeof globalThis.fetch
-  readonly headers?: HeadersInit
-}
-
-export interface RequestOptions {
-  readonly signal?: AbortSignal
-  readonly headers?: HeadersInit
-}
-
-interface RequestDescriptor {
-  readonly method: string
-  readonly path: string
-  readonly query?: Record<string, unknown>
-  readonly headers?: Record<string, unknown>
-  readonly body?: unknown
-  readonly successStatus: number
-  readonly declaredStatuses: ReadonlyArray<number>
-  readonly empty: boolean
-}
-
-export function make(options: ClientOptions) {
-  const fetch = options.fetch ?? globalThis.fetch
-
-  const prepare = (descriptor: RequestDescriptor, requestOptions?: RequestOptions) => {
-    const url = new URL(descriptor.path, options.baseUrl)
-    for (const [key, value] of Object.entries(descriptor.query ?? {})) appendQuery(url.searchParams, key, value)
-    const headers = new Headers(options.headers)
-    for (const [key, value] of Object.entries(descriptor.headers ?? {})) {
-      if (value !== undefined && value !== null) headers.set(key, String(value))
-    }
-    for (const [key, value] of new Headers(requestOptions?.headers)) headers.set(key, value)
-    if (descriptor.body !== undefined && !headers.has("content-type")) headers.set("content-type", "application/json")
-    return {
-      url,
-      init: {
-        method: descriptor.method,
-        signal: requestOptions?.signal,
-        headers,
-        body: descriptor.body === undefined ? undefined : JSON.stringify(descriptor.body),
-      } satisfies RequestInit,
-    }
-  }
-
-  const execute = async (descriptor: RequestDescriptor, requestOptions?: RequestOptions) => {
-    try {
-      const prepared = prepare(descriptor, requestOptions)
-      return await fetch(prepared.url, prepared.init)
-    } catch (cause) {
-      throw new ClientError("Transport", { cause })
-    }
-  }
-
-  const responseError = async (response: Response, descriptor: RequestDescriptor): Promise<never> => {
-    if (descriptor.declaredStatuses.includes(response.status)) throw await json(response)
-    try {
-      await response.body?.cancel()
-    } catch {}
-    throw new ClientError("UnexpectedStatus", { cause: { status: response.status } })
-  }
-
-  const request = async <A>(descriptor: RequestDescriptor, requestOptions?: RequestOptions): Promise<A> => {
-    const response = await execute(descriptor, requestOptions)
-    if (response.status !== descriptor.successStatus) return responseError(response, descriptor)
-    if (descriptor.empty) {
-      try {
-        await response.body?.cancel()
-      } catch {}
-      return undefined as A
-    }
-    return (await json(response)) as A
-  }
-
-  const sse = <A>(descriptor: RequestDescriptor, requestOptions?: RequestOptions): AsyncIterable<A> => ({
-    async *[Symbol.asyncIterator]() {
-      const response = await execute(descriptor, requestOptions)
-      if (response.status !== descriptor.successStatus) await responseError(response, descriptor)
-      if (!isContentType(response, "text/event-stream")) {
-        try {
-          await response.body?.cancel()
-        } catch {}
-        throw new ClientError("UnsupportedContentType")
-      }
-      if (response.body === null) throw new ClientError("MalformedResponse")
-      const reader = response.body.getReader()
-      const decoder = new TextDecoder()
-      let buffer = ""
-      try {
-        while (true) {
-          let next
-          try {
-            next = await reader.read()
-          } catch (cause) {
-            throw new ClientError("Transport", { cause })
-          }
-          buffer += decoder.decode(next.value, { stream: !next.done })
-          if (buffer.length > 1_048_576) throw new ClientError("MalformedResponse")
-          const trailingCarriageReturn = !next.done && buffer.endsWith("\r")
-          if (trailingCarriageReturn) buffer = buffer.slice(0, -1)
-          buffer = buffer.replaceAll("\r\n", "\n").replaceAll("\r", "\n")
-          if (trailingCarriageReturn) buffer += "\r"
-          if (next.done && buffer !== "") buffer += "\n\n"
-          let boundary = buffer.indexOf("\n\n")
-          while (boundary >= 0) {
-            const block = buffer.slice(0, boundary)
-            buffer = buffer.slice(boundary + 2)
-            const data = block
-              .split("\n")
-              .flatMap((line) => (line.startsWith("data:") ? [line.slice(5).trimStart()] : []))
-              .join("\n")
-            if (data !== "") {
-              try {
-                yield JSON.parse(data) as A
-              } catch (cause) {
-                throw new ClientError("MalformedResponse", { cause })
-              }
-            }
-            boundary = buffer.indexOf("\n\n")
-          }
-          if (next.done) return
-        }
-      } finally {
-        try {
-          await reader.cancel()
-        } catch {}
-        reader.releaseLock()
-      }
-    },
-  })
-
-  return {
-    health: {
-      get: (requestOptions?: RequestOptions) =>
-        request<HealthGetOutput>(
-          { method: "GET", path: `/api/health`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
-          requestOptions,
-        ),
-    },
-    location: {
-      get: (input?: LocationGetInput, requestOptions?: RequestOptions) =>
-        request<LocationGetOutput>(
-          {
-            method: "GET",
-            path: `/api/location`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    agents: {
-      list: (input?: AgentsListInput, requestOptions?: RequestOptions) =>
-        request<AgentsListOutput>(
-          {
-            method: "GET",
-            path: `/api/agent`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    sessions: {
-      list: (input?: SessionsListInput, requestOptions?: RequestOptions) =>
-        request<SessionsListOutput>(
-          {
-            method: "GET",
-            path: `/api/session`,
-            query: {
-              workspace: input?.["workspace"],
-              limit: input?.["limit"],
-              order: input?.["order"],
-              search: input?.["search"],
-              directory: input?.["directory"],
-              project: input?.["project"],
-              subpath: input?.["subpath"],
-              cursor: input?.["cursor"],
-            },
-            successStatus: 200,
-            declaredStatuses: [400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      create: (input?: SessionsCreateInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsCreateOutput }>(
-          {
-            method: "POST",
-            path: `/api/session`,
-            body: {
-              id: input?.["id"],
-              agent: input?.["agent"],
-              model: input?.["model"],
-              location: input?.["location"],
-            },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      active: (requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsActiveOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/active`,
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      get: (input: SessionsGetInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsGetOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      switchAgent: (input: SessionsSwitchAgentInput, requestOptions?: RequestOptions) =>
-        request<SessionsSwitchAgentOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
-            body: { agent: input["agent"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      switchModel: (input: SessionsSwitchModelInput, requestOptions?: RequestOptions) =>
-        request<SessionsSwitchModelOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
-            body: { model: input["model"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      prompt: (input: SessionsPromptInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsPromptOutput }>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
-            body: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
-            successStatus: 200,
-            declaredStatuses: [409, 404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      compact: (input: SessionsCompactInput, requestOptions?: RequestOptions) =>
-        request<SessionsCompactOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
-            successStatus: 204,
-            declaredStatuses: [404, 503, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      wait: (input: SessionsWaitInput, requestOptions?: RequestOptions) =>
-        request<SessionsWaitOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/wait`,
-            successStatus: 204,
-            declaredStatuses: [404, 503, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      stage: (input: SessionsStageInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsStageOutput }>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
-            body: { messageID: input["messageID"], files: input["files"] },
-            successStatus: 200,
-            declaredStatuses: [404, 500, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      clear: (input: SessionsClearInput, requestOptions?: RequestOptions) =>
-        request<SessionsClearOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/clear`,
-            successStatus: 204,
-            declaredStatuses: [404, 500, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      commit: (input: SessionsCommitInput, requestOptions?: RequestOptions) =>
-        request<SessionsCommitOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      context: (input: SessionsContextInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsContextOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
-            successStatus: 200,
-            declaredStatuses: [404, 500, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      history: (input: SessionsHistoryInput, requestOptions?: RequestOptions) =>
-        request<SessionsHistoryOutput>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/history`,
-            query: { limit: input["limit"], after: input["after"] },
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      events: (input: SessionsEventsInput, requestOptions?: RequestOptions): AsyncIterable<SessionsEventsOutput> =>
-        sse<SessionsEventsOutput>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/event`,
-            query: { after: input["after"] },
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      interrupt: (input: SessionsInterruptInput, requestOptions?: RequestOptions) =>
-        request<SessionsInterruptOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      message: (input: SessionsMessageInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionsMessageOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-    },
-    messages: {
-      list: (input: MessagesListInput, requestOptions?: RequestOptions) =>
-        request<MessagesListOutput>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
-            query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
-            successStatus: 200,
-            declaredStatuses: [400, 404, 500, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    models: {
-      list: (input?: ModelsListInput, requestOptions?: RequestOptions) =>
-        request<ModelsListOutput>(
-          {
-            method: "GET",
-            path: `/api/model`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [503, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    providers: {
-      list: (input?: ProvidersListInput, requestOptions?: RequestOptions) =>
-        request<ProvidersListOutput>(
-          {
-            method: "GET",
-            path: `/api/provider`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [503, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      get: (input: ProvidersGetInput, requestOptions?: RequestOptions) =>
-        request<ProvidersGetOutput>(
-          {
-            method: "GET",
-            path: `/api/provider/${encodeURIComponent(input.providerID)}`,
-            query: { location: input["location"] },
-            successStatus: 200,
-            declaredStatuses: [404, 503, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    integrations: {
-      list: (input?: IntegrationsListInput, requestOptions?: RequestOptions) =>
-        request<IntegrationsListOutput>(
-          {
-            method: "GET",
-            path: `/api/integration`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      get: (input: IntegrationsGetInput, requestOptions?: RequestOptions) =>
-        request<IntegrationsGetOutput>(
-          {
-            method: "GET",
-            path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
-            query: { location: input["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      connectKey: (input: IntegrationsConnectKeyInput, requestOptions?: RequestOptions) =>
-        request<IntegrationsConnectKeyOutput>(
-          {
-            method: "POST",
-            path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
-            query: { location: input["location"] },
-            body: { key: input["key"], label: input["label"] },
-            successStatus: 204,
-            declaredStatuses: [400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      connectOauth: (input: IntegrationsConnectOauthInput, requestOptions?: RequestOptions) =>
-        request<IntegrationsConnectOauthOutput>(
-          {
-            method: "POST",
-            path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
-            query: { location: input["location"] },
-            body: { methodID: input["methodID"], inputs: input["inputs"], label: input["label"] },
-            successStatus: 200,
-            declaredStatuses: [400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      attemptStatus: (input: IntegrationsAttemptStatusInput, requestOptions?: RequestOptions) =>
-        request<IntegrationsAttemptStatusOutput>(
-          {
-            method: "GET",
-            path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
-            query: { location: input["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      attemptComplete: (input: IntegrationsAttemptCompleteInput, requestOptions?: RequestOptions) =>
-        request<IntegrationsAttemptCompleteOutput>(
-          {
-            method: "POST",
-            path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}/complete`,
-            query: { location: input["location"] },
-            body: { code: input["code"] },
-            successStatus: 204,
-            declaredStatuses: [400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      attemptCancel: (input: IntegrationsAttemptCancelInput, requestOptions?: RequestOptions) =>
-        request<IntegrationsAttemptCancelOutput>(
-          {
-            method: "DELETE",
-            path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
-            query: { location: input["location"] },
-            successStatus: 204,
-            declaredStatuses: [401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
-    credentials: {
-      update: (input: CredentialsUpdateInput, requestOptions?: RequestOptions) =>
-        request<CredentialsUpdateOutput>(
-          {
-            method: "PATCH",
-            path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
-            query: { location: input["location"] },
-            body: { label: input["label"] },
-            successStatus: 204,
-            declaredStatuses: [401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      remove: (input: CredentialsRemoveInput, requestOptions?: RequestOptions) =>
-        request<CredentialsRemoveOutput>(
-          {
-            method: "DELETE",
-            path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
-            query: { location: input["location"] },
-            successStatus: 204,
-            declaredStatuses: [401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
-    permissions: {
-      listRequests: (input?: PermissionsListRequestsInput, requestOptions?: RequestOptions) =>
-        request<PermissionsListRequestsOutput>(
-          {
-            method: "GET",
-            path: `/api/permission/request`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      listSaved: (input?: PermissionsListSavedInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: PermissionsListSavedOutput }>(
-          {
-            method: "GET",
-            path: `/api/permission/saved`,
-            query: { projectID: input?.["projectID"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      removeSaved: (input: PermissionsRemoveSavedInput, requestOptions?: RequestOptions) =>
-        request<PermissionsRemoveSavedOutput>(
-          {
-            method: "DELETE",
-            path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
-            successStatus: 204,
-            declaredStatuses: [401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      create: (input: PermissionsCreateInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: PermissionsCreateOutput }>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
-            body: {
-              id: input["id"],
-              action: input["action"],
-              resources: input["resources"],
-              save: input["save"],
-              metadata: input["metadata"],
-              source: input["source"],
-              agent: input["agent"],
-            },
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      list: (input: PermissionsListInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: PermissionsListOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      get: (input: PermissionsGetInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: PermissionsGetOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      reply: (input: PermissionsReplyInput, requestOptions?: RequestOptions) =>
-        request<PermissionsReplyOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
-            body: { reply: input["reply"], message: input["message"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
-    files: {
-      list: (input?: FilesListInput, requestOptions?: RequestOptions) =>
-        request<FilesListOutput>(
-          {
-            method: "GET",
-            path: `/api/fs/list`,
-            query: { location: input?.["location"], path: input?.["path"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      find: (input: FilesFindInput, requestOptions?: RequestOptions) =>
-        request<FilesFindOutput>(
-          {
-            method: "GET",
-            path: `/api/fs/find`,
-            query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    commands: {
-      list: (input?: CommandsListInput, requestOptions?: RequestOptions) =>
-        request<CommandsListOutput>(
-          {
-            method: "GET",
-            path: `/api/command`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    skills: {
-      list: (input?: SkillsListInput, requestOptions?: RequestOptions) =>
-        request<SkillsListOutput>(
-          {
-            method: "GET",
-            path: `/api/skill`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    events: {
-      subscribe: (requestOptions?: RequestOptions): AsyncIterable<EventsSubscribeOutput> =>
-        sse<EventsSubscribeOutput>(
-          { method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
-          requestOptions,
-        ),
-    },
-    ptys: {
-      list: (input?: PtysListInput, requestOptions?: RequestOptions) =>
-        request<PtysListOutput>(
-          {
-            method: "GET",
-            path: `/api/pty`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      create: (input?: PtysCreateInput, requestOptions?: RequestOptions) =>
-        request<PtysCreateOutput>(
-          {
-            method: "POST",
-            path: `/api/pty`,
-            query: { location: input?.["location"] },
-            body: {
-              command: input?.["command"],
-              args: input?.["args"],
-              cwd: input?.["cwd"],
-              title: input?.["title"],
-              env: input?.["env"],
-            },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      get: (input: PtysGetInput, requestOptions?: RequestOptions) =>
-        request<PtysGetOutput>(
-          {
-            method: "GET",
-            path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
-            query: { location: input["location"] },
-            successStatus: 200,
-            declaredStatuses: [404, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      update: (input: PtysUpdateInput, requestOptions?: RequestOptions) =>
-        request<PtysUpdateOutput>(
-          {
-            method: "PUT",
-            path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
-            query: { location: input["location"] },
-            body: { title: input["title"], size: input["size"] },
-            successStatus: 200,
-            declaredStatuses: [404, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      remove: (input: PtysRemoveInput, requestOptions?: RequestOptions) =>
-        request<PtysRemoveOutput>(
-          {
-            method: "DELETE",
-            path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
-            query: { location: input["location"] },
-            successStatus: 204,
-            declaredStatuses: [404, 401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
-    questions: {
-      listRequests: (input?: QuestionsListRequestsInput, requestOptions?: RequestOptions) =>
-        request<QuestionsListRequestsOutput>(
-          {
-            method: "GET",
-            path: `/api/question/request`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      list: (input: QuestionsListInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: QuestionsListOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/question`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      reply: (input: QuestionsReplyInput, requestOptions?: RequestOptions) =>
-        request<QuestionsReplyOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reply`,
-            body: { answers: input["answers"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      reject: (input: QuestionsRejectInput, requestOptions?: RequestOptions) =>
-        request<QuestionsRejectOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reject`,
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
-    references: {
-      list: (input?: ReferencesListInput, requestOptions?: RequestOptions) =>
-        request<ReferencesListOutput>(
-          {
-            method: "GET",
-            path: `/api/reference`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    projectCopies: {
-      create: (input: ProjectCopiesCreateInput, requestOptions?: RequestOptions) =>
-        request<ProjectCopiesCreateOutput>(
-          {
-            method: "POST",
-            path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
-            query: { location: input["location"] },
-            body: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
-            successStatus: 200,
-            declaredStatuses: [400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      remove: (input: ProjectCopiesRemoveInput, requestOptions?: RequestOptions) =>
-        request<ProjectCopiesRemoveOutput>(
-          {
-            method: "DELETE",
-            path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
-            query: { location: input["location"] },
-            body: { directory: input["directory"], force: input["force"] },
-            successStatus: 204,
-            declaredStatuses: [400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      refresh: (input: ProjectCopiesRefreshInput, requestOptions?: RequestOptions) =>
-        request<ProjectCopiesRefreshOutput>(
-          {
-            method: "POST",
-            path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy/refresh`,
-            query: { location: input["location"] },
-            successStatus: 204,
-            declaredStatuses: [400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
-  }
-}
-
-function appendQuery(params: URLSearchParams, key: string, value: unknown): void {
-  if (value === undefined || value === null) return
-  if (Array.isArray(value)) {
-    for (const item of value) appendQuery(params, key, item)
-    return
-  }
-  if (typeof value === "object") {
-    for (const [child, item] of Object.entries(value)) appendQuery(params, `${key}[${child}]`, item)
-    return
-  }
-  params.append(key, String(value))
-}
-
-async function json(response: Response): Promise<unknown> {
-  if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
-    try {
-      await response.body?.cancel()
-    } catch {}
-    throw new ClientError("UnsupportedContentType")
-  }
-  let text: string
-  try {
-    text = await response.text()
-  } catch (cause) {
-    throw new ClientError("Transport", { cause })
-  }
-  if (text === "") throw new ClientError("MalformedResponse")
-  try {
-    return JSON.parse(text)
-  } catch (cause) {
-    throw new ClientError("MalformedResponse", { cause })
-  }
-}
-
-function isContentType(response: Response, expected: string) {
-  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected
-}