@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/transports/http.js

@@ -0,0 +1,406 @@
+import { getOperatorContract, getPeerContract } from '@pellux/goodvibes-sdk/contracts';
+import { createClientTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/client-transport';
+import { createHttpJsonTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
+import { appendTelemetryQuery, buildSessionEnsureBody, buildSessionMessageBody, buildSteerSessionMessageBody, buildTaskSubmitBody, buildTransportUrl, connectTelemetryStream, createJsonRequestInit, normalizeTelemetryQuery, readControlPlaneSnapshot, } from './http-helpers.js';
+import { createOperatorRemoteClient } from '@pellux/goodvibes-sdk/platform/runtime/transports/operator-remote-client';
+import { createPeerRemoteClient } from '@pellux/goodvibes-sdk/platform/runtime/transports/peer-remote-client';
+import { createEventSourceConnector, requestJson, } from './shared.js';
+import { createRemoteUiRuntimeEvents } from './ui-runtime-events.js';
+function isNotFoundError(error) {
+    return Boolean(typeof error === 'object'
+        && error !== null
+        && 'transport' in error
+        && typeof error.transport?.status === 'number'
+        && error.transport?.status === 404);
+}
+async function withNullOnNotFound(run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+}
+function asContractInput(input) {
+    return input;
+}
+function normalizeSharedSessionRecord(record) {
+    const candidate = record;
+    return {
+        ...candidate,
+        surfaceKinds: (candidate.surfaceKinds ?? []),
+        participants: (candidate.participants ?? []).map((participant) => ({
+            ...participant,
+            surfaceKind: participant.surfaceKind,
+        })),
+    };
+}
+function normalizeSharedSessionMessage(message, fallbackInput) {
+    if (message && typeof message === 'object') {
+        const candidate = message;
+        return {
+            ...candidate,
+            surfaceKind: candidate.surfaceKind,
+        };
+    }
+    if (!fallbackInput) {
+        throw new Error('Shared session submission did not include a message');
+    }
+    return {
+        id: fallbackInput.causationId ?? `msg-${fallbackInput.id}`,
+        sessionId: fallbackInput.sessionId,
+        role: 'user',
+        body: fallbackInput.body,
+        createdAt: fallbackInput.createdAt,
+        surfaceKind: fallbackInput.surfaceKind,
+        surfaceId: fallbackInput.surfaceId,
+        routeId: fallbackInput.routeId,
+        userId: fallbackInput.userId,
+        displayName: fallbackInput.displayName,
+        metadata: fallbackInput.metadata,
+    };
+}
+function normalizeSharedSessionInput(record) {
+    const candidate = record;
+    return {
+        ...candidate,
+        surfaceKind: candidate.surfaceKind,
+    };
+}
+function normalizeSharedSessionSubmission(record) {
+    const sessionValue = record.session;
+    if (!sessionValue || typeof sessionValue !== 'object') {
+        throw new Error('Shared session submission did not include a session');
+    }
+    const inputValue = record.input;
+    if (!inputValue || typeof inputValue !== 'object') {
+        throw new Error('Shared session submission did not include an input');
+    }
+    const session = normalizeSharedSessionRecord(sessionValue);
+    const input = normalizeSharedSessionInput(inputValue);
+    return {
+        session,
+        userMessage: normalizeSharedSessionMessage(record.message ?? record.userMessage, input),
+        routeBinding: record.routeBinding,
+        input,
+        intent: input.intent,
+        mode: record.mode,
+        state: input.state,
+        task: typeof record.task === 'string' ? record.task : undefined,
+        activeAgentId: typeof record.agentId === 'string'
+            ? record.agentId
+            : typeof record.activeAgentId === 'string'
+                ? record.activeAgentId
+                : undefined,
+        created: Boolean(record.created),
+    };
+}
+function normalizeTelemetryQueryForSdk(query, defaultLimit) {
+    const normalized = normalizeTelemetryQuery(query, defaultLimit);
+    return {
+        ...(normalized.limit !== undefined ? { limit: normalized.limit } : {}),
+        ...(normalized.since !== undefined ? { since: normalized.since } : {}),
+        ...(normalized.until !== undefined ? { until: normalized.until } : {}),
+        ...(normalized.domains?.length ? { domains: normalized.domains.join(',') } : {}),
+        ...(normalized.eventTypes?.length ? { types: normalized.eventTypes.join(',') } : {}),
+        ...(normalized.severity ? { severity: normalized.severity } : {}),
+        ...(normalized.traceId ? { traceId: normalized.traceId } : {}),
+        ...(normalized.sessionId ? { sessionId: normalized.sessionId } : {}),
+        ...(normalized.turnId ? { turnId: normalized.turnId } : {}),
+        ...(normalized.agentId ? { agentId: normalized.agentId } : {}),
+        ...(normalized.taskId ? { taskId: normalized.taskId } : {}),
+        ...(normalized.cursor ? { cursor: normalized.cursor } : {}),
+        ...(normalized.view ? { view: normalized.view } : {}),
+    };
+}
+function createOperatorClient(transport, events) {
+    const paths = transport.paths;
+    const token = transport.authToken ?? null;
+    const fetchImpl = transport.fetchImpl;
+    const operatorApi = createOperatorRemoteClient(transport, getOperatorContract());
+    return {
+        sessions: {
+            current: async () => await requestJson(fetchImpl, buildTransportUrl(paths.controlPlaneUrl, '/api/session'), createJsonRequestInit(token)),
+            list: async (limit = 100) => (await operatorApi.sessions.list({ limit })).sessions.map((entry) => normalizeSharedSessionRecord(entry)),
+            get: async (sessionId) => {
+                const response = await withNullOnNotFound(() => operatorApi.sessions.get(sessionId));
+                return response?.session ? normalizeSharedSessionRecord(response.session) : null;
+            },
+            messages: async (sessionId, limit = 100) => (await operatorApi.sessions.messages.list(sessionId, { limit })).messages.map((entry) => normalizeSharedSessionMessage(entry)),
+            inputs: async (sessionId, limit = 100) => {
+                const response = await operatorApi.invoke('sessions.inputs.list', { sessionId, limit });
+                return (response.inputs ?? []).map((entry) => normalizeSharedSessionInput(entry));
+            },
+            ensureSession: async (input = {}) => normalizeSharedSessionRecord((await operatorApi.sessions.create(buildSessionEnsureBody(input))).session),
+            close: async (sessionId) => {
+                const response = await withNullOnNotFound(() => operatorApi.sessions.close(sessionId));
+                return response?.session ? normalizeSharedSessionRecord(response.session) : null;
+            },
+            reopen: async (sessionId) => {
+                const response = await withNullOnNotFound(() => operatorApi.sessions.reopen(sessionId));
+                return response?.session ? normalizeSharedSessionRecord(response.session) : null;
+            },
+            submitMessage: async (sessionId, input) => normalizeSharedSessionSubmission(await operatorApi.invoke('sessions.messages.create', { sessionId, ...buildSessionMessageBody(input) })),
+            steerMessage: async (sessionId, input) => normalizeSharedSessionSubmission(await operatorApi.invoke('sessions.steer', { sessionId, ...buildSteerSessionMessageBody(input) })),
+            followUpMessage: async (sessionId, input) => normalizeSharedSessionSubmission(await operatorApi.invoke('sessions.followUp', { sessionId, ...buildSessionMessageBody(input) })),
+            cancelInput: async (sessionId, inputId) => {
+                const response = await withNullOnNotFound(() => operatorApi.sessions.inputs.cancel(sessionId, inputId));
+                return response?.input ? normalizeSharedSessionInput(response.input) : null;
+            },
+        },
+        tasks: {
+            snapshot: async () => {
+                const { tasks } = await operatorApi.tasks.list();
+                return { tasks: tasks };
+            },
+            list: async (limit = 100) => (await operatorApi.tasks.list({ limit })).tasks,
+            get: async (taskId) => {
+                const response = await withNullOnNotFound(() => operatorApi.tasks.get(taskId));
+                return (response?.task ?? null);
+            },
+            running: async () => (await operatorApi.tasks.list()).tasks.filter((task) => task.status === 'running'),
+            submit: async (input) => await operatorApi.invoke('tasks.create', buildTaskSubmitBody(input)),
+            cancel: async (taskId) => await operatorApi.invoke('tasks.cancel', { taskId }),
+            retry: async (taskId) => await operatorApi.invoke('tasks.retry', { taskId }),
+        },
+        approvals: {
+            list: async (limit = 100) => (await operatorApi.approvals.list({ limit })).approvals,
+            get: async (approvalId) => {
+                const approvals = await operatorApi.approvals.list({ limit: 200 });
+                return (approvals.approvals.find((entry) => entry.id === approvalId) ?? null);
+            },
+            claim: async (approvalId, actor, actorSurface = 'transport', note) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('approvals.claim', { approvalId, actor, actorSurface, ...(note ? { note } : {}) }));
+                return response?.approval ?? null;
+            },
+            approve: async (approvalId, actor, actorSurface = 'transport', note) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('approvals.approve', { approvalId, actor, actorSurface, ...(note ? { note } : {}) }));
+                return response?.approval ?? null;
+            },
+            deny: async (approvalId, actor, actorSurface = 'transport', note) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('approvals.deny', { approvalId, actor, actorSurface, ...(note ? { note } : {}) }));
+                return response?.approval ?? null;
+            },
+            cancel: async (approvalId, actor, actorSurface = 'transport', note) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('approvals.cancel', { approvalId, actor, actorSurface, ...(note ? { note } : {}) }));
+                return response?.approval ?? null;
+            },
+        },
+        providers: {
+            listIds: async () => (await operatorApi.providers.list()).providers.map((provider) => provider.providerId),
+            runtimeSnapshots: async () => (await operatorApi.providers.list()).providers,
+            runtimeSnapshot: async (providerId) => await withNullOnNotFound(() => operatorApi.providers.get(providerId)),
+            usageSnapshot: async (providerId) => await withNullOnNotFound(() => operatorApi.providers.usage(providerId)),
+            accountSnapshot: async () => await operatorApi.accounts.snapshot(),
+            localAuthSnapshot: async () => await operatorApi.localAuth.status(),
+            snapshot: async () => {
+                const [providerResponse, accountSnapshot, localAuthSnapshot] = await Promise.all([
+                    operatorApi.providers.list(),
+                    operatorApi.accounts.snapshot(),
+                    operatorApi.localAuth.status(),
+                ]);
+                const runtimeSnapshots = providerResponse.providers;
+                return {
+                    providerIds: runtimeSnapshots.map((provider) => provider.providerId),
+                    runtimeSnapshots,
+                    accountSnapshot,
+                    localAuthSnapshot: localAuthSnapshot,
+                };
+            },
+        },
+        controlPlane: {
+            snapshot: async () => await readControlPlaneSnapshot(fetchImpl, paths, token),
+            currentAuth: async () => await operatorApi.control.auth.current(),
+            recentEvents: async (limit = 6) => (await operatorApi.invoke('control.messages.list', { limit })).messages ?? [],
+        },
+        telemetry: {
+            snapshot: async (query = 20) => await operatorApi.telemetry.snapshot(normalizeTelemetryQueryForSdk(query, 20)),
+            events: async (query = 100) => await operatorApi.telemetry.events(normalizeTelemetryQueryForSdk(query, 100)),
+            errors: async (query = 100) => await operatorApi.telemetry.errors(normalizeTelemetryQueryForSdk(query, 100)),
+            traces: async (query = 100) => await operatorApi.telemetry.traces(normalizeTelemetryQueryForSdk(query, 100)),
+            metrics: async (query = 100) => await operatorApi.telemetry.metrics(normalizeTelemetryQueryForSdk(query, 100)),
+            otlpTraces: async (query = 100) => await operatorApi.telemetry.otlp.traces(normalizeTelemetryQueryForSdk(query, 100)),
+            otlpLogs: async (query = 100) => await operatorApi.telemetry.otlp.logs(normalizeTelemetryQueryForSdk(query, 100)),
+            otlpMetrics: async (query = 100) => await operatorApi.telemetry.otlp.metrics(normalizeTelemetryQueryForSdk(query, 100)),
+            stream: async (handlers, query = 100) => {
+                const normalized = normalizeTelemetryQuery(query, 100);
+                const url = new URL(paths.telemetryStreamUrl);
+                appendTelemetryQuery(url, normalized);
+                return await connectTelemetryStream(fetchImpl, url.toString(), token, handlers);
+            },
+        },
+        events,
+        shellPaths: paths,
+    };
+}
+function createPeerClient(transport) {
+    const operatorApi = createOperatorRemoteClient(transport, getOperatorContract());
+    const peerApi = createPeerRemoteClient(transport, getPeerContract());
+    function createPeerTokenClient(tokenValue) {
+        return createPeerRemoteClient(createHttpJsonTransport({
+            baseUrl: transport.baseUrl,
+            authToken: tokenValue,
+            fetchImpl: transport.fetchImpl,
+        }), getPeerContract());
+    }
+    async function readRemoteSnapshot() {
+        return await operatorApi.invoke('remote.snapshot');
+    }
+    async function readNodeHostContractValue() {
+        return (await operatorApi.invoke('remote.node_host.contract')).contract;
+    }
+    async function readPeers(limit = 500) {
+        return (await operatorApi.invoke('remote.peers.list', { limit })).peers ?? [];
+    }
+    return {
+        pairing: {
+            listRequests: async (limit = 100) => (await operatorApi.invoke('remote.pair.requests.list', { limit })).requests ?? [],
+            request: async (input) => await peerApi.invoke('pair.request', asContractInput(input)),
+            approve: async (requestId, actor, note) => await withNullOnNotFound(() => operatorApi.invoke('remote.pair.requests.approve', { requestId, actor, ...(note ? { note } : {}) })),
+            reject: async (requestId, actor, note) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('remote.pair.requests.reject', { requestId, actor, ...(note ? { note } : {}) }));
+                return response?.request ?? null;
+            },
+            verify: async (requestId, challenge, remoteAddress) => await withNullOnNotFound(() => peerApi.invoke('pair.verify', { requestId, challenge, ...(remoteAddress ? { remoteAddress } : {}) })),
+        },
+        peers: {
+            list: async (kind, limit = 200) => (await operatorApi.invoke('remote.peers.list', {
+                ...(kind ? { kind } : {}),
+                limit,
+            })).peers ?? [],
+            get: async (peerId) => {
+                const response = await operatorApi.invoke('remote.peers.list', { limit: 500 });
+                return (response.peers ?? []).find((peer) => peer.id === peerId) ?? null;
+            },
+            getSnapshot: async (peerId) => {
+                const [snapshot, contract, peers] = await Promise.all([
+                    readRemoteSnapshot(),
+                    readNodeHostContractValue(),
+                    readPeers(),
+                ]);
+                const pairRequests = (snapshot.distributed?.pairRequests ?? []).filter((entry) => entry.peerId === peerId || entry.requestedId === peerId);
+                const work = (snapshot.distributed?.work ?? []).filter((entry) => entry.peerId === peerId);
+                const peer = peers.find((entry) => entry.id === peerId) ?? null;
+                if (!peer && pairRequests.length === 0 && work.length === 0) {
+                    return null;
+                }
+                return {
+                    peerId,
+                    peer,
+                    pairRequests,
+                    work,
+                    nodeHostContract: contract,
+                };
+            },
+            heartbeat: async (tokenValue, input = {}) => await createPeerTokenClient(tokenValue).invoke('peer.heartbeat', asContractInput(input)),
+            rotateToken: async (peerId, actor, label, scopes) => await withNullOnNotFound(() => operatorApi.invoke('remote.peers.token.rotate', {
+                peerId,
+                actor,
+                ...(label ? { label } : {}),
+                ...(scopes ? { scopes } : {}),
+            })),
+            revokeToken: async (peerId, actor, tokenId, note) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('remote.peers.token.revoke', {
+                    peerId,
+                    actor,
+                    ...(tokenId ? { tokenId } : {}),
+                    ...(note ? { note } : {}),
+                }));
+                return response?.peer ?? null;
+            },
+            disconnect: async (peerId, actor, note, requeueClaimedWork = true) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('remote.peers.disconnect', {
+                    peerId,
+                    actor,
+                    ...(note ? { note } : {}),
+                    requeueClaimedWork,
+                }));
+                return response?.peer ?? null;
+            },
+        },
+        work: {
+            list: async (limit = 200, peerId) => (await operatorApi.invoke('remote.work.list', {
+                ...(peerId ? { peerId } : {}),
+                limit,
+            })).work ?? [],
+            invoke: async (input) => await operatorApi.invoke('remote.peers.invoke', asContractInput(input)),
+            claim: async (tokenValue, input = {}) => (await createPeerTokenClient(tokenValue).invoke('work.pull', asContractInput(input))).work ?? [],
+            complete: async (tokenValue, workId, input = {}) => {
+                const response = await withNullOnNotFound(() => createPeerTokenClient(tokenValue).invoke('work.complete', { workId, ...input }));
+                return response?.work ?? null;
+            },
+            cancel: async (workId, actor, note) => {
+                const response = await withNullOnNotFound(() => operatorApi.invoke('remote.work.cancel', {
+                    workId,
+                    actor,
+                    ...(note ? { reason: note } : {}),
+                }));
+                return response?.work ?? null;
+            },
+        },
+        getSnapshot: async () => {
+            const [remoteSnapshot, contract, peers] = await Promise.all([
+                readRemoteSnapshot(),
+                readNodeHostContractValue(),
+                readPeers(),
+            ]);
+            return {
+                capturedAt: Date.now(),
+                nodeHostContract: contract,
+                remoteSnapshot,
+                pairRequests: remoteSnapshot.distributed?.pairRequests ?? [],
+                peers,
+                work: remoteSnapshot.distributed?.work ?? [],
+            };
+        },
+        getNodeHostContract: async () => await readNodeHostContractValue(),
+    };
+}
+export function createHttpTransport(options) {
+    const httpClient = createHttpJsonTransport({
+        baseUrl: options.baseUrl,
+        authToken: options.authToken,
+        fetchImpl: options.fetchImpl,
+    });
+    const fetchImpl = httpClient.fetchImpl;
+    const paths = httpClient.paths;
+    const events = createRemoteUiRuntimeEvents(createEventSourceConnector(httpClient.baseUrl, options.authToken, fetchImpl));
+    const operator = createOperatorClient(httpClient, events);
+    const peer = createPeerClient(httpClient);
+    const transport = createClientTransport('http', operator, peer);
+    return Object.freeze({
+        ...transport,
+        async snapshot() {
+            const [currentSession, tasks, approvals, sessions, controlPlane, providers, remoteSnapshot, nodeHostContract, peerSnapshot] = await Promise.all([
+                operator.sessions.current(),
+                operator.tasks.snapshot(),
+                operator.approvals.list(),
+                operator.sessions.list(),
+                operator.controlPlane.snapshot(),
+                operator.providers.snapshot(),
+                requestJson(fetchImpl, paths.remoteUrl, createJsonRequestInit(options.authToken)),
+                peer.getNodeHostContract(),
+                peer.getSnapshot(),
+            ]);
+            return {
+                kind: 'http',
+                operator: {
+                    currentSession,
+                    tasks,
+                    approvals,
+                    sessions,
+                    controlPlane,
+                    providers,
+                    shellPaths: paths,
+                },
+                peer: {
+                    ...peerSnapshot,
+                    nodeHostContract,
+                    remoteSnapshot,
+                },
+            };
+        },
+    });
+}

