@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/dist/src/harness-rpc.js

@@ -0,0 +1,206 @@
+import { spawn } from 'node:child_process';
+import { TextDecoder } from 'node:util';
+import { ServiceError } from './protocol.js';
+export const HARNESS_RPC_LIMITS = {
+    frame: 1024 * 1024,
+    total: 4 * 1024 * 1024,
+    pending: 16,
+    timeout: 10000,
+};
+/** Bounded stdio framing only. A launch is not a workspace or credential sandbox. */
+export class HarnessRpc {
+    launch;
+    handlers;
+    process;
+    serial = 0;
+    received = 0;
+    stderr = 0;
+    buffer = '';
+    decoder = new TextDecoder('utf-8', { fatal: true });
+    pending = new Map();
+    inbound = new Set();
+    failure;
+    stopping = false;
+    exited;
+    constructor(launch, handlers = {}) {
+        this.launch = launch;
+        this.handlers = handlers;
+        this.process = spawn(launch.executable, launch.args, {
+            cwd: launch.cwd,
+            env: launch.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.exited = new Promise((resolve) => this.process.once('close', () => {
+            if (!this.stopping)
+                this.fail(new Error('Harness exited before connection closed'));
+            resolve();
+        }));
+        this.process.on('error', (error) => this.fail(error));
+        this.process.stdin.on('error', (error) => this.fail(error));
+        this.process.stderr.on('data', (bytes) => {
+            this.stderr += bytes.length;
+            if (this.stderr > HARNESS_RPC_LIMITS.total)
+                this.fail(new Error('Harness stderr exceeded its bound'));
+        });
+        this.process.stdout.on('data', (bytes) => {
+            try {
+                this.received += bytes.length;
+                if (this.received > HARNESS_RPC_LIMITS.total)
+                    throw new Error('Harness output exceeded its bound');
+                this.buffer += this.decoder.decode(bytes, { stream: true });
+                let end;
+                while ((end = this.buffer.indexOf('\n')) >= 0) {
+                    const line = this.buffer.slice(0, end);
+                    this.buffer = this.buffer.slice(end + 1);
+                    if (Buffer.byteLength(line) > HARNESS_RPC_LIMITS.frame)
+                        throw new Error('Harness frame exceeded its bound');
+                    if (!line.trim())
+                        throw new Error('Empty harness frame');
+                    this.message(JSON.parse(line));
+                }
+                if (Buffer.byteLength(this.buffer) > HARNESS_RPC_LIMITS.frame)
+                    throw new Error('Harness frame exceeded its bound');
+            }
+            catch (error) {
+                this.fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        this.process.stdout.on('end', () => {
+            if (!this.stopping &&
+                (this.buffer.length ||
+                    (() => {
+                        try {
+                            return Boolean(this.decoder.decode());
+                        }
+                        catch {
+                            return true;
+                        }
+                    })()))
+                this.fail(new Error('Truncated harness frame'));
+        });
+    }
+    object(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('Invalid harness object');
+        return value;
+    }
+    message(value) {
+        if (this.failure || this.stopping)
+            return;
+        const message = this.object(value);
+        if (this.launch.dialect === 'acp' ? message.jsonrpc !== '2.0' : message.jsonrpc !== undefined)
+            throw new Error('Harness RPC dialect mismatch');
+        if (typeof message.method === 'string') {
+            if (message.method.length > 192 ||
+                Object.hasOwn(message, 'result') ||
+                Object.hasOwn(message, 'error'))
+                throw new Error('Invalid harness request envelope');
+            const params = message.params === undefined ? {} : this.object(message.params);
+            if (message.id === undefined) {
+                this.handlers.notification?.(message.method, params);
+                return;
+            }
+            if ((typeof message.id !== 'string' && typeof message.id !== 'number') ||
+                (typeof message.id === 'string' && message.id.length > 256) ||
+                (typeof message.id === 'number' && !Number.isSafeInteger(message.id)))
+                throw new Error('Invalid harness request ID');
+            const key = JSON.stringify(message.id);
+            if (this.inbound.has(key) || this.inbound.size >= HARNESS_RPC_LIMITS.pending)
+                throw new Error('Duplicate or excessive harness requests');
+            this.inbound.add(key);
+            Promise.resolve()
+                .then(() => {
+                if (!this.handlers.request)
+                    throw new ServiceError('harness_permission_denied', 'Harness client authority is unavailable');
+                return this.handlers.request(message.method, params);
+            })
+                .then((result) => this.send({ id: message.id, result: result ?? {} }), () => this.send({
+                id: message.id,
+                error: { code: -32000, message: 'Harness request denied' },
+            }))
+                .catch((error) => this.fail(error))
+                .finally(() => this.inbound.delete(key));
+            return;
+        }
+        if (!Number.isSafeInteger(message.id) ||
+            Object.hasOwn(message, 'result') === Object.hasOwn(message, 'error'))
+            throw new Error('Invalid harness reply');
+        const waiter = this.pending.get(message.id);
+        if (!waiter)
+            throw new Error('Unowned or duplicate harness reply');
+        this.pending.delete(message.id);
+        clearTimeout(waiter.timer);
+        if (Object.hasOwn(message, 'error'))
+            waiter.reject(new ServiceError('harness_rpc_error', 'Harness rejected the request'));
+        else {
+            try {
+                waiter.resolve(this.object(message.result));
+            }
+            catch (error) {
+                waiter.reject(error);
+                throw error;
+            }
+        }
+    }
+    send(value) {
+        if (this.failure || this.stopping)
+            throw this.failure ?? new Error('Harness connection closed');
+        const frame = JSON.stringify({ ...(this.launch.dialect === 'acp' ? { jsonrpc: '2.0' } : {}), ...value }) +
+            '\n';
+        if (Buffer.byteLength(frame) > HARNESS_RPC_LIMITS.frame)
+            throw new Error('Outbound harness frame exceeded its bound');
+        if (this.process.stdin.writableLength + Buffer.byteLength(frame) > HARNESS_RPC_LIMITS.total)
+            throw new Error('Harness input backpressure exceeded its bound');
+        this.process.stdin.write(frame);
+    }
+    request(method, params, timeout = HARNESS_RPC_LIMITS.timeout) {
+        if (this.failure || this.stopping)
+            return Promise.reject(this.failure ?? new Error('Harness connection closed'));
+        if (this.pending.size >= HARNESS_RPC_LIMITS.pending ||
+            !Number.isSafeInteger(timeout) ||
+            timeout < 1 ||
+            timeout > 300000)
+            return Promise.reject(new Error('Harness request bound exceeded'));
+        const id = ++this.serial;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => this.fail(new ServiceError('harness_outcome_unknown', 'Harness reply deadline reached; the request must not be replayed')), timeout);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.send({ id, method, params });
+            }
+            catch (error) {
+                this.fail(error);
+            }
+        });
+    }
+    notify(method, params) {
+        this.send({ method, params });
+    }
+    fail(error) {
+        if (this.failure || this.stopping)
+            return;
+        this.failure = error;
+        for (const waiter of this.pending.values()) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+        this.pending.clear();
+        this.process.kill('SIGKILL');
+        // A failed persistence observer must not leave the transport usable or make a timer throw.
+        // Pending callers already reject; the committed dispatch intent remains for recovery.
+        try {
+            this.handlers.failed?.(error);
+        }
+        catch { }
+    }
+    async close() {
+        this.stopping = true;
+        for (const waiter of this.pending.values()) {
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error('Harness connection closed'));
+        }
+        this.pending.clear();
+        this.process.kill('SIGKILL');
+        await this.exited;
+    }
+}

