@zyraxon-ai/client 19.0.3 → 19.0.5

package/dist/generated/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/generated/client.ts"],"names":[],"mappings":"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"}

package/dist/generated/client.js

@@ -0,0 +1,679 @@
+import { ClientError } from "./client-error";
+export function make(options) {
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prepare = (descriptor, 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),
+            },
+        };
+    };
+    const execute = async (descriptor, 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, descriptor) => {
+        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 (descriptor, requestOptions) => {
+        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;
+        }
+        return (await json(response));
+    };
+    const sse = (descriptor, requestOptions) => ({
+        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);
+                            }
+                            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) => request({ method: "GET", path: `/api/health`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
+        },
+        location: {
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/location`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        agents: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/agent`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        sessions: {
+            list: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                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) => request({
+                method: "GET",
+                path: `/api/session/active`,
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            switchAgent: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
+                body: { agent: input["agent"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            switchModel: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
+                body: { model: input["model"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            prompt: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
+                successStatus: 204,
+                declaredStatuses: [404, 503, 400, 401],
+                empty: true,
+            }, requestOptions),
+            wait: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/wait`,
+                successStatus: 204,
+                declaredStatuses: [404, 503, 400, 401],
+                empty: true,
+            }, requestOptions),
+            stage: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/clear`,
+                successStatus: 204,
+                declaredStatuses: [404, 500, 400, 401],
+                empty: true,
+            }, requestOptions),
+            commit: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            context: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                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, requestOptions) => sse({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/event`,
+                query: { after: input["after"] },
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions),
+            interrupt: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            message: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/model`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [503, 401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        providers: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/provider`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [503, 401, 400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/integration`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            connectKey: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            attemptComplete: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [401, 400],
+                empty: true,
+            }, requestOptions),
+        },
+        credentials: {
+            update: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [401, 400],
+                empty: true,
+            }, requestOptions),
+        },
+        permissions: {
+            listRequests: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/permission/request`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            listSaved: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/permission/saved`,
+                query: { projectID: input?.["projectID"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            removeSaved: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
+                successStatus: 204,
+                declaredStatuses: [401, 400],
+                empty: true,
+            }, requestOptions),
+            create: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            get: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/fs/list`,
+                query: { location: input?.["location"], path: input?.["path"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            find: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/command`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        skills: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/skill`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        events: {
+            subscribe: (requestOptions) => sse({ method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
+        },
+        ptys: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/pty`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            create: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [404, 401, 400],
+                empty: false,
+            }, requestOptions),
+            update: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [404, 401, 400],
+                empty: true,
+            }, requestOptions),
+        },
+        questions: {
+            listRequests: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/question/request`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/question`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            reply: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                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, requestOptions) => request({
+                method: "GET",
+                path: `/api/reference`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        projectCopies: {
+            create: (input, requestOptions) => request({
+                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, requestOptions) => request({
+                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, requestOptions) => request({
+                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, key, value) {
+    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) {
+    if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
+        try {
+            await response.body?.cancel();
+        }
+        catch { }
+        throw new ClientError("UnsupportedContentType");
+    }
+    let text;
+    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, expected) {
+    return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
+}
+//# sourceMappingURL=client.js.map