@synapseone/sdk 0.7.0 → 0.7.1-dev.56

package/dist/notifications.test.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Notifications SDK tests (stub gateway).
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_http_1 = __importDefault(require("node:http"));
+const index_1 = require("./index");
+let server;
+let base = '';
+let last = {};
+(0, node_test_1.before)(() => new Promise((resolve) => {
+    server = node_http_1.default
+        .createServer((req, res) => {
+        let body = '';
+        req.on('data', (c) => (body += c));
+        req.on('end', () => {
+            last = { method: req.method, path: req.url, body: body ? JSON.parse(body) : null };
+            res.setHeader('Content-Type', 'application/json');
+            if (req.url === '/v1/notifications' && req.method === 'POST') {
+                res.statusCode = 202;
+                res.end(JSON.stringify({ notifications: [{ id: 'n1', status: 'queued' }] }));
+                return;
+            }
+            res.end(JSON.stringify({ id: 'n1', status: 'delivered', unsubscribed: false, channels: [] }));
+        });
+    })
+        .listen(0, '127.0.0.1', () => {
+        const a = server.address();
+        base = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        resolve();
+    });
+}));
+(0, node_test_1.after)(() => new Promise((resolve) => server.close(() => resolve())));
+(0, node_test_1.describe)('SynapseNotifications SDK', () => {
+    (0, node_test_1.it)('sends a templated notification', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const out = await c.notifications.send({
+            channel: 'webhook',
+            recipient: { url: 'https://example.com/hook' },
+            subject: 'Hi {{name}}',
+            body: 'Hello {{name}}',
+            data: { name: 'An' },
+        });
+        strict_1.default.equal(out.notifications[0].id, 'n1');
+        strict_1.default.equal(last.path, '/v1/notifications');
+        strict_1.default.equal(last.body.subject, 'Hi {{name}}');
+        strict_1.default.equal(last.body.recipient.url, 'https://example.com/hook');
+    });
+    (0, node_test_1.it)('gets, lists, cancels, preferences and unsubscribe', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.notifications.get('n1');
+        strict_1.default.equal(last.path, '/v1/notifications/n1');
+        await c.notifications.list({ status: 'queued', limit: 5 });
+        strict_1.default.equal(last.path, '/v1/notifications?status=queued&limit=5');
+        await c.notifications.cancel('n1');
+        strict_1.default.equal(last.path, '/v1/notifications/n1/cancel');
+        await c.notifications.getPreference('user:u1');
+        strict_1.default.equal(last.path, '/v1/notifications/preferences/user%3Au1');
+        await c.notifications.setPreference('user:u1', { channels: ['email'], unsubscribed: false });
+        strict_1.default.deepEqual(last.body, { channels: ['email'], unsubscribed: false });
+        await c.notifications.unsubscribe('user:u1');
+        strict_1.default.deepEqual(last.body, { recipient: 'user:u1' });
+    });
+});

package/dist/queue.js