package/dist/src/harness-tool-identity.js

@@ -0,0 +1,87 @@
+import { HARNESS_TARGETS } from './harness-probe.js';
+import { ServiceError } from './protocol.js';
+/** Correlation only: these IDs never authenticate a worker or grant operator authority. */
+export function harnessToolIds(target, version, intent) {
+    if (!Object.hasOwn(HARNESS_TARGETS, target) ||
+        HARNESS_TARGETS[target].version !== version ||
+        !/^[a-zA-Z0-9_-]{1,128}$/.test(intent.id) ||
+        !/^[a-zA-Z0-9_-]{1,128}$/.test(intent.name))
+        throw new ServiceError('harness_tool_identity', 'Unproved runtime or malformed model tool identity');
+    // Gemini 0.64.0 namespaces model-call IDs when projecting them into ACP tool calls.
+    return target === 'gemini-acp' ? [intent.id, intent.name + '__' + intent.id] : [intent.id];
+}
+/** Parse only literal shell argv displays; never evaluate expansions, redirections or operators. */
+function literalWords(display) {
+    const words = [];
+    let word = '', quote = '', present = false;
+    for (let i = 0; i < display.length; i++) {
+        const c = display[i];
+        if (quote === "'") {
+            if (c === "'")
+                quote = '';
+            else
+                word += c;
+        }
+        else if (c === '\\') {
+            const next = display[++i];
+            if (next === undefined || next === '\n')
+                return null;
+            if (quote === '"' && !['"', '\\', '$', '`'].includes(next))
+                word += '\\';
+            word += next;
+            present = true;
+        }
+        else if (quote === '"') {
+            if (c === '"')
+                quote = '';
+            else if (c === '$' || c === '`')
+                return null;
+            else
+                word += c;
+        }
+        else if (c === "'" || c === '"') {
+            quote = c;
+            present = true;
+        }
+        else if (c === '\n' || c === '\r')
+            return null;
+        else if (/\s/.test(c)) {
+            if (present)
+                words.push(word);
+            word = '';
+            present = false;
+        }
+        else {
+            if (';&|<>()$`*?[]{}~#'.includes(c))
+                return null;
+            word += c;
+            present = true;
+        }
+    }
+    if (quote)
+        return null;
+    if (present)
+        words.push(word);
+    return words;
+}
+/** Correlate the pinned app-server's concrete shell display with an independently captured model call. No grant is implied. */
+export function matchesCodexCommandScope(version, intent, params) {
+    if (version !== HARNESS_TARGETS['codex-app-server'].version ||
+        !intent ||
+        intent.name !== 'exec_command' ||
+        intent.id !== params.itemId ||
+        typeof intent.arguments.cmd !== 'string' ||
+        typeof params.command !== 'string' ||
+        typeof intent.arguments.workdir !== 'string' ||
+        params.cwd !== intent.arguments.workdir ||
+        intent.arguments.shell !== undefined ||
+        intent.arguments.login === false)
+        return false;
+    const words = literalWords(params.command);
+    return (words?.length === 3 &&
+        // The pinned image exposes Bash at both paths. Codex selects /bin/bash
+        // for its UID-1000 passwd entry and /usr/bin/bash for an unmapped UID.
+        ['/usr/bin/bash', '/bin/bash'].includes(words[0]) &&
+        words[1] === '-lc' &&
+        words[2] === intent.arguments.cmd);
+}