package/dist/_internal/platform/runtime/transports/realtime.d.ts

@@ -0,0 +1,17 @@
+import type { HttpTransportOptions, HttpTransportPeerClient, HttpTransportOperatorClient, HttpTransportSnapshot } from './http-types.js';
+export interface RealtimeTransportOptions extends HttpTransportOptions {
+    readonly webSocketImpl?: typeof WebSocket;
+}
+export interface RealtimeTransportSnapshot extends Omit<HttpTransportSnapshot, 'kind'> {
+    readonly kind: 'realtime';
+}
+export interface RealtimeTransport {
+    readonly kind: 'realtime';
+    readonly operator: HttpTransportOperatorClient;
+    readonly peer: HttpTransportPeerClient;
+    getOperatorClient(): HttpTransportOperatorClient;
+    getPeerClient(): HttpTransportPeerClient;
+    snapshot(): Promise<RealtimeTransportSnapshot>;
+}
+export declare function createRealtimeTransport(options: RealtimeTransportOptions): RealtimeTransport;
+//# sourceMappingURL=realtime.d.ts.map

package/dist/_internal/platform/runtime/transports/realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/transports/realtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAIzI,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,SAAS,CAAC;CAC3C;AAED,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACpF,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,iBAAiB,IAAI,2BAA2B,CAAC;IACjD,aAAa,IAAI,uBAAuB,CAAC;IACzC,QAAQ,IAAI,OAAO,CAAC,yBAAyB,CAAC,CAAC;CAChD;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,iBAAiB,CA0B5F"}