@@ -1,4 +1,6 @@
 "use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
 /*
  * Copyright 2026 SynapseOne Contributors
  * Licensed under the Apache License, Version 2.0 (the "License");

package/dist/services.test.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
 /*
  * Copyright 2026 SynapseOne Contributors
  * Licensed under the Apache License, Version 2.0 (the "License");

package/dist/storage.d.ts

@@ -0,0 +1,66 @@
+import { HttpClient, RequestOptions } from './_http';
+export interface StoredObject {
+    key: string;
+    size: number;
+    contentType: string;
+    etag: string;
+    checksumSha256?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ObjectList {
+    objects: StoredObject[];
+    nextCursor: string | null;
+}
+export interface PutObjectOptions extends RequestOptions {
+    contentType?: string;
+    /** Hex sha256 of the body; the server rejects a mismatch. */
+    checksumSha256?: string;
+    /** Overwrite an existing object (the default is an upsert). */
+    overwrite?: boolean;
+}
+export declare class StorageService {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Upload raw bytes (Uint8Array, Buffer, ArrayBuffer or a string). */
+    putObject(key: string, body: Uint8Array | ArrayBuffer | string, opts?: PutObjectOptions): Promise<StoredObject>;
+    /** Download an object as bytes (use `text()`/`blob()` on your side). */
+    getObject(key: string, opts?: RequestOptions): Promise<Uint8Array>;
+    /** HEAD metadata for an object. Returns null when it does not exist. */
+    headObject(key: string, opts?: RequestOptions): Promise<StoredObject | null>;
+    deleteObject(key: string): Promise<{
+        ok: boolean;
+        key: string;
+    }>;
+    listObjects(opts?: {
+        prefix?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<ObjectList>;
+    /** Presigned URL (S3 backend only; 501 on the filesystem backend). */
+    presign(key: string, opts?: {
+        method?: 'GET' | 'PUT' | 'DELETE' | 'HEAD';
+        expiresIn?: number;
+    }): Promise<{
+        url: string;
+        method: string;
+        expiresIn: number;
+    }>;
+    createMultipart(key: string, contentType?: string): Promise<{
+        uploadId: string;
+        key: string;
+        contentType: string;
+    }>;
+    uploadPart(uploadId: string, key: string, partNumber: number, body: Uint8Array | string): Promise<{
+        partNumber: number;
+        etag: string;
+        size: number;
+    }>;
+    completeMultipart(uploadId: string, key: string, parts: Array<{
+        partNumber: number;
+        etag: string;
+    }>): Promise<{
+        object: StoredObject;
+    }>;
+    abortMultipart(uploadId: string, key: string): Promise<unknown>;
+}

package/dist/storage.js

@@ -0,0 +1,98 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * SynapseObjectStorage client: tenant-scoped object/file storage (#24).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageService = void 0;
+const P = '/v1/storage';
+class StorageService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Upload raw bytes (Uint8Array, Buffer, ArrayBuffer or a string). */
+    async putObject(key, body, opts = {}) {
+        const bytes = typeof body === 'string' ? new TextEncoder().encode(body) : body instanceof Uint8Array ? body : new Uint8Array(body);
+        const res = await this.http.upload(`${P}/objects/${encodeKey(key)}`, bytes, {
+            ...opts,
+            contentType: opts.contentType || 'application/octet-stream',
+            headers: { ...(opts.checksumSha256 ? { 'x-object-checksum-sha256': opts.checksumSha256 } : {}), ...(opts.headers || {}) },
+        });
+        return res.object;
+    }
+    /** Download an object as bytes (use `text()`/`blob()` on your side). */
+    getObject(key, opts = {}) {
+        return this.http.reqBinary(`${P}/objects/${encodeKey(key)}`, undefined, opts);
+    }
+    /** HEAD metadata for an object. Returns null when it does not exist. */
+    async headObject(key, opts = {}) {
+        try {
+            const h = await this.http.head(`${P}/objects/${encodeKey(key)}`, opts);
+            return {
+                key: h['x-object-key'] || key,
+                size: Number(h['content-length'] || 0),
+                contentType: h['content-type'] || 'application/octet-stream',
+                etag: (h['etag'] || '').replace(/"/g, ''),
+                checksumSha256: h['x-object-checksum-sha256'],
+                createdAt: h['x-object-created-at'] || '',
+                updatedAt: h['x-object-updated-at'] || '',
+            };
+        }
+        catch (e) {
+            if (e?.status === 404)
+                return null;
+            throw e;
+        }
+    }
+    deleteObject(key) {
+        return this.http.req(`${P}/objects/${encodeKey(key)}`, { method: 'DELETE' });
+    }
+    listObjects(opts = {}) {
+        const qs = new URLSearchParams();
+        if (opts.prefix)
+            qs.set('prefix', opts.prefix);
+        if (opts.limit)
+            qs.set('limit', String(opts.limit));
+        if (opts.cursor)
+            qs.set('cursor', opts.cursor);
+        const s = qs.toString();
+        return this.http.req(`${P}/objects${s ? `?${s}` : ''}`);
+    }
+    /** Presigned URL (S3 backend only; 501 on the filesystem backend). */
+    presign(key, opts = {}) {
+        return this.http.req(`${P}/presign`, {
+            method: 'POST',
+            body: JSON.stringify({ key, method: opts.method || 'GET', expiresIn: opts.expiresIn ?? 900 }),
+        });
+    }
+    createMultipart(key, contentType = 'application/octet-stream') {
+        return this.http.req(`${P}/uploads`, {
+            method: 'POST',
+            body: JSON.stringify({ key, contentType }),
+        });
+    }
+    uploadPart(uploadId, key, partNumber, body) {
+        const bytes = typeof body === 'string' ? new TextEncoder().encode(body) : body;
+        return this.http.upload(`${P}/uploads/${encodeURIComponent(uploadId)}/parts/${partNumber}?key=${encodeURIComponent(key)}`, bytes, { method: 'PUT', contentType: 'application/octet-stream' });
+    }
+    completeMultipart(uploadId, key, parts) {
+        return this.http.req(`${P}/uploads/${encodeURIComponent(uploadId)}/complete`, {
+            method: 'POST',
+            body: JSON.stringify({ key, parts }),
+        });
+    }
+    abortMultipart(uploadId, key) {
+        return this.http.req(`/v1/storage/uploads/${encodeURIComponent(uploadId)}?key=${encodeURIComponent(key)}`, { method: 'DELETE' });
+    }
+}
+exports.StorageService = StorageService;
+function encodeKey(key) {
+    return String(key || '')
+        .split('/')
+        .map((seg) => encodeURIComponent(seg))
+        .join('/');
+}

package/dist/storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage.test.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Object storage SDK tests: binary upload/download/head/list/multipart.
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_http_1 = __importDefault(require("node:http"));
+const index_1 = require("./index");
+let server;
+let base = '';
+const objects = new Map();
+let lastUploadId = '';
+(0, node_test_1.before)(() => new Promise((resolve) => {
+    server = node_http_1.default
+        .createServer((req, res) => {
+        const url = new URL(req.url || '/', 'http://x');
+        const key = decodeURIComponent(url.pathname.replace('/v1/storage/objects/', ''));
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => {
+            const body = Buffer.concat(chunks);
+            if (url.pathname === '/v1/storage/objects' && req.method === 'GET') {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ objects: [{ key: 'a.txt', size: 5, contentType: 'text/plain', etag: 'e', createdAt: 't', updatedAt: 't' }], nextCursor: null }));
+                return;
+            }
+            if (url.pathname === '/v1/storage/presign') {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ url: 'https://s3.example.com/x', method: 'GET', expiresIn: 900 }));
+                return;
+            }
+            if (url.pathname === '/v1/storage/uploads') {
+                lastUploadId = 'u1';
+                res.statusCode = 201;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ uploadId: 'u1', key: 'k', contentType: 'application/octet-stream' }));
+                return;
+            }
+            if (url.pathname.endsWith('/complete')) {
+                res.statusCode = 201;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ object: { key: 'k', size: 11, contentType: 'application/octet-stream', etag: 'e', createdAt: 't', updatedAt: 't' } }));
+                return;
+            }
+            if (url.pathname.includes('/parts/')) {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ partNumber: 1, etag: 'p1', size: body.length }));
+                return;
+            }
+            if (req.method === 'PUT') {
+                objects.set(key, { body, type: String(req.headers['content-type'] || '') });
+                res.statusCode = 201;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ object: { key, size: body.length, contentType: req.headers['content-type'], etag: 'e', createdAt: 't', updatedAt: 't' } }));
+                return;
+            }
+            if (req.method === 'HEAD') {
+                const o = objects.get(key);
+                if (!o) {
+                    res.statusCode = 404;
+                    res.end();
+                    return;
+                }
+                res.setHeader('Content-Type', o.type);
+                res.setHeader('Content-Length', String(o.body.length));
+                res.setHeader('ETag', '"e"');
+                res.setHeader('x-object-key', key);
+                res.end();
+                return;
+            }
+            if (req.method === 'GET') {
+                const o = objects.get(key);
+                if (!o) {
+                    res.statusCode = 404;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end('{"error":"not_found"}');
+                    return;
+                }
+                res.setHeader('Content-Type', o.type);
+                res.end(o.body);
+                return;
+            }
+            if (req.method === 'DELETE') {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ ok: objects.delete(key), key }));
+                return;
+            }
+            res.statusCode = 404;
+            res.end('{}');
+        });
+    })
+        .listen(0, '127.0.0.1', () => {
+        const a = server.address();
+        base = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        resolve();
+    });
+}));
+(0, node_test_1.after)(() => new Promise((resolve) => server.close(() => resolve())));
+(0, node_test_1.describe)('SynapseObjectStorage SDK', () => {
+    (0, node_test_1.it)('uploads/downloads binary bodies without JSON wrapping', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const bytes = new Uint8Array([0, 1, 2, 254, 255]);
+        const meta = await c.storage.putObject('photos/a.png', bytes, { contentType: 'image/png' });
+        strict_1.default.equal(meta.size, 5);
+        const got = await c.storage.getObject('photos/a.png');
+        strict_1.default.deepEqual([...got], [0, 1, 2, 254, 255]);
+    });
+    (0, node_test_1.it)('reads HEAD metadata and lists objects', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.storage.putObject('a.txt', 'hello', { contentType: 'text/plain' });
+        const head = await c.storage.headObject('a.txt');
+        strict_1.default.equal(head?.size, 5);
+        strict_1.default.equal(head?.contentType, 'text/plain');
+        strict_1.default.equal(await c.storage.headObject('missing'), null);
+        const list = await c.storage.listObjects({ prefix: 'a' });
+        strict_1.default.equal(list.objects[0].key, 'a.txt');
+    });
+    (0, node_test_1.it)('presigns, deletes and runs multipart', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const pre = await c.storage.presign('a.txt', { expiresIn: 60 });
+        strict_1.default.equal(pre.expiresIn, 900); // mock returns its own value
+        const del = await c.storage.deleteObject('a.txt');
+        strict_1.default.equal(typeof del.ok, 'boolean');
+        const up = await c.storage.createMultipart('k');
+        strict_1.default.equal(up.uploadId, 'u1');
+        const part = await c.storage.uploadPart(lastUploadId, 'k', 1, new Uint8Array([1, 2, 3]));
+        strict_1.default.equal(part.etag, 'p1');
+        const done = await c.storage.completeMultipart(lastUploadId, 'k', [{ partNumber: 1, etag: 'p1' }]);
+        strict_1.default.equal(done.object.size, 11);
+    });
+});

