@qwen-code/arena-agent 0.0.1

package/dist/sdk.js

@@ -0,0 +1,674 @@
+class AsyncQueue {
+    values = [];
+    pending = [];
+    ended = false;
+    failure;
+    push(value) {
+        if (this.ended)
+            return;
+        const pending = this.pending.shift();
+        if (pending) {
+            pending.resolve({ value, done: false });
+        }
+        else {
+            this.values.push(value);
+        }
+    }
+    close(error) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.failure = error;
+        for (const pending of this.pending.splice(0)) {
+            if (error)
+                pending.reject(error);
+            else
+                pending.resolve({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = this.values.shift();
+                if (value !== undefined)
+                    return { value, done: false };
+                if (this.ended) {
+                    if (this.failure)
+                        throw this.failure;
+                    return { value: undefined, done: true };
+                }
+                return new Promise((resolve, reject) => {
+                    this.pending.push({ resolve, reject });
+                });
+            },
+        };
+    }
+}
+export class ArenaApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "ArenaApiError";
+    }
+}
+function withoutTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function abortError() {
+    const error = new Error("operation cancelled");
+    error.name = "AbortError";
+    return error;
+}
+function runtimeFetch() {
+    if (typeof globalThis.fetch !== "function") {
+        throw new Error("Arena SDK requires a Fetch API implementation");
+    }
+    return globalThis.fetch.bind(globalThis);
+}
+function runtimeOriginHost() {
+    return typeof globalThis.location === "object"
+        ? globalThis.location.host
+        : "";
+}
+function randomId() {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+        return globalThis.crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (value) => {
+        const random = Math.floor(Math.random() * 16);
+        const nibble = value === "x" ? random : (random & 0x3) | 0x8;
+        return nibble.toString(16);
+    });
+}
+function dateInTimezone(timezone) {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).formatToParts(new Date());
+    const value = (type) => parts.find((part) => part.type === type)?.value || "";
+    return `${value("year")}-${value("month")}-${value("day")}`;
+}
+export function defaultArenaClientContext() {
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    return {
+        currentDate: dateInTimezone(timezone),
+        timezone,
+    };
+}
+async function responseBody(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function expectJson(response) {
+    const body = await responseBody(response);
+    if (!response.ok) {
+        const record = body && typeof body === "object"
+            ? body
+            : {};
+        throw new ArenaApiError(String(record.error || record.message || `Request failed (${response.status})`), response.status, body);
+    }
+    return body;
+}
+async function* sseFrames(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const parseFrame = (frame) => {
+        let id;
+        const data = [];
+        for (const line of frame.split("\n")) {
+            if (line.startsWith("id:"))
+                id = line.slice(3).trim();
+            if (line.startsWith("data:"))
+                data.push(line.slice(5).trimStart());
+        }
+        return data.length ? { ...(id ? { id } : {}), data: data.join("\n") } : undefined;
+    };
+    while (true) {
+        const { done, value } = await reader.read();
+        buffer += decoder.decode(value, { stream: !done }).replace(/\r\n/g, "\n");
+        let boundary = buffer.indexOf("\n\n");
+        while (boundary !== -1) {
+            const parsed = parseFrame(buffer.slice(0, boundary));
+            buffer = buffer.slice(boundary + 2);
+            if (parsed)
+                yield parsed;
+            boundary = buffer.indexOf("\n\n");
+        }
+        if (done)
+            break;
+    }
+    const parsed = parseFrame(buffer);
+    if (parsed)
+        yield parsed;
+}
+async function abortableDelay(milliseconds, signal) {
+    if (signal.aborted)
+        throw signal.reason || abortError();
+    await new Promise((resolve, reject) => {
+        const complete = () => {
+            signal.removeEventListener("abort", abort);
+            resolve();
+        };
+        const timeout = setTimeout(complete, milliseconds);
+        const abort = () => {
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", abort);
+            reject(signal.reason || abortError());
+        };
+        signal.addEventListener("abort", abort, { once: true });
+    });
+}
+function uploadValue(input) {
+    if (input instanceof Blob) {
+        return {
+            name: typeof input.name === "string"
+                ? String(input.name)
+                : "upload.bin",
+            body: input,
+            type: input.type || "application/octet-stream",
+        };
+    }
+    let body;
+    if (input.data instanceof Blob) {
+        body = input.data;
+    }
+    else if (input.data instanceof Uint8Array) {
+        const bytes = new Uint8Array(input.data.byteLength);
+        bytes.set(input.data);
+        body = new Blob([bytes.buffer], {
+            type: input.type || "application/octet-stream",
+        });
+    }
+    else {
+        body = new Blob([input.data], {
+            type: input.type || "application/octet-stream",
+        });
+    }
+    return {
+        name: input.name,
+        body,
+        type: input.type || body.type || "application/octet-stream",
+    };
+}
+function inputRequest(event) {
+    if (event.type !== "data-user-input-request")
+        return undefined;
+    const data = event.data && typeof event.data === "object"
+        ? event.data
+        : {};
+    if (typeof data.requestId !== "string" ||
+        typeof data.toolCallId !== "string" ||
+        !Array.isArray(data.questions)) {
+        return undefined;
+    }
+    return {
+        requestId: data.requestId,
+        toolCallId: data.toolCallId,
+        questions: data.questions,
+    };
+}
+export class ArenaClient {
+    sessions;
+    baseUrl;
+    fetcher;
+    requestCredentials;
+    onCredentials;
+    constructor(options = {}) {
+        this.baseUrl = withoutTrailingSlash(options.baseUrl || "");
+        this.fetcher = options.fetch || runtimeFetch();
+        this.requestCredentials = options.credentials || "same-origin";
+        this.onCredentials = options.onCredentials;
+        this.sessions = {
+            create: (createOptions) => this.createSession(createOptions),
+            resume: (credentials) => this.resumeSession(credentials),
+        };
+    }
+    async getConfig(signal) {
+        return expectJson(await this.request("/api/config", { signal }));
+    }
+    async createSession(options = {}) {
+        const defaults = defaultArenaClientContext();
+        const value = await expectJson(await this.request("/api/chat/trigger-session", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                currentDate: options.currentDate || defaults.currentDate,
+                timezone: options.timezone || defaults.timezone,
+                ...(options.location ? { location: options.location } : {}),
+            }),
+            signal: options.signal,
+        }));
+        return this.resumeSession({
+            sessionId: value.sessionId,
+            token: value.publicAccessToken,
+            expiresAt: value.expiresAt,
+        });
+    }
+    resumeSession(credentials) {
+        if (!credentials.sessionId || !credentials.token) {
+            throw new Error("resumeSession requires a sessionId and token");
+        }
+        this.onCredentials?.({ ...credentials });
+        return new ArenaSession(this, credentials);
+    }
+    async run(options, createOptions = {}) {
+        const session = await this.createSession(createOptions);
+        const result = await session.run(options);
+        return { ...result, session };
+    }
+    async request(pathname, init = {}) {
+        return this.fetcher(this.resolveUrl(pathname), {
+            ...init,
+            credentials: init.credentials || this.requestCredentials,
+        });
+    }
+    resolveUrl(pathname) {
+        return `${this.baseUrl}${pathname}`;
+    }
+    credentialsChanged(credentials) {
+        this.onCredentials?.({ ...credentials });
+    }
+}
+export class ArenaSession {
+    client;
+    id;
+    lastEventId;
+    tokenValue;
+    expiresAtValue;
+    constructor(client, credentials) {
+        this.client = client;
+        this.id = credentials.sessionId;
+        this.tokenValue = credentials.token;
+        this.expiresAtValue = credentials.expiresAt;
+        this.lastEventId = "0";
+    }
+    get credentials() {
+        return {
+            sessionId: this.id,
+            token: this.tokenValue,
+            ...(this.expiresAtValue ? { expiresAt: this.expiresAtValue } : {}),
+        };
+    }
+    setLastEventId(value) {
+        this.lastEventId = value || "0";
+    }
+    async refreshToken(signal) {
+        const value = await expectJson(await this.client.request("/api/chat/trigger-token", {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.tokenValue}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ sessionId: this.id }),
+            signal,
+        }));
+        this.tokenValue = value.token;
+        this.expiresAtValue = value.expiresAt;
+        const credentials = this.credentials;
+        this.client.credentialsChanged(credentials);
+        return credentials;
+    }
+    async getHistory(signal) {
+        const value = await expectJson(await this.authorizedRequest(`/api/chat/sessions/${this.id}/messages`, { signal }));
+        this.lastEventId = value.lastEventId || "0";
+        return {
+            messages: value.messages || [],
+            lastEventId: this.lastEventId,
+            activePrompt: value.activePrompt || null,
+        };
+    }
+    async upload(input, signal) {
+        const upload = uploadValue(input);
+        return expectJson(await this.authorizedRequest(`/api/chat/sessions/${this.id}/uploads`, {
+            method: "POST",
+            headers: {
+                "content-type": upload.type,
+                "x-file-name": encodeURIComponent(upload.name),
+            },
+            body: upload.body,
+            signal,
+        })).then((value) => value.attachment);
+    }
+    async send(options) {
+        const input = options.input?.trim() || "";
+        const uploaded = await Promise.all((options.files || []).map((file) => this.upload(file, options.signal)));
+        const attachments = [...(options.attachments || []), ...uploaded];
+        if (!input && !attachments.length) {
+            throw new Error("send requires input or at least one file");
+        }
+        const messageId = options.messageId || randomId();
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+        const parts = [
+            ...(input ? [{ type: "text", text: input }] : []),
+            ...attachments.map((attachment) => ({
+                type: "file",
+                path: attachment.path,
+            })),
+        ];
+        const value = await expectJson(await this.authorizedRequest(`/ai-proxy/realtime/v1/sessions/${this.id}/in/append`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-trigger-source": "sdk",
+                "x-part-id": randomId(),
+            },
+            body: JSON.stringify({
+                kind: "message",
+                payload: {
+                    message: {
+                        id: messageId,
+                        role: "user",
+                        parts,
+                    },
+                    chatId: this.id,
+                    trigger: "submit-message",
+                    messageId,
+                    metadata: {
+                        originHost: runtimeOriginHost(),
+                        timezone,
+                        submissionSource: "sdk",
+                        ...(options.metadata || {}),
+                    },
+                },
+            }),
+            signal: options.signal,
+        }));
+        return {
+            accepted: value.accepted,
+            sessionId: value.sessionId,
+            messageId: value.messageId,
+            attachments: value.attachments || attachments,
+        };
+    }
+    connect(options = {}) {
+        if (options.lastEventId !== undefined) {
+            this.lastEventId = options.lastEventId;
+        }
+        return new ArenaEventStream(this, options);
+    }
+    async *stream(options) {
+        const messageId = options.messageId || randomId();
+        const stream = this.connect({
+            reconnect: options.reconnect,
+            reconnectDelayMs: options.reconnectDelayMs,
+            signal: options.signal,
+        });
+        let started = false;
+        try {
+            await stream.ready;
+            await this.send({
+                input: options.input,
+                files: options.files,
+                attachments: options.attachments,
+                messageId,
+                metadata: options.metadata,
+                signal: options.signal,
+            });
+            for await (const event of stream) {
+                if (!started) {
+                    started =
+                        event.type === "start" && event.messageId === messageId;
+                    if (!started)
+                        continue;
+                }
+                const request = inputRequest(event);
+                const answers = request && options.onInputRequired
+                    ? Promise.resolve(options.onInputRequired(request, this))
+                    : undefined;
+                yield event;
+                if (request && answers) {
+                    try {
+                        await this.respondToInput(request.requestId, await answers, options.signal);
+                    }
+                    catch (error) {
+                        await this.cancel().catch(() => undefined);
+                        throw error;
+                    }
+                }
+                if (event.type === "trigger:turn-complete")
+                    break;
+            }
+        }
+        finally {
+            stream.close();
+            if (options.signal?.aborted && options.cancelOnAbort !== false) {
+                await this.cancel().catch(() => undefined);
+            }
+        }
+    }
+    async run(options) {
+        const events = [];
+        const files = new Map();
+        let text = "";
+        let reasoning = "";
+        let messages = [];
+        let status = "unknown";
+        let error;
+        for await (const event of this.stream(options)) {
+            events.push(event);
+            if (event.type === "text-delta")
+                text += String(event.delta || "");
+            if (event.type === "reasoning-delta") {
+                reasoning += String(event.delta || "");
+            }
+            if (event.type === "data-messages") {
+                const data = event.data && typeof event.data === "object"
+                    ? event.data
+                    : {};
+                if (Array.isArray(data.messages))
+                    messages = data.messages;
+            }
+            if (["data-workspace", "data-present-file"].includes(event.type)) {
+                const data = event.data && typeof event.data === "object"
+                    ? event.data
+                    : {};
+                const path = typeof data.path === "string" ? data.path : "";
+                if (path)
+                    files.set(path, data);
+            }
+            if (event.type === "error") {
+                error = String(event.errorText || "Agent error");
+            }
+            if (event.type === "trigger:turn-complete") {
+                status = event.status === "success" ? "success" : "error";
+                if (event.error)
+                    error = String(event.error);
+            }
+        }
+        return {
+            status,
+            text,
+            reasoning,
+            messages,
+            files: [...files.values()],
+            events,
+            ...(error ? { error } : {}),
+        };
+    }
+    async respondToInput(requestId, answers, signal) {
+        await expectJson(await this.authorizedRequest(`/api/chat/sessions/${this.id}/input-response`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ requestId, answers }),
+            signal,
+        }));
+    }
+    async cancel(signal) {
+        const value = await expectJson(await this.authorizedRequest(`/api/chat/sessions/${this.id}/cancel`, { method: "POST", signal }));
+        return value.cancelled === true;
+    }
+    workspaceUrl(filePath) {
+        return this.client.resolveUrl(this.workspacePath(filePath));
+    }
+    async download(filePath, signal) {
+        const response = await this.authorizedRequest(this.workspacePath(filePath), { signal });
+        if (!response.ok)
+            await expectJson(response);
+        return response.blob();
+    }
+    workspacePath(filePath) {
+        const encoded = filePath
+            .replace(/^\/home\/user\/?/, "")
+            .split("/")
+            .map(encodeURIComponent)
+            .join("/");
+        return `/api/chat/sessions/${this.id}/workspace/${encoded}`;
+    }
+    async openEventResponse(signal) {
+        const response = await this.authorizedRequest(`/ai-proxy/realtime/v1/sessions/${this.id}/out`, {
+            headers: {
+                accept: "text/event-stream",
+                "last-event-id": this.lastEventId,
+            },
+            signal,
+        });
+        if (!response.ok)
+            await expectJson(response);
+        if (!response.body) {
+            throw new Error("Arena event stream returned no response body");
+        }
+        return response;
+    }
+    async authorizedRequest(pathname, init = {}, retry = true) {
+        const headers = new Headers(init.headers);
+        headers.set("authorization", `Bearer ${this.tokenValue}`);
+        const response = await this.client.request(pathname, {
+            ...init,
+            headers,
+        });
+        if (response.status === 401 && retry) {
+            await response.body?.cancel().catch(() => undefined);
+            await this.refreshToken(init.signal || undefined);
+            return this.authorizedRequest(pathname, init, false);
+        }
+        return response;
+    }
+}
+export class ArenaEventStream {
+    session;
+    options;
+    ready;
+    closed;
+    controller = new AbortController();
+    events = new AsyncQueue();
+    reconnect;
+    reconnectDelayMs;
+    readyResolve;
+    readyReject;
+    closedResolve;
+    readySettled = false;
+    connectedOnce = false;
+    intentionalClose = false;
+    removeExternalAbort;
+    constructor(session, options) {
+        this.session = session;
+        this.options = options;
+        this.reconnect = options.reconnect !== false;
+        this.reconnectDelayMs = options.reconnectDelayMs ?? 800;
+        this.ready = new Promise((resolve, reject) => {
+            this.readyResolve = resolve;
+            this.readyReject = reject;
+        });
+        this.closed = new Promise((resolve) => {
+            this.closedResolve = resolve;
+        });
+        if (options.signal) {
+            const abort = () => this.close();
+            options.signal.addEventListener("abort", abort, { once: true });
+            this.removeExternalAbort = () => options.signal?.removeEventListener("abort", abort);
+            if (options.signal.aborted)
+                this.close();
+        }
+        queueMicrotask(() => void this.pump());
+    }
+    close() {
+        if (this.intentionalClose)
+            return;
+        this.intentionalClose = true;
+        this.controller.abort(abortError());
+    }
+    [Symbol.asyncIterator]() {
+        return this.events[Symbol.asyncIterator]();
+    }
+    state(value) {
+        this.options.onStateChange?.(value);
+    }
+    async pump() {
+        try {
+            while (!this.controller.signal.aborted) {
+                this.state(this.connectedOnce ? "reconnecting" : "connecting");
+                try {
+                    const response = await this.session.openEventResponse(this.controller.signal);
+                    if (!this.connectedOnce) {
+                        this.connectedOnce = true;
+                        this.readySettled = true;
+                        this.readyResolve();
+                    }
+                    this.state("connected");
+                    for await (const frame of sseFrames(response.body)) {
+                        if (frame.id)
+                            this.session.lastEventId = frame.id;
+                        const value = JSON.parse(frame.data);
+                        const event = {
+                            ...value,
+                            ...(frame.id ? { eventId: frame.id } : {}),
+                        };
+                        this.events.push(event);
+                        this.options.onEvent?.(event);
+                    }
+                    if (!this.reconnect)
+                        break;
+                }
+                catch (error) {
+                    if (this.controller.signal.aborted)
+                        break;
+                    this.options.onError?.(error instanceof Error ? error : new Error(String(error)));
+                    if (!this.reconnect) {
+                        if (!this.readySettled) {
+                            this.readySettled = true;
+                            this.readyReject(error);
+                        }
+                        this.events.close(error);
+                        return;
+                    }
+                }
+                await abortableDelay(this.reconnectDelayMs, this.controller.signal).catch(() => undefined);
+            }
+            this.events.close();
+        }
+        catch (error) {
+            if (this.controller.signal.aborted)
+                this.events.close();
+            else {
+                this.options.onError?.(new Error(errorMessage(error)));
+                this.events.close(error);
+            }
+        }
+        finally {
+            if (!this.readySettled) {
+                this.readySettled = true;
+                this.readyReject(this.controller.signal.reason || new Error("event stream closed"));
+            }
+            this.removeExternalAbort?.();
+            this.state("closed");
+            this.closedResolve();
+        }
+    }
+}
+//# sourceMappingURL=sdk.js.map