package/dist/_internal/platform/runtime/transports/realtime.js

@@ -0,0 +1,28 @@
+import { createHttpTransport } from './http.js';
+import { createClientTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/client-transport';
+import { createWebSocketConnector } from './shared.js';
+import { createRemoteUiRuntimeEvents } from './ui-runtime-events.js';
+export function createRealtimeTransport(options) {
+    const baseTransport = createHttpTransport({
+        baseUrl: options.baseUrl,
+        authToken: options.authToken,
+        fetchImpl: options.fetchImpl,
+    });
+    const WebSocketImpl = options.webSocketImpl ?? WebSocket;
+    const events = createRemoteUiRuntimeEvents(createWebSocketConnector(options.baseUrl, options.authToken, WebSocketImpl));
+    const operator = {
+        ...baseTransport.operator,
+        events,
+    };
+    const transport = createClientTransport('realtime', operator, baseTransport.peer);
+    return Object.freeze({
+        ...transport,
+        async snapshot() {
+            const snapshot = await baseTransport.snapshot();
+            return {
+                ...snapshot,
+                kind: 'realtime',
+            };
+        },
+    });
+}

package/dist/_internal/platform/runtime/transports/remote-events.d.ts

@@ -0,0 +1,4 @@
+export type { DomainEventConnector, DomainEvents as RemoteDomainEvents, SerializedEventEnvelope as SerializedRuntimeEnvelope, RemoteRuntimeEvents, RuntimeEventConnectorOptions, } from '@pellux/goodvibes-sdk/transport-realtime';
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteDomainEvents, createRemoteRuntimeEvents, createWebSocketConnector, } from '@pellux/goodvibes-sdk/transport-realtime';
+export { createRemoteUiRuntimeEvents } from './ui-runtime-events.js';
+//# sourceMappingURL=remote-events.d.ts.map

