weave-typescript 0.12.0 → 0.14.0

package/dist/weaveapi/atc/v1/service.pb.d.ts

@@ -0,0 +1,339 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Observable } from "rxjs";
+import { Event } from "./event.pb";
+import { MailboxMessage } from "./message.pb";
+import { Process, ProcessTypeSummary } from "./process.pb";
+import { Run, RunConfig, RunStatus } from "./run.pb";
+export declare const protobufPackage = "weaveapi.atc.v1";
+export interface CreateRunRequest {
+    /** The prompt or task description for the run. */
+    prompt: string;
+    /** Optional configuration for the run. */
+    config: RunConfig | undefined;
+}
+export interface CreateRunResponse {
+    run: Run | undefined;
+}
+export interface SendMessageRequest {
+    runId: string;
+    /** Target process ID within the run. */
+    toProcessId: string;
+    /** Message type identifier. */
+    type: string;
+    /** Message payload as raw bytes (JSON-encoded). */
+    payload: Uint8Array;
+    /** Whether this message is an interrupt. */
+    interrupt: boolean;
+}
+export interface SendMessageResponse {
+    message: MailboxMessage | undefined;
+}
+export interface CancelRunRequest {
+    runId: string;
+}
+export interface CancelRunResponse {
+    run: Run | undefined;
+}
+export interface WaitRunRequest {
+    runId: string;
+}
+export interface WaitRunResponse {
+    status: RunStatus;
+    run: Run | undefined;
+}
+export interface GetRunStatusRequest {
+    runId: string;
+}
+export interface GetRunStatusResponse {
+    run: Run | undefined;
+    totalProcesses: number;
+    runningProcesses: number;
+    completedProcesses: number;
+    failedProcesses: number;
+}
+export interface ListRunsRequest {
+    pageSize: number;
+    pageToken: string;
+    /** Filter by run status. */
+    statusFilter: RunStatus;
+    /** Filter by runs created at or after this timestamp. */
+    createdAfter: Date | undefined;
+    /** Filter by runs created at or before this timestamp. */
+    createdBefore: Date | undefined;
+}
+export interface ListRunsResponse {
+    runs: Run[];
+    nextPageToken: string;
+    totalCount: number;
+}
+export interface GetRunRequest {
+    runId: string;
+}
+export interface GetRunResponse {
+    run: Run | undefined;
+    processes: Process[];
+}
+export interface ListEventsRequest {
+    runId: string;
+    pageSize: number;
+    pageToken: string;
+    /** Only return events with sequence greater than this value. */
+    afterSequence: number;
+    /** Filter by event type. */
+    eventTypeFilter: string;
+}
+export interface ListEventsResponse {
+    events: Event[];
+    nextPageToken: string;
+}
+export interface ListProcessTypesRequest {
+    pageSize: number;
+    pageToken: string;
+}
+export interface ListProcessTypesResponse {
+    processTypes: ProcessTypeSummary[];
+    nextPageToken: string;
+}
+export declare const CreateRunRequest: MessageFns<CreateRunRequest>;
+export declare const CreateRunResponse: MessageFns<CreateRunResponse>;
+export declare const SendMessageRequest: MessageFns<SendMessageRequest>;
+export declare const SendMessageResponse: MessageFns<SendMessageResponse>;
+export declare const CancelRunRequest: MessageFns<CancelRunRequest>;
+export declare const CancelRunResponse: MessageFns<CancelRunResponse>;
+export declare const WaitRunRequest: MessageFns<WaitRunRequest>;
+export declare const WaitRunResponse: MessageFns<WaitRunResponse>;
+export declare const GetRunStatusRequest: MessageFns<GetRunStatusRequest>;
+export declare const GetRunStatusResponse: MessageFns<GetRunStatusResponse>;
+export declare const ListRunsRequest: MessageFns<ListRunsRequest>;
+export declare const ListRunsResponse: MessageFns<ListRunsResponse>;
+export declare const GetRunRequest: MessageFns<GetRunRequest>;
+export declare const GetRunResponse: MessageFns<GetRunResponse>;
+export declare const ListEventsRequest: MessageFns<ListEventsRequest>;
+export declare const ListEventsResponse: MessageFns<ListEventsResponse>;
+export declare const ListProcessTypesRequest: MessageFns<ListProcessTypesRequest>;
+export declare const ListProcessTypesResponse: MessageFns<ListProcessTypesResponse>;
+/**
+ * ATCService is the primary API surface for running agents through the
+ * Agent Traffic Controller runtime.
+ */
+export interface ATCService {
+    /** CreateRun kicks off a new run by spawning a supervisor with a prompt. */
+    CreateRun(request: CreateRunRequest): Promise<CreateRunResponse>;
+    /** SendMessage sends a message to a running process's mailbox. */
+    SendMessage(request: SendMessageRequest): Promise<SendMessageResponse>;
+    /** CancelRun requests cancellation of a run. */
+    CancelRun(request: CancelRunRequest): Promise<CancelRunResponse>;
+    /** WaitRun streams status updates until the run reaches a terminal state. */
+    WaitRun(request: WaitRunRequest): Observable<WaitRunResponse>;
+    /** GetRunStatus returns the point-in-time status of a run. */
+    GetRunStatus(request: GetRunStatusRequest): Promise<GetRunStatusResponse>;
+}
+export declare const ATCServiceServiceName = "weaveapi.atc.v1.ATCService";
+export declare class ATCServiceClientImpl implements ATCService {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc, opts?: {
+        service?: string;
+    });
+    CreateRun(request: CreateRunRequest): Promise<CreateRunResponse>;
+    SendMessage(request: SendMessageRequest): Promise<SendMessageResponse>;
+    CancelRun(request: CancelRunRequest): Promise<CancelRunResponse>;
+    WaitRun(request: WaitRunRequest): Observable<WaitRunResponse>;
+    GetRunStatus(request: GetRunStatusRequest): Promise<GetRunStatusResponse>;
+}
+/**
+ * ATCService is the primary API surface for running agents through the
+ * Agent Traffic Controller runtime.
+ */
+export type ATCServiceDefinition = typeof ATCServiceDefinition;
+export declare const ATCServiceDefinition: {
+    readonly name: "ATCService";
+    readonly fullName: "weaveapi.atc.v1.ATCService";
+    readonly methods: {
+        /** CreateRun kicks off a new run by spawning a supervisor with a prompt. */
+        readonly createRun: {
+            readonly name: "CreateRun";
+            readonly requestType: typeof CreateRunRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof CreateRunResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+        /** SendMessage sends a message to a running process's mailbox. */
+        readonly sendMessage: {
+            readonly name: "SendMessage";
+            readonly requestType: typeof SendMessageRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof SendMessageResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+        /** CancelRun requests cancellation of a run. */
+        readonly cancelRun: {
+            readonly name: "CancelRun";
+            readonly requestType: typeof CancelRunRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof CancelRunResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+        /** WaitRun streams status updates until the run reaches a terminal state. */
+        readonly waitRun: {
+            readonly name: "WaitRun";
+            readonly requestType: typeof WaitRunRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof WaitRunResponse;
+            readonly responseStream: true;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+        /** GetRunStatus returns the point-in-time status of a run. */
+        readonly getRunStatus: {
+            readonly name: "GetRunStatus";
+            readonly requestType: typeof GetRunStatusRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof GetRunStatusResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+    };
+};
+/**
+ * InspectionService provides observability and audit capabilities for
+ * the ATC runtime.
+ */
+export interface InspectionService {
+    /** ListRuns lists runs with optional filters. */
+    ListRuns(request: ListRunsRequest): Promise<ListRunsResponse>;
+    /**
+     * GetRun returns detailed information about a run including its
+     * processes, artifacts, and status.
+     */
+    GetRun(request: GetRunRequest): Promise<GetRunResponse>;
+    /** ListEvents queries the event log for a run. */
+    ListEvents(request: ListEventsRequest): Promise<ListEventsResponse>;
+    /** ListProcessTypes discovers registered process types. */
+    ListProcessTypes(request: ListProcessTypesRequest): Promise<ListProcessTypesResponse>;
+}
+export declare const InspectionServiceServiceName = "weaveapi.atc.v1.InspectionService";
+export declare class InspectionServiceClientImpl implements InspectionService {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc, opts?: {
+        service?: string;
+    });
+    ListRuns(request: ListRunsRequest): Promise<ListRunsResponse>;
+    GetRun(request: GetRunRequest): Promise<GetRunResponse>;
+    ListEvents(request: ListEventsRequest): Promise<ListEventsResponse>;
+    ListProcessTypes(request: ListProcessTypesRequest): Promise<ListProcessTypesResponse>;
+}
+/**
+ * InspectionService provides observability and audit capabilities for
+ * the ATC runtime.
+ */
+export type InspectionServiceDefinition = typeof InspectionServiceDefinition;
+export declare const InspectionServiceDefinition: {
+    readonly name: "InspectionService";
+    readonly fullName: "weaveapi.atc.v1.InspectionService";
+    readonly methods: {
+        /** ListRuns lists runs with optional filters. */
+        readonly listRuns: {
+            readonly name: "ListRuns";
+            readonly requestType: typeof ListRunsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ListRunsResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+        /**
+         * GetRun returns detailed information about a run including its
+         * processes, artifacts, and status.
+         */
+        readonly getRun: {
+            readonly name: "GetRun";
+            readonly requestType: typeof GetRunRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof GetRunResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+        /** ListEvents queries the event log for a run. */
+        readonly listEvents: {
+            readonly name: "ListEvents";
+            readonly requestType: typeof ListEventsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ListEventsResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+        /** ListProcessTypes discovers registered process types. */
+        readonly listProcessTypes: {
+            readonly name: "ListProcessTypes";
+            readonly requestType: typeof ListProcessTypesRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ListProcessTypesResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array];
+                };
+            };
+        };
+    };
+};
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array): Observable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Observable<Uint8Array>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};