package/dist/src/harness-wire-bridge.js

@@ -0,0 +1,387 @@
+import { randomUUID } from 'node:crypto';
+import { ServiceError } from './protocol.js';
+function invalid() {
+    throw new ServiceError('harness_wire_unsupported', 'Payload exceeds the admitted text/custom-tool wire subset');
+}
+const object = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : invalid();
+const list = (value) => Array.isArray(value) && value.length <= 512 ? value.map(object) : invalid();
+const text = (value) => (typeof value === 'string' ? value : invalid());
+const id = (value) => typeof value === 'string' && /^[a-zA-Z0-9_-]{1,128}$/.test(value) ? value : invalid();
+/** Explicit protocol translation to the operator-declared Claude backend, never a Google/OpenAI account claim. */
+export class HarnessWireBridge {
+    backend;
+    wire;
+    onTool;
+    constructor(backend, wire, onTool) {
+        this.backend = backend;
+        this.wire = wire;
+        this.onTool = onTool;
+        if (!wire.model ||
+            !wire.tools.length ||
+            wire.tools.some((n) => !/^[a-zA-Z0-9_-]{1,128}$/.test(n)))
+            throw Error('Invalid frozen harness wire policy');
+    }
+    tool(name) {
+        const n = text(name);
+        if (!this.wire.tools.includes(n))
+            invalid();
+        return n;
+    }
+    append(t, role, content) {
+        if (!content.length)
+            return;
+        const previous = t.messages.at(-1);
+        if (previous?.role === role)
+            previous.content.push(...content);
+        else
+            t.messages.push({ role, content });
+    }
+    google(body) {
+        if (Object.keys(body).some((k) => !['contents', 'systemInstruction', 'tools', 'generationConfig', 'toolConfig'].includes(k)))
+            invalid();
+        const t = { system: [], messages: [], tools: [] }, pending = new Map(), byName = new Map();
+        if (body.systemInstruction)
+            for (const part of list(object(body.systemInstruction).parts))
+                t.system.push(text(part.text));
+        for (const tool of list(body.tools ?? []))
+            for (const declaration of list(tool.functionDeclarations ?? [])) {
+                const name = text(declaration.name);
+                if (!this.wire.tools.includes(name))
+                    continue;
+                t.tools.push({
+                    name,
+                    description: typeof declaration.description === 'string' ? declaration.description : '',
+                    input_schema: object(declaration.parametersJsonSchema ?? declaration.parameters),
+                });
+            }
+        for (const [position, message] of list(body.contents).entries()) {
+            if (!['user', 'model'].includes(message.role))
+                invalid();
+            const parts = [];
+            for (const [index, part] of list(message.parts).entries()) {
+                if (typeof part.text === 'string') {
+                    parts.push({ type: 'text', text: part.text });
+                    continue;
+                }
+                if (part.functionCall && message.role === 'model') {
+                    const call = object(part.functionCall), name = this.tool(call.name), callId = call.id === undefined ? 'google_' + position + '_' + index : id(call.id);
+                    if (pending.has(callId))
+                        invalid();
+                    pending.set(callId, name);
+                    byName.set(name, [...(byName.get(name) ?? []), callId]);
+                    parts.push({ type: 'tool_use', id: callId, name, input: object(call.args) });
+                    continue;
+                }
+                if (part.functionResponse && message.role === 'user') {
+                    const reply = object(part.functionResponse), name = this.tool(reply.name), options = byName.get(name) ?? [], callId = reply.id === undefined
+                        ? options.length === 1
+                            ? options[0]
+                            : invalid()
+                        : id(reply.id);
+                    if (pending.get(callId) !== name)
+                        invalid();
+                    pending.delete(callId);
+                    byName.set(name, options.filter((n) => n !== callId));
+                    parts.push({
+                        type: 'tool_result',
+                        tool_use_id: callId,
+                        content: JSON.stringify(reply.response),
+                    });
+                    continue;
+                }
+                invalid();
+            }
+            this.append(t, message.role === 'model' ? 'assistant' : 'user', parts);
+        }
+        if (pending.size)
+            invalid();
+        return t;
+    }
+    responses(body) {
+        if (body.model !== this.wire.model || body.previous_response_id)
+            invalid();
+        const t = { system: [], messages: [], tools: [] }, pending = new Set();
+        if (body.instructions !== undefined)
+            t.system.push(text(body.instructions));
+        for (const tool of list(body.tools ?? [])) {
+            if (tool.type !== 'function' || !this.wire.tools.includes(tool.name))
+                continue;
+            t.tools.push({
+                name: this.tool(tool.name),
+                description: typeof tool.description === 'string' ? tool.description : '',
+                input_schema: object(tool.parameters),
+            });
+        }
+        for (const item of list(body.input)) {
+            if (item.type === 'message' || item.role) {
+                if (!['user', 'assistant', 'system', 'developer'].includes(item.role))
+                    invalid();
+                const parts = typeof item.content === 'string'
+                    ? [{ text: item.content }]
+                    : list(item.content).map((p) => {
+                        if (!['input_text', 'output_text'].includes(p.type))
+                            invalid();
+                        return { text: text(p.text) };
+                    });
+                if (['system', 'developer'].includes(item.role))
+                    t.system.push(parts.map((p) => p.text).join('\n'));
+                else
+                    this.append(t, item.role, parts.map((p) => ({ type: 'text', text: p.text })));
+                continue;
+            }
+            if (item.type === 'function_call') {
+                const callId = id(item.call_id);
+                if (pending.has(callId))
+                    invalid();
+                pending.add(callId);
+                let input;
+                try {
+                    input = object(JSON.parse(text(item.arguments)));
+                }
+                catch {
+                    invalid();
+                }
+                this.append(t, 'assistant', [
+                    { type: 'tool_use', id: callId, name: this.tool(item.name), input },
+                ]);
+                continue;
+            }
+            if (item.type === 'function_call_output') {
+                const callId = id(item.call_id);
+                if (!pending.delete(callId))
+                    invalid();
+                const output = typeof item.output === 'string' ? item.output : JSON.stringify(item.output);
+                this.append(t, 'user', [{ type: 'tool_result', tool_use_id: callId, content: output }]);
+                continue;
+            }
+            // A foreign provider's opaque thinking signature is never forwarded as Claude authority.
+            if (item.type === 'reasoning')
+                continue;
+            invalid();
+        }
+        if (pending.size)
+            invalid();
+        return t;
+    }
+    async request(request) {
+        if (request.method !== 'POST' || request.body.length > 2 * 1024 * 1024)
+            invalid();
+        const expected = this.wire.protocol === 'google'
+            ? '/v1beta/models/' + this.wire.model + ':streamGenerateContent?alt=sse'
+            : '/v1/responses';
+        if (request.path !== expected)
+            invalid();
+        let raw;
+        try {
+            raw = object(JSON.parse(request.body.toString('utf8')));
+        }
+        catch {
+            invalid();
+        }
+        const transcript = this.wire.protocol === 'google' ? this.google(raw) : this.responses(raw);
+        const requested = this.wire.protocol === 'google'
+            ? raw.generationConfig?.maxOutputTokens
+            : raw.max_output_tokens;
+        if (requested !== undefined && (!Number.isSafeInteger(requested) || requested < 1))
+            invalid();
+        const body = {
+            model: this.backend.policy.model,
+            max_tokens: Math.min(requested ?? this.backend.policy.output, this.backend.policy.output),
+            stream: false,
+            system: transcript.system.join('\n\n'),
+            messages: transcript.messages,
+            ...(transcript.tools.length
+                ? {
+                    tools: transcript.tools,
+                    tool_choice: { type: 'auto', disable_parallel_tool_use: true },
+                }
+                : {}),
+        };
+        const result = await this.backend.request({
+            ...request,
+            path: '/v1/messages',
+            body: Buffer.from(JSON.stringify(body)),
+        });
+        if (result.status !== 200)
+            return {
+                status: result.status,
+                content_type: 'application/json',
+                body: Buffer.from(JSON.stringify({
+                    error: {
+                        code: result.status,
+                        message: 'Declared model backend rejected this request',
+                        status: 'FAILED_PRECONDITION',
+                    },
+                })),
+            };
+        let bytes;
+        if (Buffer.isBuffer(result.body))
+            bytes = result.body;
+        else {
+            const chunks = [];
+            let length = 0;
+            for await (const chunk of result.body) {
+                length += chunk.length;
+                if (length > 8 * 1024 * 1024)
+                    invalid();
+                chunks.push(Buffer.from(chunk));
+            }
+            bytes = Buffer.concat(chunks);
+        }
+        const response = object(JSON.parse(bytes.toString('utf8'))), content = list(response.content), usage = object(response.usage ?? {});
+        for (const part of content)
+            if (part.type === 'tool_use') {
+                this.tool(part.name);
+                this.onTool?.({
+                    id: id(part.id),
+                    name: this.tool(part.name),
+                    arguments: structuredClone(object(part.input)),
+                });
+            }
+            else if (!['text', 'thinking', 'redacted_thinking'].includes(part.type))
+                invalid();
+        if (this.wire.protocol === 'google') {
+            const parts = content.flatMap((p) => p.type === 'text'
+                ? [{ text: text(p.text) }]
+                : p.type === 'tool_use'
+                    ? [{ functionCall: { id: id(p.id), name: this.tool(p.name), args: object(p.input) } }]
+                    : []);
+            const payload = {
+                candidates: [
+                    {
+                        index: 0,
+                        content: { role: 'model', parts },
+                        finishReason: response.stop_reason === 'max_tokens' ? 'MAX_TOKENS' : 'STOP',
+                    },
+                ],
+                usageMetadata: {
+                    promptTokenCount: usage.input_tokens ?? 0,
+                    candidatesTokenCount: usage.output_tokens ?? 0,
+                    totalTokenCount: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+                },
+                modelVersion: this.wire.model,
+                responseId: response.id,
+            };
+            return {
+                status: 200,
+                content_type: 'text/event-stream',
+                body: Buffer.from('data: ' + JSON.stringify(payload) + '\n\n'),
+            };
+        }
+        const responseId = 'resp_' + randomUUID().replaceAll('-', ''), output = content.flatMap((p) => p.type === 'text'
+            ? [
+                {
+                    id: 'msg_' + randomUUID().replaceAll('-', ''),
+                    type: 'message',
+                    status: 'completed',
+                    role: 'assistant',
+                    content: [{ type: 'output_text', text: text(p.text), annotations: [] }],
+                },
+            ]
+            : p.type === 'tool_use'
+                ? [
+                    {
+                        id: 'fc_' + id(p.id),
+                        type: 'function_call',
+                        status: 'completed',
+                        call_id: id(p.id),
+                        name: this.tool(p.name),
+                        arguments: JSON.stringify(object(p.input)),
+                    },
+                ]
+                : []);
+        const complete = {
+            id: responseId,
+            object: 'response',
+            created_at: Math.floor(Date.now() / 1000),
+            status: response.stop_reason === 'max_tokens' ? 'incomplete' : 'completed',
+            error: null,
+            incomplete_details: response.stop_reason === 'max_tokens' ? { reason: 'max_output_tokens' } : null,
+            model: this.wire.model,
+            output,
+            usage: {
+                input_tokens: usage.input_tokens ?? 0,
+                output_tokens: usage.output_tokens ?? 0,
+                total_tokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+                input_tokens_details: { cached_tokens: usage.cache_read_input_tokens ?? 0 },
+                output_tokens_details: { reasoning_tokens: 0 },
+            },
+            parallel_tool_calls: false,
+        };
+        if (raw.stream !== true)
+            return {
+                status: 200,
+                content_type: 'application/json',
+                body: Buffer.from(JSON.stringify(complete)),
+            };
+        let serial = 0;
+        const events = [
+            { type: 'response.created', response: { ...complete, status: 'in_progress', output: [] } },
+        ];
+        for (const [index, item] of output.entries()) {
+            events.push({
+                type: 'response.output_item.added',
+                output_index: index,
+                item: {
+                    ...item,
+                    status: 'in_progress',
+                    ...(item.type === 'function_call' ? { arguments: '' } : { content: [] }),
+                },
+            });
+            if (item.type === 'function_call')
+                events.push({
+                    type: 'response.function_call_arguments.delta',
+                    item_id: item.id,
+                    output_index: index,
+                    delta: item.arguments,
+                }, {
+                    type: 'response.function_call_arguments.done',
+                    item_id: item.id,
+                    output_index: index,
+                    arguments: item.arguments,
+                });
+            else {
+                events.push({
+                    type: 'response.content_part.added',
+                    item_id: item.id,
+                    output_index: index,
+                    content_index: 0,
+                    part: { type: 'output_text', text: '', annotations: [] },
+                }, {
+                    type: 'response.output_text.delta',
+                    item_id: item.id,
+                    output_index: index,
+                    content_index: 0,
+                    delta: item.content[0].text,
+                }, {
+                    type: 'response.output_text.done',
+                    item_id: item.id,
+                    output_index: index,
+                    content_index: 0,
+                    text: item.content[0].text,
+                }, {
+                    type: 'response.content_part.done',
+                    item_id: item.id,
+                    output_index: index,
+                    content_index: 0,
+                    part: item.content[0],
+                });
+            }
+            events.push({ type: 'response.output_item.done', output_index: index, item });
+        }
+        events.push({
+            type: complete.status === 'completed' ? 'response.completed' : 'response.incomplete',
+            response: complete,
+        });
+        return {
+            status: 200,
+            content_type: 'text/event-stream',
+            body: Buffer.from(events
+                .map((event) => {
+                const value = { ...event, sequence_number: serial++ };
+                return 'event: ' + event.type + '\ndata: ' + JSON.stringify(value) + '\n\n';
+            })
+                .join('')),
+        };
+    }
+}