@deepnoodle/mobius 0.0.21 → 0.0.23

package/dist/client.js

@@ -3,74 +3,24 @@ export { RateLimitError } from "./retry.js";
 export const DEFAULT_BASE_URL = "https://api.mobiusops.ai";
 export const DEFAULT_PROJECT = "default";
 export const DEFAULT_NAMESPACE = DEFAULT_PROJECT;
-export class LeaseLostError extends Error {
-    constructor(jobId) {
-        super(`lease lost for job ${jobId}`);
-        this.jobId = jobId;
-        this.name = "LeaseLostError";
-    }
-}
-/**
- * Thrown when the server returns HTTP 401 on a worker-loop request.
- * The credential has been revoked mid-execution; the process needs
- * to restart under a fresh credential. Distinct from
- * {@link LeaseLostError} (409 — lease reclaimed by scheduler) because
- * the remedy is operational, not workflow-level.
- */
 export class AuthRevokedError extends Error {
-    constructor(jobId) {
-        super(jobId
-            ? `mobius: credential revoked (job ${jobId})`
-            : "mobius: credential revoked");
-        this.jobId = jobId;
+    constructor() {
+        super("mobius: credential revoked");
         this.name = "AuthRevokedError";
     }
 }
-/**
- * Thrown when the server returns HTTP 409 with `worker_instance_conflict`
- * on a claim. Another live process has already registered this
- * `worker_instance_id` in the project under a different session token.
- * Surfaces from {@link Worker.run} as a hard error so the operator
- * notices the misconfiguration instead of the worker silently retrying —
- * fix by configuring a unique instance ID per process or by relying on
- * the SDK's auto-detection.
- */
-export class WorkerInstanceConflictError extends Error {
-    constructor(workerInstanceId, projectHandle, message) {
-        super(message ??
-            (workerInstanceId
-                ? `mobius: worker_instance_id ${JSON.stringify(workerInstanceId)} is already registered in project ${JSON.stringify(projectHandle)} by another live process; configure a unique instance ID per process or rely on auto-detection`
-                : "mobius: worker instance conflict"));
-        this.workerInstanceId = workerInstanceId;
-        this.projectHandle = projectHandle;
-        this.name = "WorkerInstanceConflictError";
-    }
-}
-/**
- * Thrown from {@link Client} construction when the API key or project
- * options are malformed (e.g. a project-pinned key whose handle prefix
- * doesn't match the server's handle regex, or a handle conflict
- * between `WithProjectHandle` and the handle embedded in the key).
- */
 export class ConfigError extends Error {
     constructor(message) {
         super(message);
         this.name = "ConfigError";
     }
 }
-// Mirrors the server-side handle regex (domain/validate.go) so the
-// extracted prefix is rejected here rather than as a 403 on first
-// request.
-const HANDLE_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-function extractHandleFromApiKey(apiKey) {
-    const slash = apiKey.indexOf("/");
-    if (slash < 0)
-        return null;
-    const handle = apiKey.slice(0, slash);
-    if (!HANDLE_RE.test(handle)) {
-        throw new ConfigError(`invalid project handle prefix in API key: ${JSON.stringify(handle)}`);
+export class LeaseLostError extends Error {
+    constructor(jobId) {
+        super(`lease lost for job ${jobId}`);
+        this.jobId = jobId;
+        this.name = "LeaseLostError";
     }
-    return handle;
 }
 export class PayloadTooLargeError extends Error {
     constructor(jobId) {
@@ -79,12 +29,6 @@ export class PayloadTooLargeError extends Error {
         this.name = "PayloadTooLargeError";
     }
 }
-/**
- * Legacy per-job rate-limit error raised by {@link Client.emitJobEvents}.
- * Subclass of {@link RateLimitError} so callers catching the newer,
- * transport-raised {@link RateLimitError} also catch this. New code
- * should prefer {@link RateLimitError}.
- */
 export class RateLimitedError extends RateLimitError {
     constructor(jobId, retryAfter) {
         super({
@@ -97,21 +41,34 @@ export class RateLimitedError extends RateLimitError {
         this.jobId = jobId;
     }
 }
-/**
- * Low-level Mobius runtime API client. Prefer {@link Worker} in worker.ts
- * rather than calling these methods directly.
- *
- * Request and response shapes mirror the OpenAPI spec exactly (snake_case).
- * A worker claims individual *jobs* — one action invocation on behalf of
- * a workflow run — and reports each job's result back via this client.
- */
+export class WorkerInstanceConflictError extends Error {
+    constructor(workerInstanceId, projectHandle, message) {
+        super(message ??
+            (workerInstanceId
+                ? `mobius: worker_instance_id ${JSON.stringify(workerInstanceId)} is already registered in project ${JSON.stringify(projectHandle)} by another live process`
+                : "mobius: worker instance conflict"));
+        this.workerInstanceId = workerInstanceId;
+        this.projectHandle = projectHandle;
+        this.name = "WorkerInstanceConflictError";
+    }
+}
+const HANDLE_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function extractHandleFromApiKey(apiKey) {
+    if (!apiKey.startsWith("mbx_") && !apiKey.startsWith("mbc_"))
+        return null;
+    const dot = apiKey.lastIndexOf(".");
+    if (dot < 0 || dot === apiKey.length - 1)
+        return null;
+    const handle = apiKey.slice(dot + 1);
+    if (!HANDLE_RE.test(handle)) {
+        throw new ConfigError(`invalid project handle suffix in API key: ${JSON.stringify(handle)}`);
+    }
+    return handle;
+}
 export class Client {
     constructor(opts) {
         this.baseURL = (opts.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
         const explicitProject = opts.project ?? opts.namespace;
-        // Project-pinned keys arrive as "<handle>/mbx_<secret>". Split the
-        // handle off and use it as the project; any explicit project option
-        // must either match or be the default sentinel.
         const handleInKey = extractHandleFromApiKey(opts.apiKey);
         if (handleInKey != null) {
             if (explicitProject != null &&
@@ -131,98 +88,109 @@ export class Client {
         this.timeoutMs = opts.timeoutMs ?? 60000;
         this.fetchFn = wrapFetchWithRetry((input, init) => globalThis.fetch(input, init), { maxRetries: opts.retry ?? DEFAULT_MAX_RETRIES });
     }
-    /**
-     * Long-poll for the next claimable job. Returns null when the poll
-     * window closes without a job being available.
-     */
-    async claimJob(req, signal) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/jobs/claim`, { method: "POST", body: req, signal });
-        if (resp.status === 204)
-            return null;
-        if (resp.status === 401)
-            throw new AuthRevokedError();
-        if (resp.status === 409) {
-            const text = await resp.text().catch(() => "");
-            // The backend wraps errors as {"error":{"code","message"}}.
-            let body = {};
-            try {
-                body = text ? JSON.parse(text) : {};
-            }
-            catch {
-                body = {};
-            }
-            if (body.error?.code === "worker_instance_conflict") {
-                throw new WorkerInstanceConflictError(req.worker_instance_id, this.project, body.error.message);
-            }
-            throw new Error(`mobius API POST /jobs/claim: HTTP 409: ${text || "(no body)"}`);
-        }
+    workerSocketURL() {
+        const url = new URL(this.baseURL);
+        if (url.protocol === "http:")
+            url.protocol = "ws:";
+        if (url.protocol === "https:")
+            url.protocol = "wss:";
+        url.pathname = `${url.pathname.replace(/\/$/, "")}/v1/projects/${encodeURIComponent(this.project)}/workers/socket`;
+        url.search = "";
+        return url.toString();
+    }
+    async listAutomations(opts = {}) {
+        const resp = await this.request(withQuery("/v1/projects/:project/automations", opts), {
+            method: "GET",
+        });
+        return (await resp.json());
+    }
+    async getAutomation(handle) {
+        const resp = await this.request(`/v1/projects/:project/automations/${encodeURIComponent(handle)}`, { method: "GET" });
+        return (await resp.json());
+    }
+    async createAutomation(opts) {
+        const body = removeUndefined({
+            name: opts.name,
+            handle: opts.handle,
+            description: opts.description,
+            default_agent_id: opts.default_agent_id,
+            default_inputs: opts.default_inputs,
+            settings: opts.settings,
+            tags: opts.tags,
+            triggers: opts.triggers,
+        });
+        const resp = await this.request("/v1/projects/:project/automations", {
+            method: "POST",
+            body,
+        });
         return (await resp.json());
     }
-    /** Refresh the lease on a claimed job. */
-    async heartbeatJob(jobId, req) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/jobs/${encodeURIComponent(jobId)}/heartbeat`, { method: "POST", body: req });
-        if (resp.status === 401)
-            throw new AuthRevokedError(jobId);
-        if (resp.status === 409)
-            throw new LeaseLostError(jobId);
+    async updateAutomation(handle, opts) {
+        const body = removeUndefined(opts);
+        const resp = await this.request(`/v1/projects/:project/automations/${encodeURIComponent(handle)}`, { method: "PATCH", body });
         return (await resp.json());
     }
-    /** Report the terminal outcome(s) of a claimed job. */
-    async reportJob(jobId, req) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/jobs/${encodeURIComponent(jobId)}/report`, { method: "POST", body: req });
-        if (resp.status === 401)
-            throw new AuthRevokedError(jobId);
-        if (resp.status === 409)
-            throw new LeaseLostError(jobId);
+    async deleteAutomation(handle) {
+        await this.request(`/v1/projects/:project/automations/${encodeURIComponent(handle)}`, { method: "DELETE" });
     }
-    async emitJobEvents(jobId, req) {
-        // 429 responses surface as RateLimitError (thrown from the retry
-        // transport below). 401/409/413 are non-retryable and handled here.
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/jobs/${encodeURIComponent(jobId)}/events`, { method: "POST", body: req });
-        if (resp.status === 401)
-            throw new AuthRevokedError(jobId);
-        if (resp.status === 409)
-            throw new LeaseLostError(jobId);
-        if (resp.status === 413)
-            throw new PayloadTooLargeError(jobId);
+    async listAutomationVersions(handle) {
+        const resp = await this.request(`/v1/projects/:project/automations/${encodeURIComponent(handle)}/versions`, { method: "GET" });
+        return (await resp.json());
     }
-    async emitJobEvent(jobId, req) {
-        await this.emitJobEvents(jobId, {
-            worker_instance_id: req.worker_instance_id,
-            lease_token: req.lease_token,
-            events: [{ type: req.type, payload: req.payload }],
+    async createAutomationVersion(handle, spec, opts = {}) {
+        const body = removeUndefined({
+            spec: spec,
+            compiled_plan: opts.compiled_plan,
         });
+        const resp = await this.request(`/v1/projects/:project/automations/${encodeURIComponent(handle)}/versions`, { method: "POST", body });
+        const version = (await resp.json());
+        if (opts.publish) {
+            await this.publishAutomationVersion(handle, version.version);
+        }
+        return version;
     }
-    async startRun(spec, opts = {}) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/runs`, { method: "POST", body: { mode: "inline", spec, ...opts } });
+    async publishAutomationVersion(handle, version) {
+        const resp = await this.request(`/v1/projects/:project/automations/${encodeURIComponent(handle)}/versions/${version}/publication`, { method: "POST" });
         return (await resp.json());
     }
-    async startWorkflowRun(workflowId, opts = {}) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/workflows/${encodeURIComponent(workflowId)}/runs`, { method: "POST", body: opts });
+    async startRun(automationHandle, opts = {}) {
+        return this.startAutomationRun(automationHandle, opts);
+    }
+    async startAutomationRun(automationHandle, opts = {}) {
+        const body = removeUndefined({
+            inputs: opts.inputs,
+            source: opts.source,
+            external_id: opts.external_id,
+        });
+        const resp = await this.request(`/v1/projects/:project/automations/${encodeURIComponent(automationHandle)}/runs`, { method: "POST", body });
         return (await resp.json());
     }
     async listRuns(opts = {}) {
-        const path = withQuery(`/v1/projects/${encodeURIComponent(this.project)}/runs`, opts);
-        const resp = await this.request(path, { method: "GET" });
+        const resp = await this.request(withQuery("/v1/projects/:project/runs", opts), {
+            method: "GET",
+        });
         return (await resp.json());
     }
     async getRun(runId) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/runs/${encodeURIComponent(runId)}`, { method: "GET" });
+        const resp = await this.request(`/v1/projects/:project/runs/${encodeURIComponent(runId)}`, { method: "GET" });
         return (await resp.json());
     }
-    async cancelRun(runId) {
-        await this.request(`/v1/projects/${encodeURIComponent(this.project)}/runs/${encodeURIComponent(runId)}/cancellations`, { method: "POST" });
-    }
-    async resumeRun(runId) {
-        await this.request(`/v1/projects/${encodeURIComponent(this.project)}/runs/${encodeURIComponent(runId)}/resumptions`, { method: "POST" });
+    async cancelRun(runId, reason) {
+        const body = removeUndefined({ reason });
+        const resp = await this.request(`/v1/projects/:project/runs/${encodeURIComponent(runId)}/cancellations`, { method: "POST", body });
+        return (await resp.json());
     }
-    async sendRunSignal(runId, req) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/runs/${encodeURIComponent(runId)}/signals`, { method: "POST", body: req });
+    async signalRun(runId, stepKey, result) {
+        const body = removeUndefined({
+            step_key: stepKey,
+            result,
+        });
+        const resp = await this.request(`/v1/projects/:project/runs/${encodeURIComponent(runId)}/signals`, { method: "POST", body });
         return (await resp.json());
     }
     async *watchRun(runId, opts = {}) {
-        const path = withQuery(`/v1/projects/${encodeURIComponent(this.project)}/runs/${encodeURIComponent(runId)}/events`, opts.since && opts.since > 0 ? { since: opts.since } : {});
-        const resp = await this.fetchFn(this.baseURL + path, {
+        const path = withQuery(`/v1/projects/:project/runs/${encodeURIComponent(runId)}/events.stream`, opts.since && opts.since > 0 ? { since_sequence: opts.since } : {});
+        const resp = await this.fetchFn(this.url(path), {
             method: "GET",
             headers: this.headers,
             signal: opts.signal,
@@ -248,16 +216,11 @@ export class Client {
             if (isTerminalRunStatus(run.status))
                 return run;
             try {
-                for await (const ev of this.watchRun(runId, {
-                    since,
-                    signal: opts.signal,
-                })) {
-                    if (ev.seq > since)
-                        since = ev.seq;
-                    if (ev.type !== "run_updated")
-                        continue;
-                    const status = ev.data.status;
-                    if (status === "completed" || status === "failed") {
+                for await (const ev of this.watchRun(runId, { ...opts, since })) {
+                    if (ev.sequence > since)
+                        since = ev.sequence;
+                    const status = ev.payload?.status;
+                    if (typeof status === "string" && isTerminalRunStatus(status)) {
                         return await this.getRun(runId);
                     }
                 }
@@ -269,60 +232,6 @@ export class Client {
             await delay(reconnectDelayMs, opts.signal);
         }
     }
-    async listWorkflows(opts = {}) {
-        const path = withQuery(`/v1/projects/${encodeURIComponent(this.project)}/workflows`, opts);
-        const resp = await this.request(path, { method: "GET" });
-        return (await resp.json());
-    }
-    async getWorkflow(workflowId) {
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/workflows/${encodeURIComponent(workflowId)}`, { method: "GET" });
-        return (await resp.json());
-    }
-    async createWorkflow(spec, opts = {}) {
-        const body = createWorkflowRequest(spec, opts);
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/workflows`, { method: "POST", body });
-        return (await resp.json());
-    }
-    async updateWorkflow(workflowId, opts) {
-        const body = removeUndefined({
-            expected_version: opts.expected_version,
-            name: opts.name,
-            description: opts.description,
-            published_as_tool: opts.published_as_tool,
-            spec: opts.spec,
-            tags: opts.tags,
-        });
-        const resp = await this.request(`/v1/projects/${encodeURIComponent(this.project)}/workflows/${encodeURIComponent(workflowId)}`, { method: "PATCH", body });
-        return (await resp.json());
-    }
-    async ensureWorkflow(spec, opts = {}) {
-        const desired = normalizeWorkflowOptions(spec, opts);
-        const existing = await this.findWorkflow(desired);
-        if (!existing) {
-            return {
-                definition: await this.createWorkflow(spec, desired),
-                created: true,
-                updated: false,
-            };
-        }
-        const current = await this.getWorkflow(existing.id);
-        const update = workflowUpdateForDiff(current, spec, desired);
-        if (!update) {
-            return { definition: current, created: false, updated: false };
-        }
-        return {
-            definition: await this.updateWorkflow(current.id, update),
-            created: false,
-            updated: true,
-        };
-    }
-    async syncWorkflows(defs) {
-        const results = [];
-        for (const def of defs) {
-            results.push(await this.ensureWorkflow(def.spec, def.options ?? {}));
-        }
-        return results;
-    }
     async request(path, opts) {
         const timeout = AbortSignal.timeout(this.timeoutMs);
         const signal = opts.signal ? anySignal(opts.signal, timeout) : timeout;
@@ -331,56 +240,37 @@ export class Client {
             headers: this.headers,
             signal,
         };
-        if (opts.body != null) {
+        if (opts.body != null)
             init.body = JSON.stringify(opts.body);
-        }
-        const resp = await this.fetchFn(this.baseURL + path, init);
-        if (!resp.ok &&
-            resp.status !== 204 &&
-            resp.status !== 401 &&
-            resp.status !== 409 &&
-            resp.status !== 413 &&
-            resp.status !== 429) {
+        const resp = await this.fetchFn(this.url(path), init);
+        if (!resp.ok && resp.status !== 204) {
+            if (resp.status === 401)
+                throw new AuthRevokedError();
             const text = await resp.text().catch(() => "");
             throw new Error(`mobius API ${opts.method} ${path}: HTTP ${resp.status}: ${text}`);
         }
         return resp;
     }
-    async findWorkflow(desired) {
-        if (!desired.handle && !desired.name) {
-            throw new Error("mobius: ensure workflow requires a handle, name, or spec name");
-        }
-        let cursor = "";
-        for (;;) {
-            const page = await this.listWorkflows({ cursor, limit: 100 });
-            for (const item of page.items) {
-                if (desired.handle && item.handle === desired.handle)
-                    return item;
-                if (!desired.handle && item.name === desired.name)
-                    return item;
-            }
-            if (!page.has_more || !page.next_cursor)
-                return null;
-            cursor = page.next_cursor;
-        }
+    url(path) {
+        return this.baseURL + path.replace(":project", encodeURIComponent(this.project));
     }
 }
+export function isTerminalRunStatus(status) {
+    return status === "completed" || status === "failed" || status === "cancelled";
+}
 function anySignal(...signals) {
     const controller = new AbortController();
-    for (const s of signals) {
-        if (s.aborted) {
-            controller.abort(s.reason);
+    for (const signal of signals) {
+        if (signal.aborted) {
+            controller.abort(signal.reason);
             break;
         }
-        s.addEventListener("abort", () => controller.abort(s.reason), {
+        signal.addEventListener("abort", () => controller.abort(signal.reason), {
             once: true,
         });
     }
     return controller.signal;
 }
-export function isTerminalRunStatus(status) {
-    return status === "completed" || status === "failed";
-}
 function withQuery(path, params) {
     const query = new URLSearchParams();
     for (const [key, value] of Object.entries(params)) {
@@ -397,143 +287,49 @@ function withQuery(path, params) {
     const qs = query.toString();
     return qs ? `${path}?${qs}` : path;
 }
-function createWorkflowRequest(spec, opts) {
-    const normalized = normalizeWorkflowOptions(spec, opts);
-    return removeUndefined({
-        name: normalized.name,
-        handle: normalized.handle,
-        description: normalized.description,
-        published_as_tool: normalized.published_as_tool,
-        spec,
-        tags: normalized.tags,
-    });
-}
-function normalizeWorkflowOptions(spec, opts) {
-    return { ...opts, name: opts.name || spec.name };
-}
-function workflowUpdateForDiff(current, spec, desired) {
-    const update = {
-        expected_version: current.latest_version,
-    };
-    let changed = false;
-    if (desired.name && current.name !== desired.name) {
-        update.name = desired.name;
-        changed = true;
-    }
-    if (desired.description && current.description !== desired.description) {
-        update.description = desired.description;
-        changed = true;
-    }
-    if (desired.published_as_tool !== undefined &&
-        current.published_as_tool !== desired.published_as_tool) {
-        update.published_as_tool = desired.published_as_tool;
-        changed = true;
-    }
-    if (desired.tags !== undefined && !jsonEqual(current.tags, desired.tags)) {
-        update.tags = desired.tags;
-        changed = true;
-    }
-    if (!jsonEqual(current.spec, spec)) {
-        update.spec = spec;
-        changed = true;
-    }
-    return changed ? update : null;
-}
-function jsonEqual(a, b) {
-    return stableJsonStringify(a) === stableJsonStringify(b);
-}
-function stableJsonStringify(value) {
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableJsonStringify(item) ?? "null").join(",")}]`;
-    }
-    const obj = value;
-    const entries = Object.keys(obj)
-        .sort()
-        .filter((key) => obj[key] !== undefined)
-        .map((key) => `${JSON.stringify(key)}:${stableJsonStringify(obj[key])}`);
-    return `{${entries.join(",")}}`;
-}
 function removeUndefined(obj) {
-    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+async function delay(ms, signal) {
+    if (ms <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        if (signal) {
+            signal.addEventListener("abort", () => {
+                clearTimeout(timer);
+                reject(signal.reason ?? new Error("aborted"));
+            }, { once: true });
+        }
+    });
 }
 async function* parseSSE(body) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    let event = "";
-    let id = "";
-    let dataLines = [];
-    const dispatch = () => {
-        if (dataLines.length === 0) {
-            event = "";
-            return null;
-        }
-        const out = {
-            event: event || "message",
-            id,
-            data: dataLines.join("\n"),
-        };
-        event = "";
-        dataLines = [];
-        return out;
-    };
-    const processLine = (rawLine) => {
-        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-        if (line === "")
-            return dispatch();
-        if (line.startsWith(":"))
-            return null;
-        const colon = line.indexOf(":");
-        const field = colon >= 0 ? line.slice(0, colon) : line;
-        let value = colon >= 0 ? line.slice(colon + 1) : "";
-        if (value.startsWith(" "))
-            value = value.slice(1);
-        if (field === "event")
-            event = value;
-        if (field === "id" && !value.includes("\0"))
-            id = value;
-        if (field === "data")
-            dataLines.push(value);
-        return null;
-    };
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
+    try {
         for (;;) {
-            const newline = buffer.indexOf("\n");
-            if (newline < 0)
+            const { value, done } = await reader.read();
+            if (done)
                 break;
-            const line = buffer.slice(0, newline);
-            buffer = buffer.slice(newline + 1);
-            const evt = processLine(line);
-            if (evt)
-                yield evt;
+            buffer += decoder.decode(value, { stream: true });
+            for (;;) {
+                const match = /\r?\n\r?\n/.exec(buffer);
+                if (!match)
+                    break;
+                const raw = buffer.slice(0, match.index);
+                buffer = buffer.slice(match.index + match[0].length);
+                const data = raw
+                    .split(/\r?\n/)
+                    .filter((line) => line.startsWith("data:"))
+                    .map((line) => line.slice(5).trimStart())
+                    .join("\n");
+                yield { data };
+            }
         }
     }
-    buffer += decoder.decode();
-    if (buffer.length > 0) {
-        const evt = processLine(buffer);
-        if (evt)
-            yield evt;
+    finally {
+        reader.releaseLock();
     }
-    const evt = dispatch();
-    if (evt)
-        yield evt;
-}
-function delay(ms, signal) {
-    if (signal?.aborted)
-        return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(resolve, ms);
-        signal?.addEventListener("abort", () => {
-            clearTimeout(timeout);
-            reject(signal.reason);
-        }, { once: true });
-    });
 }
 //# sourceMappingURL=client.js.map