package/dist/stream.js

@@ -1,4 +1,6 @@
 "use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
 /*
  * Copyright 2026 SynapseOne Contributors
  * Licensed under the Apache License, Version 2.0 (the "License");

package/dist/transport.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transport.test.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Transport contract tests: non-JSON guard, retries, timeouts, streaming and
+ * typed health/readiness. Offline (local HTTP servers only).
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_module_1 = require("node:module");
+const index_1 = require("./index");
+const requireCjs = (0, node_module_1.createRequire)(__dirname);
+let server;
+let base = '';
+let hits = new Map();
+let slowMs = 0;
+(0, node_test_1.before)(() => new Promise((resolve) => {
+    server = node_http_1.default
+        .createServer((req, res) => {
+        const url = req.url || '';
+        hits.set(url, (hits.get(url) || 0) + 1);
+        if (url === '/v1/orgs' && req.headers['x-test-html'] === '1') {
+            res.setHeader('Content-Type', 'text/html; charset=utf-8');
+            res.end('<!doctype html><html><body>console</body></html>');
+            return;
+        }
+        if (url === '/v1/orgs' && req.headers['x-test-html'] === '2') {
+            // HTML with a JSON content-type still has to be rejected by body sniffing.
+            res.setHeader('Content-Type', 'application/json');
+            res.end('<html><body>console</body></html>');
+            return;
+        }
+        if (url === '/v1/flaky') {
+            const n = hits.get(url) || 0;
+            if (n < 3) {
+                res.statusCode = 503;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: 'unavailable' }));
+                return;
+            }
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ ok: true, attempts: n }));
+            return;
+        }
+        if (url === '/v1/retry-after') {
+            const n = hits.get(url) || 0;
+            if (n === 1) {
+                res.statusCode = 429;
+                res.setHeader('Retry-After', '0');
+                res.end('{}');
+                return;
+            }
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
+        if (url === '/v1/slow') {
+            setTimeout(() => {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ ok: true }));
+            }, slowMs);
+            return;
+        }
+        if (url === '/v1/never') {
+            return; // leave the socket open
+        }
+        if (url === '/ready') {
+            res.statusCode = 503;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ status: 'degraded', service: 'gateway', version: '0', upstreams: [{ name: 'base', ok: false }], time: 't' }));
+            return;
+        }
+        if (url === '/health') {
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ status: 'ok', service: 'gateway', version: '0', time: 't' }));
+            return;
+        }
+        if (url === '/v1/inference/chat/completions') {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.write('data: {"choices":[{"delta":{"content":"he"}}]}\n\n');
+            res.write('event: done\ndata: [DONE]\n\n');
+            res.end();
+            return;
+        }
+        res.setHeader('Content-Type', 'application/json');
+        res.end(JSON.stringify({ ok: true, path: url }));
+    })
+        .listen(0, '127.0.0.1', () => {
+        const a = server.address();
+        base = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        resolve();
+    });
+}));
+(0, node_test_1.after)(() => new Promise((resolve) => server.close(() => resolve())));
+(0, node_test_1.describe)('transport', () => {
+    (0, node_test_1.it)('exposes the API gateway as the default URL constant', () => {
+        strict_1.default.equal(index_1.DEFAULT_BASE_URL, 'https://api.synapseone.space');
+    });
+    (0, node_test_1.it)('rejects a 200 text/html response with a typed error naming the base URL', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 1 });
+        let err;
+        try {
+            await c.http.req('/v1/orgs', { headers: { 'x-test-html': '1' } });
+            strict_1.default.fail('expected a typed error');
+        }
+        catch (e) {
+            err = e;
+        }
+        strict_1.default.ok(err instanceof index_1.SynapseOneError);
+        strict_1.default.equal(err.code, 'non_json_response');
+        strict_1.default.equal(err.status, 200);
+        strict_1.default.match(err.message, /api\.synapseone\.space/);
+        strict_1.default.equal(err.baseUrl, base);
+    });
+    (0, node_test_1.it)('rejects HTML bodies even when the content type says JSON', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 1 });
+        await strict_1.default.rejects(() => c.http.req('/v1/orgs', { headers: { 'x-test-html': '2' } }), (e) => e instanceof index_1.SynapseOneError && e.code === 'non_json_response');
+    });
+    (0, node_test_1.it)('retries idempotent requests on 503 and eventually succeeds', async () => {
+        hits.delete('/v1/flaky');
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 3, retryBaseMs: 1 });
+        const out = await c.http.req('/v1/flaky');
+        strict_1.default.equal(out.ok, true);
+        strict_1.default.equal(hits.get('/v1/flaky'), 3);
+    });
+    (0, node_test_1.it)('stops after maxAttempts and surfaces the last status', async () => {
+        hits.delete('/v1/flaky');
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 2, retryBaseMs: 1 });
+        await strict_1.default.rejects(() => c.http.req('/v1/flaky'), (e) => e.status === 503);
+        strict_1.default.equal(hits.get('/v1/flaky'), 2);
+    });
+    (0, node_test_1.it)('honours Retry-After', async () => {
+        hits.delete('/v1/retry-after');
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 2, retryBaseMs: 5 });
+        const out = await c.http.req('/v1/retry-after');
+        strict_1.default.equal(out.ok, true);
+        strict_1.default.equal(hits.get('/v1/retry-after'), 2);
+    });
+    (0, node_test_1.it)('does not retry non-idempotent POSTs unless asked', async () => {
+        hits.delete('/v1/flaky');
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 3, retryBaseMs: 1 });
+        await strict_1.default.rejects(() => c.http.req('/v1/flaky', { method: 'POST', body: '{}' }), (e) => e.status === 503);
+        strict_1.default.equal(hits.get('/v1/flaky'), 1);
+    });
+    (0, node_test_1.it)('applies a per-call timeout override', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 1 });
+        const started = Date.now();
+        await strict_1.default.rejects(() => c.http.req('/v1/never', undefined, { timeoutMs: 50 }), (e) => e instanceof index_1.SynapseOneError && e.code === 'timeout');
+        strict_1.default.ok(Date.now() - started < 2000);
+    });
+    (0, node_test_1.it)('supports a caller AbortSignal', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 1 });
+        const ctl = new AbortController();
+        setTimeout(() => ctl.abort(), 20);
+        await strict_1.default.rejects(() => c.http.req('/v1/never', undefined, { timeoutMs: 5000, signal: ctl.signal }), (e) => e.code === 'timeout' || e.code === 'network_error');
+    });
+    (0, node_test_1.it)('returns a degraded readiness payload instead of throwing (default)', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 1 });
+        const ready = await c.health.ready();
+        strict_1.default.equal(ready.status, 'degraded');
+        strict_1.default.equal(ready.upstreams[0].name, 'base');
+        await strict_1.default.rejects(() => c.health.ready({ throwOnDegraded: true }), (e) => e.status === 503);
+    });
+    (0, node_test_1.it)('projects status() into ok/tier1/upstreams', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 1 });
+        const status = await c.health.status();
+        strict_1.default.equal(status.ok, false);
+        strict_1.default.equal(status.tier1.reachable, true);
+        strict_1.default.equal(status.upstreams.length, 1);
+    });
+    (0, node_test_1.it)('streams SSE chat deltas without buffering', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base, maxAttempts: 1 });
+        const events = [];
+        for await (const ev of c.inference.chatStream([{ role: 'user', content: 'hi' }])) {
+            events.push(ev.data);
+        }
+        strict_1.default.equal(events.length, 2);
+        strict_1.default.equal((0, index_1.parseChatDelta)(events[0]), 'he');
+        strict_1.default.equal((0, index_1.parseChatDelta)(events[1]), null);
+    });
+    (0, node_test_1.it)('all documented package subpaths resolve', () => {
+        const pkg = requireCjs(node_path_1.default.join(__dirname, '..', 'package.json'));
+        const expected = ['.', './iam', './workflow', './ai', './lds', './base', './faststore', './queue', './stream', './inference', './health', './storage', './notifications'];
+        for (const sub of expected) {
+            strict_1.default.ok(pkg.exports[sub], `missing exports entry ${sub}`);
+            const target = node_path_1.default.join(__dirname, '..', pkg.exports[sub].require);
+            strict_1.default.doesNotThrow(() => requireCjs(target), `cannot require ${sub}`);
+        }
+    });
+});

package/dist/workflow.d.ts

@@ -54,9 +54,14 @@ export declare class WorkflowService {
      * Fire a public inbound webhook through the gateway: `ANY /webhook/:path`.
      * No auth is required; per-workflow auth/rate-limit/idempotency still apply.
      * `path` is the webhook node's `parameters.path`, not a workflow id.
+     *
+     * The gateway allows 300s for `/webhook`; this call uses that budget unless
+     * `init.timeoutMs` overrides it.
      */
     triggerWebhook(path: string, payload?: unknown, init?: {
         method?: string;
+        timeoutMs?: number;
+        signal?: AbortSignal;
     }): Promise<unknown>;
 }
 /** Normalize GET /v1/credentials: the API returns `{data: []}`. */
@@ -79,4 +84,5 @@ export declare function unwrapExecutions(payload: any): any[];
 export declare function triggerWebhook(webhookBaseUrl: string, path: string, payload?: unknown, init?: {
     method?: string;
     timeoutMs?: number;
+    signal?: AbortSignal;
 }): Promise<any>;