@kognitivedev/cloud-web-search 0.2.28

package/dist/client.js

@@ -0,0 +1,516 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KognitiveCloudWebSearchClient = void 0;
+exports.readCloudWebSearchEventStream = readCloudWebSearchEventStream;
+const client_core_1 = require("@kognitivedev/client-core");
+const errors_1 = require("./errors");
+const rich_events_1 = require("./rich-events");
+const sse_1 = require("./sse");
+const validation_1 = require("./validation");
+const TERMINAL_STATUSES = new Set(["completed", "error", "cancelled"]);
+const NON_PROGRESS_EVENT_TYPES = new Set([
+    "job.completed",
+    "job.failed",
+    "job.error",
+    "job.cancelled",
+    "websearch.research.answer.delta",
+    "websearch.research.reasoning",
+    "websearch.research.status",
+    "websearch.research.todo.generated",
+    "websearch.research.answer.completed",
+]);
+function isTransportLike(value) {
+    return Boolean(value
+        && typeof value === "object"
+        && "baseUrl" in value
+        && "json" in value
+        && "raw" in value
+        && "poll" in value);
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (value instanceof Date) {
+        return JSON.stringify(value.toISOString());
+    }
+    if ((0, validation_1.isPlainObject)(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function toProgressFingerprint(progress) {
+    return stableStringify({
+        stage: progress.stage,
+        message: progress.message,
+        timestamp: progress.timestamp,
+    });
+}
+function rememberProgress(seenProgress, progress, eventId) {
+    const progressKey = `progress:${toProgressFingerprint(progress)}`;
+    const eventKey = eventId ? `event:${eventId}` : null;
+    const duplicate = seenProgress.has(progressKey) || (eventKey ? seenProgress.has(eventKey) : false);
+    seenProgress.add(progressKey);
+    if (eventKey) {
+        seenProgress.add(eventKey);
+    }
+    return !duplicate;
+}
+function normalizeTimestamp(value) {
+    return typeof value === "string" ? value : value.toISOString();
+}
+function deriveStatusFromRecord(record, fallback) {
+    if ((0, validation_1.isJobStatus)(record.status)) {
+        return record.status;
+    }
+    switch (record.eventType) {
+        case "job.created":
+            return "queued";
+        case "job.started":
+            return "in_progress";
+        case "job.completed":
+            return "completed";
+        case "job.failed":
+        case "job.error":
+            return "error";
+        case "job.cancelled":
+            return "cancelled";
+        default:
+            return fallback !== null && fallback !== void 0 ? fallback : "in_progress";
+    }
+}
+function toProgressEntry(record) {
+    if (typeof record.stage !== "string" || typeof record.message !== "string") {
+        return null;
+    }
+    const payload = (0, validation_1.isPlainObject)(record.payload) ? (0, validation_1.cloneUnknown)(record.payload) : undefined;
+    return Object.assign({ stage: record.stage, message: record.message, timestamp: normalizeTimestamp(record.createdAt) }, (payload ? { metadata: payload } : {}));
+}
+function shouldEmitProgress(record) {
+    if (typeof record.stage !== "string" || typeof record.message !== "string") {
+        return false;
+    }
+    if (NON_PROGRESS_EVENT_TYPES.has(record.eventType)) {
+        return false;
+    }
+    if (record.eventType.startsWith("websearch.workflow.")) {
+        return false;
+    }
+    return true;
+}
+function assertJobId(jobId, path = "jobId") {
+    const value = jobId.trim();
+    if (!value) {
+        throw new errors_1.CloudWebSearchValidationError(path, "non-empty string", jobId);
+    }
+    return value;
+}
+function rememberObservedJobId(observedJobId, nextJobId, path) {
+    if (observedJobId && observedJobId !== nextJobId) {
+        throw new errors_1.CloudWebSearchValidationError(path, `jobId "${observedJobId}"`, nextJobId);
+    }
+    return nextJobId;
+}
+function extractResultFromPayload(payload, options, path = "event.payload") {
+    if (payload === undefined || payload === null) {
+        return null;
+    }
+    if ((0, validation_1.isPlainObject)(payload) && "result" in payload) {
+        return payload.result === null
+            ? null
+            : (0, validation_1.decodeCloudWebSearchResult)(payload.result, options, `${path}.result`);
+    }
+    return (0, validation_1.decodeCloudWebSearchResult)(payload, options, path);
+}
+function extractErrorMessage(payload, fallback) {
+    if ((0, validation_1.isPlainObject)(payload) && typeof payload.errorMessage === "string" && payload.errorMessage.trim()) {
+        return payload.errorMessage;
+    }
+    if ((0, validation_1.isPlainObject)(payload) && typeof payload.reason === "string" && payload.reason.trim()) {
+        return payload.reason;
+    }
+    return fallback;
+}
+function applyLifecycleUpdate(job, record, options) {
+    var _a;
+    if (!job) {
+        return;
+    }
+    job.updatedAt = normalizeTimestamp(record.createdAt);
+    switch (record.eventType) {
+        case "job.created":
+            job.status = "queued";
+            break;
+        case "job.started":
+            job.status = "in_progress";
+            break;
+        case "job.completed":
+            job.status = "completed";
+            job.results = extractResultFromPayload(record.payload, options, `stream.${record.eventType}.payload`);
+            job.errorMessage = null;
+            break;
+        case "job.failed":
+        case "job.error":
+            job.status = "error";
+            job.errorMessage = extractErrorMessage(record.payload, (_a = record.message) !== null && _a !== void 0 ? _a : "Web search job failed");
+            break;
+        case "job.cancelled":
+            job.status = "cancelled";
+            job.errorMessage = "Job cancelled";
+            break;
+        default:
+            break;
+    }
+}
+function createSearchJobInput(input, parameters) {
+    if (typeof input === "string") {
+        return Object.assign({ mode: "search", query: input }, (parameters ? { parameters } : {}));
+    }
+    return Object.assign({ mode: "search", query: input.query }, (input.parameters ? { parameters: input.parameters } : {}));
+}
+function createResearchJobInput(input, options) {
+    if (typeof input === "string") {
+        return Object.assign(Object.assign(Object.assign({ mode: "research", instructions: input }, ((options === null || options === void 0 ? void 0 : options.responseInstructions) ? { responseInstructions: options.responseInstructions } : {})), ((options === null || options === void 0 ? void 0 : options.responseSchema) ? { responseSchema: options.responseSchema } : {})), ((options === null || options === void 0 ? void 0 : options.parameters) ? { parameters: options.parameters } : {}));
+    }
+    return Object.assign(Object.assign(Object.assign({ mode: "research", instructions: input.instructions }, (input.responseInstructions ? { responseInstructions: input.responseInstructions } : {})), (input.responseSchema ? { responseSchema: input.responseSchema } : {})), (input.parameters ? { parameters: input.parameters } : {}));
+}
+function readCloudWebSearchEventStream(stream, options) {
+    return __asyncGenerator(this, arguments, function* readCloudWebSearchEventStream_1() {
+        var _a, e_1, _b, _c;
+        var _d, _e, _f;
+        let currentJob = null;
+        let observedJobId = null;
+        const seenProgress = new Set();
+        try {
+            for (var _g = true, _h = __asyncValues((0, sse_1.readSSEStream)(stream)), _j; _j = yield __await(_h.next()), _a = _j.done, !_a; _g = true) {
+                _c = _j.value;
+                _g = false;
+                const frame = _c;
+                let lifecycleDecodeError = null;
+                if (frame.event === "job.snapshot") {
+                    const payload = (0, validation_1.decodeJobSnapshotPayload)(frame.data, options, "stream.job.snapshot");
+                    observedJobId = rememberObservedJobId(observedJobId, payload.job.id, "stream.job.snapshot.job.id");
+                    currentJob = (0, validation_1.cloneUnknown)(payload.job);
+                    yield yield __await({
+                        type: "snapshot",
+                        job: (0, validation_1.cloneUnknown)(currentJob),
+                    });
+                    for (const progress of currentJob.progress) {
+                        if (!rememberProgress(seenProgress, progress)) {
+                            continue;
+                        }
+                        yield yield __await({
+                            type: "progress",
+                            jobId: currentJob.id,
+                            job: (0, validation_1.cloneUnknown)(currentJob),
+                            status: currentJob.status,
+                            progress: (0, validation_1.cloneUnknown)(progress),
+                            replay: true,
+                        });
+                    }
+                    continue;
+                }
+                if (frame.event === "job.keepalive") {
+                    const payload = (0, validation_1.decodeKeepalivePayload)(frame.data, "stream.job.keepalive");
+                    observedJobId = rememberObservedJobId(observedJobId, payload.jobId, "stream.job.keepalive.jobId");
+                    yield yield __await({
+                        type: "keepalive",
+                        jobId: payload.jobId,
+                        timestamp: payload.timestamp,
+                    });
+                    continue;
+                }
+                if (frame.event === "job.progress") {
+                    try {
+                        const payload = (0, validation_1.decodeDirectProgressPayload)(frame.data, "stream.job.progress");
+                        observedJobId = rememberObservedJobId(observedJobId, payload.jobId, "stream.job.progress.jobId");
+                        if (!rememberProgress(seenProgress, payload.progress, frame.id)) {
+                            continue;
+                        }
+                        if (currentJob && currentJob.id === payload.jobId) {
+                            currentJob.status = payload.status;
+                            currentJob.progress.push((0, validation_1.cloneUnknown)(payload.progress));
+                            currentJob.updatedAt = payload.progress.timestamp;
+                        }
+                        yield yield __await(Object.assign({ type: "progress", jobId: payload.jobId, job: (0, validation_1.cloneUnknown)(currentJob), status: payload.status, progress: (0, validation_1.cloneUnknown)(payload.progress) }, (frame.id ? { eventId: frame.id } : {})));
+                        continue;
+                    }
+                    catch (error) {
+                        if (!(error instanceof errors_1.CloudWebSearchValidationError)) {
+                            throw error;
+                        }
+                        lifecycleDecodeError = error;
+                    }
+                }
+                if (frame.event === "job.completed") {
+                    try {
+                        const payload = (0, validation_1.decodeDirectCompletedPayload)(frame.data, options, "stream.job.completed");
+                        observedJobId = rememberObservedJobId(observedJobId, payload.job.id, "stream.job.completed.job.id");
+                        currentJob = (0, validation_1.cloneUnknown)(payload.job);
+                        currentJob.status = "completed";
+                        currentJob.results = (0, validation_1.cloneUnknown)(payload.result);
+                        yield yield __await(Object.assign({ type: "completed", jobId: payload.job.id, job: (0, validation_1.cloneUnknown)(currentJob), result: (0, validation_1.cloneUnknown)(payload.result) }, (frame.id ? { eventId: frame.id } : {})));
+                        continue;
+                    }
+                    catch (error) {
+                        if (!(error instanceof errors_1.CloudWebSearchValidationError)) {
+                            throw error;
+                        }
+                        lifecycleDecodeError = error;
+                    }
+                }
+                if (frame.event === "job.error" || frame.event === "job.failed") {
+                    try {
+                        const payload = (0, validation_1.decodeDirectErrorPayload)(frame.data, options, `stream.${frame.event}`);
+                        observedJobId = rememberObservedJobId(observedJobId, payload.job.id, `stream.${frame.event}.job.id`);
+                        currentJob = (0, validation_1.cloneUnknown)(payload.job);
+                        currentJob.status = "error";
+                        currentJob.errorMessage = payload.errorMessage;
+                        yield yield __await(Object.assign({ type: "error", jobId: payload.job.id, job: (0, validation_1.cloneUnknown)(currentJob), errorMessage: payload.errorMessage }, (frame.id ? { eventId: frame.id } : {})));
+                        continue;
+                    }
+                    catch (error) {
+                        if (!(error instanceof errors_1.CloudWebSearchValidationError)) {
+                            throw error;
+                        }
+                        lifecycleDecodeError = error;
+                    }
+                }
+                if (frame.event === "job.cancelled") {
+                    try {
+                        const payload = (0, validation_1.decodeDirectCancelledPayload)(frame.data, options, "stream.job.cancelled");
+                        observedJobId = rememberObservedJobId(observedJobId, payload.job.id, "stream.job.cancelled.job.id");
+                        currentJob = (0, validation_1.cloneUnknown)(payload.job);
+                        currentJob.status = "cancelled";
+                        currentJob.errorMessage = (_d = currentJob.errorMessage) !== null && _d !== void 0 ? _d : "Job cancelled";
+                        yield yield __await(Object.assign({ type: "cancelled", jobId: payload.job.id, job: (0, validation_1.cloneUnknown)(currentJob) }, (frame.id ? { eventId: frame.id } : {})));
+                        continue;
+                    }
+                    catch (error) {
+                        if (!(error instanceof errors_1.CloudWebSearchValidationError)) {
+                            throw error;
+                        }
+                        lifecycleDecodeError = error;
+                    }
+                }
+                let record = null;
+                try {
+                    record = (0, validation_1.decodeCloudWebSearchJobEventRecord)(frame.data, `stream.${frame.event}`);
+                }
+                catch (error) {
+                    if (lifecycleDecodeError) {
+                        throw lifecycleDecodeError;
+                    }
+                    if (error instanceof errors_1.CloudWebSearchValidationError) {
+                        yield yield __await({
+                            type: "unknown",
+                            job: (0, validation_1.cloneUnknown)(currentJob),
+                            frame: (0, validation_1.cloneUnknown)(frame),
+                        });
+                        continue;
+                    }
+                    throw error;
+                }
+                observedJobId = rememberObservedJobId(observedJobId, record.jobId, `stream.${frame.event}.jobId`);
+                applyLifecycleUpdate(currentJob, record, options);
+                if (shouldEmitProgress(record)) {
+                    const progress = toProgressEntry(record);
+                    if (progress && rememberProgress(seenProgress, progress, record.id)) {
+                        if (currentJob && currentJob.id === record.jobId) {
+                            currentJob.status = deriveStatusFromRecord(record, currentJob.status);
+                            currentJob.progress.push((0, validation_1.cloneUnknown)(progress));
+                            currentJob.updatedAt = progress.timestamp;
+                        }
+                        yield yield __await({
+                            type: "progress",
+                            jobId: record.jobId,
+                            job: (0, validation_1.cloneUnknown)(currentJob),
+                            status: deriveStatusFromRecord(record, currentJob === null || currentJob === void 0 ? void 0 : currentJob.status),
+                            progress: (0, validation_1.cloneUnknown)(progress),
+                            eventId: record.id,
+                            rawEventType: record.eventType,
+                            raw: (0, validation_1.cloneUnknown)(record),
+                        });
+                    }
+                    continue;
+                }
+                if (record.eventType === "job.completed") {
+                    yield yield __await({
+                        type: "completed",
+                        jobId: record.jobId,
+                        job: (0, validation_1.cloneUnknown)(currentJob),
+                        result: (0, validation_1.cloneUnknown)((_e = currentJob === null || currentJob === void 0 ? void 0 : currentJob.results) !== null && _e !== void 0 ? _e : extractResultFromPayload(record.payload, options, `stream.${record.eventType}.payload`)),
+                        eventId: record.id,
+                        raw: (0, validation_1.cloneUnknown)(record),
+                    });
+                    continue;
+                }
+                if (record.eventType === "job.failed" || record.eventType === "job.error") {
+                    yield yield __await({
+                        type: "error",
+                        jobId: record.jobId,
+                        job: (0, validation_1.cloneUnknown)(currentJob),
+                        errorMessage: (_f = currentJob === null || currentJob === void 0 ? void 0 : currentJob.errorMessage) !== null && _f !== void 0 ? _f : extractErrorMessage(record.payload, "Web search job failed"),
+                        eventId: record.id,
+                        raw: (0, validation_1.cloneUnknown)(record),
+                    });
+                    continue;
+                }
+                if (record.eventType === "job.cancelled") {
+                    yield yield __await({
+                        type: "cancelled",
+                        jobId: record.jobId,
+                        job: (0, validation_1.cloneUnknown)(currentJob),
+                        eventId: record.id,
+                        raw: (0, validation_1.cloneUnknown)(record),
+                    });
+                    continue;
+                }
+                yield yield __await({
+                    type: "event",
+                    jobId: record.jobId,
+                    job: (0, validation_1.cloneUnknown)(currentJob),
+                    event: (0, validation_1.cloneUnknown)(record),
+                });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_g && !_a && (_b = _h.return)) yield __await(_b.call(_h));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+class KognitiveCloudWebSearchClient {
+    constructor(config) {
+        this.jobs = {
+            list: (options) => this.listJobs(options),
+            create: (input) => this.createJob(input),
+            createSearch: (input, parameters) => this.createSearchJob(input, parameters),
+            createResearch: (input, options) => this.createResearchJob(input, options),
+            get: (jobId, options) => this.getJob(jobId, options),
+            result: (jobId, options) => this.getJobResult(jobId, options),
+            cancel: (jobId, options) => this.cancelJob(jobId, options),
+            stream: (jobId, init) => this.streamJob(jobId, init),
+            subscribe: (jobId, options) => this.subscribeToJob(jobId, options),
+            subscribeRich: (jobId, options) => this.subscribeToRichJob(jobId, options),
+            streamUrl: (jobId) => this.getJobEventsStreamUrl(jobId),
+            waitForCompletion: (jobId, options) => this.waitForCompletion(jobId, options),
+        };
+        this.transport = isTransportLike(config) ? config : new client_core_1.HttpTransport(config);
+    }
+    getJobEventsStreamUrl(jobId) {
+        return `${this.transport.baseUrl}/api/cloud/web-search/jobs/${encodeURIComponent(assertJobId(jobId))}/events/stream`;
+    }
+    async listJobs(options) {
+        const response = await this.transport.json("/api/cloud/web-search/jobs");
+        return (0, validation_1.decodeCloudWebSearchJobListEnvelope)(response, options).jobs;
+    }
+    async createJob(input) {
+        const body = (0, validation_1.validateCreateCloudWebSearchJobInput)(input);
+        const response = await this.transport.json("/api/cloud/web-search/jobs", {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+        return (0, validation_1.decodeCloudWebSearchJobRecord)(response, undefined, "jobs.create");
+    }
+    async createSearchJob(input, parameters) {
+        return this.createJob(createSearchJobInput(input, parameters));
+    }
+    async createResearchJob(input, options) {
+        return this.createJob(createResearchJobInput(input, options));
+    }
+    async getJob(jobId, options) {
+        const response = await this.transport.json(`/api/cloud/web-search/jobs/${encodeURIComponent(assertJobId(jobId))}`);
+        return (0, validation_1.decodeCloudWebSearchJobRecord)(response, options, "jobs.get");
+    }
+    async getJobResult(jobId, options) {
+        const response = await this.transport.json(`/api/cloud/web-search/jobs/${encodeURIComponent(assertJobId(jobId))}/result`);
+        return (0, validation_1.decodeCloudWebSearchJobResultEnvelope)(response, options, "jobs.result");
+    }
+    async cancelJob(jobId, options) {
+        const response = await this.transport.json(`/api/cloud/web-search/jobs/${encodeURIComponent(assertJobId(jobId))}/cancel`, {
+            method: "POST",
+        });
+        return (0, validation_1.decodeCloudWebSearchJobRecord)(response, options, "jobs.cancel");
+    }
+    async streamJob(jobId, init) {
+        return this.transport.raw(`/api/cloud/web-search/jobs/${encodeURIComponent(assertJobId(jobId))}/events/stream`, init);
+    }
+    async subscribeToJob(jobId, options) {
+        const response = await this.streamJob(jobId, options === null || options === void 0 ? void 0 : options.init);
+        if (!response.body) {
+            throw new errors_1.CloudWebSearchStreamProtocolError("Cloud web-search stream response did not include a body");
+        }
+        return readCloudWebSearchEventStream(response.body, options);
+    }
+    async subscribeToRichJob(jobId, options) {
+        const events = await this.subscribeToJob(jobId, options);
+        function richStream() {
+            return __asyncGenerator(this, arguments, function* richStream_1() {
+                var _a, e_2, _b, _c;
+                try {
+                    for (var _d = true, events_1 = __asyncValues(events), events_1_1; events_1_1 = yield __await(events_1.next()), _a = events_1_1.done, !_a; _d = true) {
+                        _c = events_1_1.value;
+                        _d = false;
+                        const event = _c;
+                        for (const richEvent of (0, rich_events_1.toCloudWebSearchRichEvents)(event)) {
+                            yield yield __await(richEvent);
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = events_1.return)) yield __await(_b.call(events_1));
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            });
+        }
+        return richStream();
+    }
+    async waitForCompletion(jobId, options) {
+        var _a, _b;
+        const normalizedJobId = assertJobId(jobId);
+        const job = await this.transport.poll(() => this.getJob(normalizedJobId, options), {
+            intervalMs: options === null || options === void 0 ? void 0 : options.intervalMs,
+            timeoutMs: options === null || options === void 0 ? void 0 : options.timeoutMs,
+            isDone: (value) => TERMINAL_STATUSES.has(value.status),
+        });
+        if (job.status === "completed") {
+            const envelope = await this.getJobResult(normalizedJobId, options);
+            return {
+                job,
+                result: envelope.result,
+            };
+        }
+        if (job.status === "cancelled") {
+            throw new Error((_a = job.errorMessage) !== null && _a !== void 0 ? _a : `Web search job ${normalizedJobId} was cancelled`);
+        }
+        throw new Error((_b = job.errorMessage) !== null && _b !== void 0 ? _b : `Web search job ${normalizedJobId} finished with status ${job.status}`);
+    }
+}
+exports.KognitiveCloudWebSearchClient = KognitiveCloudWebSearchClient;

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class CloudWebSearchValidationError extends Error {
+    readonly path: string;
+    readonly expected: string;
+    readonly actual: unknown;
+    constructor(path: string, expected: string, actual: unknown);
+}
+export declare class CloudWebSearchStreamProtocolError extends Error {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWebSearchStreamProtocolError = exports.CloudWebSearchValidationError = void 0;
+class CloudWebSearchValidationError extends Error {
+    constructor(path, expected, actual) {
+        super(`Invalid cloud web-search payload at ${path}: expected ${expected}`);
+        this.name = "CloudWebSearchValidationError";
+        this.path = path;
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+exports.CloudWebSearchValidationError = CloudWebSearchValidationError;
+class CloudWebSearchStreamProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CloudWebSearchStreamProtocolError";
+    }
+}
+exports.CloudWebSearchStreamProtocolError = CloudWebSearchStreamProtocolError;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { KognitiveCloudWebSearchClient, readCloudWebSearchEventStream } from "./client";
+export { CloudWebSearchStreamProtocolError, CloudWebSearchValidationError } from "./errors";
+export { toCloudWebSearchRichEvents } from "./rich-events";
+export { readSSEStream } from "./sse";
+export type { ParsedSSEEvent } from "./sse";
+export type { CloudWebSearchClientConfig, CloudWebSearchDecodeOptions, CloudWebSearchExecutionParameters, CloudWebSearchJobEventRecord, CloudWebSearchJobRecord, CloudWebSearchJobResultEnvelope, CloudWebSearchJobStatus, CloudWebSearchJobWaitResult, CloudWebSearchMode, CloudWebSearchOutputParser, CloudWebSearchProductAnswer, CloudWebSearchProgressEntry, CloudWebSearchRichEvent, CloudWebSearchRichSource, CloudWebSearchResearchJobInput, CloudWebSearchResult, CloudWebSearchSearchJobInput, CloudWebSearchSource, CloudWebSearchStreamEvent, CloudWebSearchSubscribeOptions, CloudWebSearchTimeRange, CreateCloudWebSearchJobInput, LogLevel, ResearchPlan, ResearchPlanTodo, WaitForCompletionOptions, } from "./types";

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSSEStream = exports.toCloudWebSearchRichEvents = exports.CloudWebSearchValidationError = exports.CloudWebSearchStreamProtocolError = exports.readCloudWebSearchEventStream = exports.KognitiveCloudWebSearchClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "KognitiveCloudWebSearchClient", { enumerable: true, get: function () { return client_1.KognitiveCloudWebSearchClient; } });
+Object.defineProperty(exports, "readCloudWebSearchEventStream", { enumerable: true, get: function () { return client_1.readCloudWebSearchEventStream; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "CloudWebSearchStreamProtocolError", { enumerable: true, get: function () { return errors_1.CloudWebSearchStreamProtocolError; } });
+Object.defineProperty(exports, "CloudWebSearchValidationError", { enumerable: true, get: function () { return errors_1.CloudWebSearchValidationError; } });
+var rich_events_1 = require("./rich-events");
+Object.defineProperty(exports, "toCloudWebSearchRichEvents", { enumerable: true, get: function () { return rich_events_1.toCloudWebSearchRichEvents; } });
+var sse_1 = require("./sse");
+Object.defineProperty(exports, "readSSEStream", { enumerable: true, get: function () { return sse_1.readSSEStream; } });

package/dist/rich-events.d.ts

@@ -0,0 +1,2 @@
+import type { CloudWebSearchRichEvent, CloudWebSearchStreamEvent } from "./types";
+export declare function toCloudWebSearchRichEvents<TOutput = unknown>(event: CloudWebSearchStreamEvent<TOutput>): CloudWebSearchRichEvent<TOutput>[];