package/dist/_internal/platform/runtime/transports/remote-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-events.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/transports/remote-events.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,oBAAoB,EACpB,YAAY,IAAI,kBAAkB,EAClC,uBAAuB,IAAI,yBAAyB,EACpD,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,0BAA0B,EAC1B,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/_internal/platform/runtime/transports/remote-events.js

@@ -0,0 +1,2 @@
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteDomainEvents, createRemoteRuntimeEvents, createWebSocketConnector, } from '@pellux/goodvibes-sdk/transport-realtime';
+export { createRemoteUiRuntimeEvents } from './ui-runtime-events.js';

package/dist/_internal/platform/runtime/transports/shared.d.ts

@@ -0,0 +1,17 @@
+export type { DomainEventConnector, SerializedRuntimeEnvelope } from './remote-events.js';
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createRemoteUiRuntimeEvents, createWebSocketConnector, } from './remote-events.js';
+export type { TransportPaths } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
+export { buildUrl, createTransportPaths, normalizeBaseUrl } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
+export type { BackoffPolicy, ResolvedBackoffPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/backoff';
+export { computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal } from '@pellux/goodvibes-sdk/platform/runtime/transports/backoff';
+export type { AuthTokenResolver, HeaderResolver, MaybePromise } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-auth';
+export { mergeHeaders, resolveAuthToken, resolveHeaders } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-auth';
+export type { HttpJsonRequestOptions, HttpRetryPolicy, HttpJsonTransport, HttpJsonTransportOptions, JsonObject, JsonValue, ResolvedContractRequest, TransportJsonError, } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
+export { createFetch, createHttpJsonTransport, createJsonInit, createJsonRequestInit, readJsonBody, requestJson, } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
+export type { ResolvedHttpRetryPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-retry';
+export { DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-retry';
+export type { ServerSentEventHandlers, ServerSentEventOptions } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
+export { isAbortError, openServerSentEventStream } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
+export type { StreamReconnectPolicy, ResolvedStreamReconnectPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/stream-reconnect';
+export { DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/stream-reconnect';
+//# sourceMappingURL=shared.d.ts.map

package/dist/_internal/platform/runtime/transports/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/transports/shared.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC1F,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,cAAc,EAAE,MAAM,mEAAmE,CAAC;AACxG,OAAO,EAAE,QAAQ,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,mEAAmE,CAAC;AACrI,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,2DAA2D,CAAC;AACtH,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,2DAA2D,CAAC;AACzI,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,6DAA6D,CAAC;AACnI,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,6DAA6D,CAAC;AAC7H,YAAY,EACV,sBAAsB,EACtB,eAAe,EACf,iBAAiB,EACjB,wBAAwB,EACxB,UAAU,EACV,SAAS,EACT,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,uEAAuE,CAAC;AAC/E,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,YAAY,EACZ,WAAW,GACZ,MAAM,uEAAuE,CAAC;AAC/E,YAAY,EAAE,uBAAuB,EAAE,MAAM,8DAA8D,CAAC;AAC5G,OAAO,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,8DAA8D,CAAC;AAC9N,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,8DAA8D,CAAC;AACpI,OAAO,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,8DAA8D,CAAC;AACvH,YAAY,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,oEAAoE,CAAC;AAC/I,OAAO,EAAE,+BAA+B,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,MAAM,oEAAoE,CAAC"}

package/dist/_internal/platform/runtime/transports/shared.js

@@ -0,0 +1,8 @@
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createRemoteUiRuntimeEvents, createWebSocketConnector, } from './remote-events.js';
+export { buildUrl, createTransportPaths, normalizeBaseUrl } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
+export { computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal } from '@pellux/goodvibes-sdk/platform/runtime/transports/backoff';
+export { mergeHeaders, resolveAuthToken, resolveHeaders } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-auth';
+export { createFetch, createHttpJsonTransport, createJsonInit, createJsonRequestInit, readJsonBody, requestJson, } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
+export { DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-retry';
+export { isAbortError, openServerSentEventStream } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
+export { DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/stream-reconnect';

package/dist/_internal/platform/runtime/transports/ui-runtime-events.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeEventDomain } from '../events/index.js';
+import type { UiRuntimeEvents } from '../ui-events.js';
+import type { DomainEventConnector } from '@pellux/goodvibes-sdk/platform/runtime/transports/domain-events';
+type RuntimeEventRecord = {
+    readonly type: string;
+};
+export declare function createRemoteUiRuntimeEvents(connect: DomainEventConnector<RuntimeEventDomain, RuntimeEventRecord>): UiRuntimeEvents;
+export {};
+//# sourceMappingURL=ui-runtime-events.d.ts.map

package/dist/_internal/platform/runtime/transports/ui-runtime-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-runtime-events.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/transports/ui-runtime-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,kBAAkB,EAKnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iEAAiE,CAAC;AAG5G,KAAK,kBAAkB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAepD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,oBAAoB,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,GACpE,eAAe,CAEjB"}

package/dist/_internal/platform/runtime/transports/ui-runtime-events.js

@@ -0,0 +1,16 @@
+import { createRemoteRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/transports/runtime-events-client';
+function asUiEvents(runtimeEvents) {
+    return {
+        sessions: runtimeEvents.session,
+        turns: runtimeEvents.turn,
+        tools: runtimeEvents.tools,
+        providers: runtimeEvents.providers,
+        agents: runtimeEvents.agents,
+        workflows: runtimeEvents.workflows,
+        planner: runtimeEvents.planner,
+        ops: runtimeEvents.ops,
+    };
+}
+export function createRemoteUiRuntimeEvents(connect) {
+    return asUiEvents(createRemoteRuntimeEvents(connect));
+}

package/dist/_internal/platform/runtime/ui/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Runtime UI data surface barrel.
+ *
+ * Exports enriched data providers and one-shot factory functions for
+ * the model picker and provider health surfaces.
+ *
+ * These modules produce structured data for renderers — no UI rendering
+ * logic lives here.
+ */
+export type { CapabilityFlags, ProviderLatencyStats, ProviderHealthContext, ModelPickerEntry, ModelPickerGroup, ModelPickerData, } from './model-picker/index.js';
+export type { ProviderStatus as ModelPickerProviderStatus } from './model-picker/index.js';
+export { ModelPickerDataProvider, createModelPickerData } from './model-picker/index.js';
+export type { ModelPickerDataProviderOptions } from './model-picker/index.js';
+export type { HealthTimelinePoint, HealthTimeline, ProviderHealthEntry, FallbackChainNode, FallbackChainData, ProviderHealthData, CompositeHealthStatus, } from './provider-health/index.js';
+export type { ProviderStatus } from './provider-health/index.js';
+export { ProviderHealthDataProvider, buildFallbackChainData, createProviderHealthData, } from './provider-health/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/ui/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,YAAY,EACV,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,GAChB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,cAAc,IAAI,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAC3F,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACzF,YAAY,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AAE9E,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC"}

package/dist/_internal/platform/runtime/ui/index.js

@@ -0,0 +1,11 @@
+/**
+ * Runtime UI data surface barrel.
+ *
+ * Exports enriched data providers and one-shot factory functions for
+ * the model picker and provider health surfaces.
+ *
+ * These modules produce structured data for renderers — no UI rendering
+ * logic lives here.
+ */
+export { ModelPickerDataProvider, createModelPickerData } from './model-picker/index.js';
+export { ProviderHealthDataProvider, buildFallbackChainData, createProviderHealthData, } from './provider-health/index.js';