@codegraff/relay 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1088 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions$1 {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+type ClientOptions = {
+    baseUrl: 'https://yapper.codegraff.com/api/v1' | 'https://staging.yapper.codegraff.com/api/v1' | 'http://localhost:8787/api/v1' | (string & {});
+};
+/**
+ * RFC 7807-ish error.
+ */
+type Problem = {
+    type?: string;
+    title?: string;
+    status?: number;
+    detail?: string;
+    instance?: string;
+};
+type AgentKind = 'user' | 'service' | 'run';
+type AgentStatus = 'active' | 'revoked';
+type RoomStatus = 'active' | 'archived';
+type MessageKind = 'text' | 'tool_call' | 'task_ref' | 'summary';
+type Identity = {
+    agentId: string;
+    userId?: string;
+    orgId: string;
+    kind: AgentKind;
+    scopes: Array<string>;
+    machineId?: string;
+};
+type Agent = {
+    id: string;
+    orgId: string;
+    userId?: string;
+    name: string;
+    kind: AgentKind;
+    machineId?: string;
+    scopes: Array<string>;
+    status: AgentStatus;
+    lastSeen?: number;
+    createdAt: number;
+};
+type AgentCreate = {
+    name: string;
+    kind?: AgentKind;
+    scopes: Array<string>;
+    machineId?: string;
+};
+type Token = {
+    /**
+     * Bearer JWT. Returned exactly once.
+     */
+    token: string;
+    expiresAt: number;
+};
+type AgentWithToken = {
+    agent: Agent;
+    token: Token;
+};
+type RoomBinding = {
+    kind: 'manual';
+} | {
+    kind: 'project';
+    repo: string;
+} | {
+    kind: 'branch';
+    repo: string;
+    branch: string;
+    base?: string;
+};
+type Outcome = {
+    commitSha?: string;
+    prNumber?: number;
+    prUrl?: string;
+    mergedAt?: number;
+    revertedAt?: number;
+    testsPassed?: boolean;
+    releaseTag?: string;
+    releaseUrl?: string;
+    releasedAt?: number;
+};
+type Room = {
+    id: string;
+    orgId: string;
+    name: string;
+    topic?: string;
+    binding: RoomBinding;
+    envBucket?: string;
+    parentRoomId?: string;
+    status: RoomStatus;
+    coordinatorAgentId?: string;
+    memberAgentIds?: Array<string>;
+    latestSeq: number;
+    outcome?: Outcome;
+    createdAt: number;
+};
+type RoomBootstrap = {
+    room: Room;
+    latestSummary?: {
+        content?: string;
+        uptoSeq?: number;
+    };
+    recent: Array<Message>;
+    cursor: number;
+};
+/**
+ * Cheap filters used by discover.ambient/ask. Fields are optional —
+ * whatever the caller can produce. Indexed alongside the message.
+ *
+ */
+type Fingerprint = {
+    envHash?: string;
+    toolCallSignature?: string;
+    errorSig?: string;
+    filePaths?: Array<string>;
+    taskIntent?: string;
+};
+type Message = {
+    id: string;
+    roomId: string;
+    seq: number;
+    authorAgentId: string;
+    kind: MessageKind;
+    content: string;
+    refs?: Array<string>;
+    fingerprint?: Fingerprint;
+    createdAt: number;
+};
+type MessagePage = {
+    messages: Array<Message>;
+    nextCursor: number;
+};
+type WaitResult = {
+    messages: Array<Message>;
+    nextCursor: number;
+    timedOut: boolean;
+};
+type Memory = {
+    id: string;
+    orgId: string;
+    scope: 'agent' | 'room' | 'team' | 'org';
+    scopeId: string;
+    kind: string;
+    content: string;
+    tags?: Array<string>;
+    createdBy: string;
+    ttl?: number;
+    createdAt: number;
+};
+type MemoryCreate = {
+    scope: 'agent' | 'room' | 'team' | 'org';
+    scopeId: string;
+    kind: string;
+    content: string;
+    tags?: Array<string>;
+    ttl?: number;
+};
+type MemorySearch = {
+    scope?: 'agent' | 'room' | 'team' | 'org';
+    scopeId?: string;
+    envBucket?: string;
+    query: string;
+    k?: number;
+};
+type MemoryHit = {
+    memory: Memory;
+    score: number;
+};
+type Task = {
+    id: string;
+    orgId: string;
+    roomId?: string;
+    spec: string;
+    targetScope: string;
+    status: 'open' | 'claimed' | 'complete' | 'failed';
+    claimedBy?: string;
+    result?: string;
+    parentTaskId?: string;
+    createdAt: number;
+};
+type AmbientQuery = {
+    envBucket: string;
+    taskIntent?: string;
+    filePaths?: Array<string>;
+    k?: number;
+};
+type AskQuery = {
+    errorSig?: string;
+    toolCallSignature?: string;
+    recentTrajectory?: Array<{
+        [key: string]: unknown;
+    }>;
+    envBucket?: string;
+    k?: number;
+};
+/**
+ * Verified prior resolution returned by discover.ambient/ask. Capped at
+ * ~400 tokens combined per page so the agent can fold these in without
+ * bloating its context.
+ *
+ */
+type Resolution = {
+    captureId: string;
+    summary: string;
+    diff?: string;
+    verification?: {
+        replayStatus?: 'clean_replay_passed' | 'replay_diverged' | 'unreplayable' | 'unverified';
+        testOutcome?: 'pass' | 'fail' | 'none';
+        mergeStatus?: 'merged' | 'merged_then_reverted' | 'abandoned' | 'unknown';
+        humanSignal?: 'applied_clean' | 'edited_after' | 'rewritten' | 'none';
+        inProduction?: boolean;
+    };
+    score: number;
+    provenance?: {
+        agentId?: string;
+        repo?: string;
+        branch?: string;
+        commitSha?: string;
+        releaseTag?: string;
+    };
+};
+type ResolutionPage = {
+    resolutions: Array<Resolution>;
+};
+type IdentityWhoamiData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/identity/whoami';
+};
+type IdentityWhoamiErrors = {
+    /**
+     * Missing or invalid Bearer token.
+     */
+    401: Problem;
+};
+type IdentityWhoamiError = IdentityWhoamiErrors[keyof IdentityWhoamiErrors];
+type IdentityWhoamiResponses = {
+    /**
+     * Identity context
+     */
+    200: Identity;
+};
+type IdentityWhoamiResponse = IdentityWhoamiResponses[keyof IdentityWhoamiResponses];
+type ListAgentsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        status?: AgentStatus;
+        kind?: AgentKind;
+    };
+    url: '/agents';
+};
+type ListAgentsResponses = {
+    /**
+     * Agents
+     */
+    200: {
+        agents: Array<Agent>;
+    };
+};
+type ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];
+type CreateAgentData = {
+    body: AgentCreate;
+    path?: never;
+    query?: never;
+    url: '/agents';
+};
+type CreateAgentResponses = {
+    /**
+     * Created agent + bearer token (returned exactly once).
+     */
+    201: AgentWithToken;
+};
+type CreateAgentResponse = CreateAgentResponses[keyof CreateAgentResponses];
+type RevokeAgentData = {
+    body?: never;
+    path: {
+        agentId: string;
+    };
+    query?: never;
+    url: '/agents/{agentId}';
+};
+type RevokeAgentResponses = {
+    /**
+     * Revoked
+     */
+    204: void;
+};
+type RevokeAgentResponse = RevokeAgentResponses[keyof RevokeAgentResponses];
+type MintRunTokenData = {
+    body: {
+        ttlHours?: number;
+        scopes: Array<string>;
+    };
+    path: {
+        agentId: string;
+    };
+    query?: never;
+    url: '/agents/{agentId}/run-tokens';
+};
+type MintRunTokenResponses = {
+    /**
+     * Token
+     */
+    201: Token;
+};
+type MintRunTokenResponse = MintRunTokenResponses[keyof MintRunTokenResponses];
+type CreateServiceTokenData = {
+    body: {
+        /**
+         * Display name (e.g. `cursor-bg-acme`)
+         */
+        name: string;
+        scopes: Array<string>;
+        machineId?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/service-tokens';
+};
+type CreateServiceTokenResponses = {
+    /**
+     * Service agent + token (token returned exactly once).
+     */
+    201: AgentWithToken;
+};
+type CreateServiceTokenResponse = CreateServiceTokenResponses[keyof CreateServiceTokenResponses];
+type ListRoomsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        status?: RoomStatus;
+        repo?: string;
+        branch?: string;
+        releaseTag?: string;
+    };
+    url: '/rooms';
+};
+type ListRoomsResponses = {
+    /**
+     * Rooms
+     */
+    200: {
+        rooms: Array<Room>;
+    };
+};
+type ListRoomsResponse = ListRoomsResponses[keyof ListRoomsResponses];
+type CreateRoomData = {
+    body: {
+        name: string;
+        topic?: string;
+        memberAgentIds?: Array<string>;
+    };
+    path?: never;
+    query?: never;
+    url: '/rooms';
+};
+type CreateRoomResponses = {
+    /**
+     * Created
+     */
+    201: Room;
+};
+type CreateRoomResponse = CreateRoomResponses[keyof CreateRoomResponses];
+type RoomForBranchData = {
+    body: {
+        repo: string;
+        branch: string;
+        base?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/rooms/branch';
+};
+type RoomForBranchResponses = {
+    /**
+     * Existing or freshly created
+     */
+    200: Room;
+};
+type RoomForBranchResponse = RoomForBranchResponses[keyof RoomForBranchResponses];
+type BootstrapRoomData = {
+    body?: never;
+    path: {
+        roomId: string;
+    };
+    query?: never;
+    url: '/rooms/{roomId}/bootstrap';
+};
+type BootstrapRoomResponses = {
+    /**
+     * Bootstrap payload
+     */
+    200: RoomBootstrap;
+};
+type BootstrapRoomResponse = BootstrapRoomResponses[keyof BootstrapRoomResponses];
+type ReadMessagesData = {
+    body?: never;
+    path: {
+        roomId: string;
+    };
+    query: {
+        since: number;
+        limit?: number;
+    };
+    url: '/rooms/{roomId}/messages';
+};
+type ReadMessagesResponses = {
+    /**
+     * Messages
+     */
+    200: MessagePage;
+};
+type ReadMessagesResponse = ReadMessagesResponses[keyof ReadMessagesResponses];
+type PostMessageData = {
+    body: {
+        content: string;
+        kind?: MessageKind;
+        refs?: Array<string>;
+        fingerprint?: Fingerprint;
+    };
+    path: {
+        roomId: string;
+    };
+    query?: never;
+    url: '/rooms/{roomId}/messages';
+};
+type PostMessageResponses = {
+    /**
+     * Posted
+     */
+    201: Message;
+};
+type PostMessageResponse = PostMessageResponses[keyof PostMessageResponses];
+type WaitForMessagesData = {
+    body?: never;
+    path: {
+        roomId: string;
+    };
+    query: {
+        since: number;
+        timeoutMs?: number;
+    };
+    url: '/rooms/{roomId}/wait';
+};
+type WaitForMessagesResponses = {
+    /**
+     * Wait result
+     */
+    200: WaitResult;
+};
+type WaitForMessagesResponse = WaitForMessagesResponses[keyof WaitForMessagesResponses];
+type DeclareRoomDoneData = {
+    body: {
+        reason: string;
+        outcome?: Outcome;
+    };
+    path: {
+        roomId: string;
+    };
+    query?: never;
+    url: '/rooms/{roomId}/declare-done';
+};
+type DeclareRoomDoneResponses = {
+    /**
+     * OK
+     */
+    200: unknown;
+};
+type DeclareRoomBlockedData = {
+    body: {
+        reason: string;
+        needsHuman?: boolean;
+    };
+    path: {
+        roomId: string;
+    };
+    query?: never;
+    url: '/rooms/{roomId}/declare-blocked';
+};
+type DeclareRoomBlockedResponses = {
+    /**
+     * OK
+     */
+    200: unknown;
+};
+type GetRoomStateData = {
+    body?: never;
+    path: {
+        roomId: string;
+    };
+    query?: never;
+    url: '/rooms/{roomId}/state';
+};
+type GetRoomStateResponses = {
+    /**
+     * State
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+type GetRoomStateResponse = GetRoomStateResponses[keyof GetRoomStateResponses];
+type PatchRoomStateData = {
+    body: {
+        [key: string]: unknown;
+    };
+    path: {
+        roomId: string;
+    };
+    query?: never;
+    url: '/rooms/{roomId}/state';
+};
+type PatchRoomStateResponses = {
+    /**
+     * Updated state
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+type PatchRoomStateResponse = PatchRoomStateResponses[keyof PatchRoomStateResponses];
+type SearchMemoryData = {
+    body: MemorySearch;
+    path?: never;
+    query?: never;
+    url: '/memory/search';
+};
+type SearchMemoryResponses = {
+    /**
+     * Hits
+     */
+    200: {
+        hits: Array<MemoryHit>;
+    };
+};
+type SearchMemoryResponse = SearchMemoryResponses[keyof SearchMemoryResponses];
+type WriteMemoryData = {
+    body: MemoryCreate;
+    path?: never;
+    query?: never;
+    url: '/memory';
+};
+type WriteMemoryResponses = {
+    /**
+     * Written
+     */
+    201: Memory;
+};
+type WriteMemoryResponse = WriteMemoryResponses[keyof WriteMemoryResponses];
+type ForgetMemoryData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/memory/{id}';
+};
+type ForgetMemoryResponses = {
+    /**
+     * Forgotten
+     */
+    204: void;
+};
+type ForgetMemoryResponse = ForgetMemoryResponses[keyof ForgetMemoryResponses];
+type CreateTaskData = {
+    body: {
+        spec: string;
+        /**
+         * e.g. agent:abc123, team:eng, role:reviewer
+         */
+        targetScope: string;
+        roomId?: string;
+        parentTaskId?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/tasks';
+};
+type CreateTaskResponses = {
+    /**
+     * Created
+     */
+    201: Task;
+};
+type CreateTaskResponse = CreateTaskResponses[keyof CreateTaskResponses];
+type NextTaskData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/tasks/next';
+};
+type NextTaskResponses = {
+    /**
+     * Task or null
+     */
+    200: Task | null;
+};
+type NextTaskResponse = NextTaskResponses[keyof NextTaskResponses];
+type CompleteTaskData = {
+    body: {
+        result: string;
+        ok?: boolean;
+    };
+    path: {
+        taskId: string;
+    };
+    query?: never;
+    url: '/tasks/{taskId}/complete';
+};
+type CompleteTaskResponses = {
+    /**
+     * OK
+     */
+    200: unknown;
+};
+type DiscoverAmbientData = {
+    body: AmbientQuery;
+    path?: never;
+    query?: never;
+    url: '/discover/ambient';
+};
+type DiscoverAmbientResponses = {
+    /**
+     * Resolutions
+     */
+    200: ResolutionPage;
+};
+type DiscoverAmbientResponse = DiscoverAmbientResponses[keyof DiscoverAmbientResponses];
+type DiscoverAskData = {
+    body: AskQuery;
+    path?: never;
+    query?: never;
+    url: '/discover/ask';
+};
+type DiscoverAskResponses = {
+    /**
+     * Resolutions
+     */
+    200: ResolutionPage;
+};
+type DiscoverAskResponse = DiscoverAskResponses[keyof DiscoverAskResponses];
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+/**
+ * Return the calling agent's identity, scopes, and org.
+ */
+declare const identityWhoami: <ThrowOnError extends boolean = false>(options?: Options<IdentityWhoamiData, ThrowOnError>) => RequestResult<IdentityWhoamiResponses, IdentityWhoamiErrors, ThrowOnError, "fields">;
+/**
+ * List agents in the calling org.
+ */
+declare const listAgents: <ThrowOnError extends boolean = false>(options?: Options<ListAgentsData, ThrowOnError>) => RequestResult<ListAgentsResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Register a new agent under the calling user/service.
+ */
+declare const createAgent: <ThrowOnError extends boolean = false>(options: Options<CreateAgentData, ThrowOnError>) => RequestResult<CreateAgentResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Revoke an agent — its tokens stop working within ~60s.
+ */
+declare const revokeAgent: <ThrowOnError extends boolean = false>(options: Options<RevokeAgentData, ThrowOnError>) => RequestResult<RevokeAgentResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Mint a short-lived run-scoped token for a single agent run.
+ */
+declare const mintRunToken: <ThrowOnError extends boolean = false>(options: Options<MintRunTokenData, ThrowOnError>) => RequestResult<MintRunTokenResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Issue a service-derived agent token (no human user). Org admin only.
+ * Used for cloud agents, CI runs, and platform-managed background workers.
+ *
+ */
+declare const createServiceToken: <ThrowOnError extends boolean = false>(options: Options<CreateServiceTokenData, ThrowOnError>) => RequestResult<CreateServiceTokenResponses, unknown, ThrowOnError, "fields">;
+declare const listRooms: <ThrowOnError extends boolean = false>(options?: Options<ListRoomsData, ThrowOnError>) => RequestResult<ListRoomsResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Create a manual (non-branch) room.
+ */
+declare const createRoom: <ThrowOnError extends boolean = false>(options: Options<CreateRoomData, ThrowOnError>) => RequestResult<CreateRoomResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Find or create the branch-scoped room for (repo, branch).
+ */
+declare const roomForBranch: <ThrowOnError extends boolean = false>(options: Options<RoomForBranchData, ThrowOnError>) => RequestResult<RoomForBranchResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Join a room. Returns latest summary, recent messages, and a cursor.
+ */
+declare const bootstrapRoom: <ThrowOnError extends boolean = false>(options: Options<BootstrapRoomData, ThrowOnError>) => RequestResult<BootstrapRoomResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Read messages strictly past `since`.
+ */
+declare const readMessages: <ThrowOnError extends boolean = false>(options: Options<ReadMessagesData, ThrowOnError>) => RequestResult<ReadMessagesResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Post a message to the room.
+ */
+declare const postMessage: <ThrowOnError extends boolean = false>(options: Options<PostMessageData, ThrowOnError>) => RequestResult<PostMessageResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Long-poll. Resolves as soon as a message lands past `since`, or after
+ * `timeoutMs` (capped at 28s by the Worker). Cursor is the last seq
+ * observed. Caller owns the cursor across calls.
+ *
+ */
+declare const waitForMessages: <ThrowOnError extends boolean = false>(options: Options<WaitForMessagesData, ThrowOnError>) => RequestResult<WaitForMessagesResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Mark the room's task as complete with verification artifacts.
+ */
+declare const declareRoomDone: <ThrowOnError extends boolean = false>(options: Options<DeclareRoomDoneData, ThrowOnError>) => RequestResult<DeclareRoomDoneResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Mark the room as blocked, optionally requesting human attention.
+ */
+declare const declareRoomBlocked: <ThrowOnError extends boolean = false>(options: Options<DeclareRoomBlockedData, ThrowOnError>) => RequestResult<DeclareRoomBlockedResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Get the room's structured state blob (decisions, open questions, artifacts).
+ */
+declare const getRoomState: <ThrowOnError extends boolean = false>(options: Options<GetRoomStateData, ThrowOnError>) => RequestResult<GetRoomStateResponses, unknown, ThrowOnError, "fields">;
+/**
+ * JSON-merge-patch the room state.
+ */
+declare const patchRoomState: <ThrowOnError extends boolean = false>(options: Options<PatchRoomStateData, ThrowOnError>) => RequestResult<PatchRoomStateResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Filter-then-rank search over org memory. Either `scope` (with optional
+ * `scopeId`) or `envBucket` is required — pure vector queries are
+ * intentionally rejected.
+ *
+ */
+declare const searchMemory: <ThrowOnError extends boolean = false>(options: Options<SearchMemoryData, ThrowOnError>) => RequestResult<SearchMemoryResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Write a new memory record.
+ */
+declare const writeMemory: <ThrowOnError extends boolean = false>(options: Options<WriteMemoryData, ThrowOnError>) => RequestResult<WriteMemoryResponses, unknown, ThrowOnError, "fields">;
+declare const forgetMemory: <ThrowOnError extends boolean = false>(options: Options<ForgetMemoryData, ThrowOnError>) => RequestResult<ForgetMemoryResponses, unknown, ThrowOnError, "fields">;
+declare const createTask: <ThrowOnError extends boolean = false>(options: Options<CreateTaskData, ThrowOnError>) => RequestResult<CreateTaskResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Atomically claim the next task targeted at the calling agent's scopes.
+ */
+declare const nextTask: <ThrowOnError extends boolean = false>(options?: Options<NextTaskData, ThrowOnError>) => RequestResult<NextTaskResponses, unknown, ThrowOnError, "fields">;
+declare const completeTask: <ThrowOnError extends boolean = false>(options: Options<CompleteTaskData, ThrowOnError>) => RequestResult<CompleteTaskResponses, unknown, ThrowOnError, "fields">;
+/**
+ * Pre-retrieval at session start. Filters by env_hash + file paths +
+ * intent embedding before semantic ranking. Returns ≤3 resolutions.
+ *
+ */
+declare const discoverAmbient: <ThrowOnError extends boolean = false>(options: Options<DiscoverAmbientData, ThrowOnError>) => RequestResult<DiscoverAmbientResponses, unknown, ThrowOnError, "fields">;
+/**
+ * On-demand mid-trajectory retrieval. Filters by error_signature +
+ * tool_call_signature first, then ranks. Returns ≤3 resolutions.
+ *
+ */
+declare const discoverAsk: <ThrowOnError extends boolean = false>(options: Options<DiscoverAskData, ThrowOnError>) => RequestResult<DiscoverAskResponses, unknown, ThrowOnError, "fields">;
+
+/**
+ * relay SDK client. Hand-written wrapper around the generated OpenAPI
+ * client so we own the public surface — `./generated/` is regenerated
+ * by `bun run codegen` against `./openapi/relay.yaml`.
+ *
+ * @example
+ *   import { createClient, identityWhoami } from "@codegraff/relay";
+ *
+ *   const relay = createClient({
+ *     baseUrl: "https://relay.codegraff.com/api/v1",
+ *     token: process.env.RELAY_TOKEN,
+ *   });
+ *   const { data: me } = await identityWhoami({ client: relay });
+ */
+declare function createClient(opts: {
+    baseUrl: string;
+    token?: string;
+} & ClientOptions$1): Client;
+type RelayClient = ReturnType<typeof createClient>;
+
+export { type Agent, type AgentCreate, type AgentKind, type AgentStatus, type AgentWithToken, type AmbientQuery, type AskQuery, type BootstrapRoomData, type BootstrapRoomResponse, type BootstrapRoomResponses, type ClientOptions, type CompleteTaskData, type CompleteTaskResponses, type CreateAgentData, type CreateAgentResponse, type CreateAgentResponses, type CreateRoomData, type CreateRoomResponse, type CreateRoomResponses, type CreateServiceTokenData, type CreateServiceTokenResponse, type CreateServiceTokenResponses, type CreateTaskData, type CreateTaskResponse, type CreateTaskResponses, type DeclareRoomBlockedData, type DeclareRoomBlockedResponses, type DeclareRoomDoneData, type DeclareRoomDoneResponses, type DiscoverAmbientData, type DiscoverAmbientResponse, type DiscoverAmbientResponses, type DiscoverAskData, type DiscoverAskResponse, type DiscoverAskResponses, type Fingerprint, type ForgetMemoryData, type ForgetMemoryResponse, type ForgetMemoryResponses, type GetRoomStateData, type GetRoomStateResponse, type GetRoomStateResponses, type Identity, type IdentityWhoamiData, type IdentityWhoamiError, type IdentityWhoamiErrors, type IdentityWhoamiResponse, type IdentityWhoamiResponses, type ListAgentsData, type ListAgentsResponse, type ListAgentsResponses, type ListRoomsData, type ListRoomsResponse, type ListRoomsResponses, type Memory, type MemoryCreate, type MemoryHit, type MemorySearch, type Message, type MessageKind, type MessagePage, type MintRunTokenData, type MintRunTokenResponse, type MintRunTokenResponses, type NextTaskData, type NextTaskResponse, type NextTaskResponses, type Options, type Outcome, type PatchRoomStateData, type PatchRoomStateResponse, type PatchRoomStateResponses, type PostMessageData, type PostMessageResponse, type PostMessageResponses, type Problem, type ReadMessagesData, type ReadMessagesResponse, type ReadMessagesResponses, type RelayClient, type Resolution, type ResolutionPage, type RevokeAgentData, type RevokeAgentResponse, type RevokeAgentResponses, type Room, type RoomBinding, type RoomBootstrap, type RoomForBranchData, type RoomForBranchResponse, type RoomForBranchResponses, type RoomStatus, type SearchMemoryData, type SearchMemoryResponse, type SearchMemoryResponses, type Task, type Token, type WaitForMessagesData, type WaitForMessagesResponse, type WaitForMessagesResponses, type WaitResult, type WriteMemoryData, type WriteMemoryResponse, type WriteMemoryResponses, bootstrapRoom, completeTask, createAgent, createClient, createRoom, createServiceToken, createTask, declareRoomBlocked, declareRoomDone, discoverAmbient, discoverAsk, forgetMemory, getRoomState, identityWhoami, listAgents, listRooms, mintRunToken, nextTask, patchRoomState, postMessage, readMessages, revokeAgent, roomForBranch, searchMemory, waitForMessages, writeMemory };