@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/runtime/tools/phases/permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tools/phases/permission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAC;AAQ3G;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,IAAI,EACX,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,WAAW,CAAC,CA4GtB"}

package/dist/_internal/platform/runtime/tools/phases/permission.js

@@ -0,0 +1,109 @@
+import { emitPermissionDecision, emitPermissionRequested, } from '../../emitters/permissions.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/**
+ * permission — Phase 3 of the tool execution pipeline.
+ *
+ * Delegates to PermissionManager.check(). If permission is denied,
+ * the phase aborts and no further phases are run.
+ *
+ * The resolved args used here account for any input updates from the
+ * prehook phase (stored as `_updatedArgs` on the record).
+ */
+export async function permissionPhase(call, _tool, context, record) {
+    const start = performance.now();
+    // Use updated args from prehook if present
+    const effectiveArgs = record._updatedArgs ?? call.arguments;
+    const resolvePermissionResult = async () => {
+        const manager = context.permissionManager;
+        if (typeof manager.checkDetailed === 'function') {
+            return manager.checkDetailed(call.name, effectiveArgs);
+        }
+        if (typeof manager.check === 'function') {
+            const approved = await manager.check(call.name, effectiveArgs);
+            return {
+                approved,
+                persisted: false,
+                sourceLayer: approved ? 'config_policy' : 'user_prompt',
+                reasonCode: approved ? 'config_allow' : 'user_denied',
+                analysis: {
+                    classification: 'generic',
+                    riskLevel: 'medium',
+                    summary: `Permission ${approved ? 'approved' : 'denied'} for ${call.name}`,
+                    reasons: [],
+                },
+            };
+        }
+        throw new Error('PermissionManager is missing both checkDetailed() and check()');
+    };
+    try {
+        if (context.runtimeBus) {
+            const analysis = await resolvePermissionResult();
+            emitPermissionRequested(context.runtimeBus, {
+                sessionId: context.ids.sessionId,
+                traceId: context.ids.traceId,
+                source: 'permission-manager',
+            }, {
+                callId: call.id,
+                tool: call.name,
+                args: effectiveArgs,
+                category: context.permissionManager.getCategory(call.name),
+                classification: analysis.analysis.classification,
+                riskLevel: analysis.analysis.riskLevel,
+                summary: analysis.analysis.summary,
+                reasons: analysis.analysis.reasons,
+            });
+            emitPermissionDecision(context.runtimeBus, {
+                sessionId: context.ids.sessionId,
+                traceId: context.ids.traceId,
+                source: 'permission-manager',
+            }, {
+                callId: call.id,
+                tool: call.name,
+                approved: analysis.approved,
+                source: 'permission-manager',
+                sourceLayer: analysis.sourceLayer,
+                persisted: analysis.persisted,
+                reasonCode: analysis.reasonCode,
+                classification: analysis.analysis.classification,
+                riskLevel: analysis.analysis.riskLevel,
+                summary: analysis.analysis.summary,
+            });
+            if (!analysis.approved) {
+                return {
+                    phase: 'permissioned',
+                    success: false,
+                    durationMs: performance.now() - start,
+                    error: `Permission denied for tool '${call.name}'`,
+                    abort: true,
+                };
+            }
+        }
+        else {
+            const analysis = await resolvePermissionResult();
+            if (!analysis.approved) {
+                return {
+                    phase: 'permissioned',
+                    success: false,
+                    durationMs: performance.now() - start,
+                    error: `Permission denied for tool '${call.name}'`,
+                    abort: true,
+                };
+            }
+        }
+        return {
+            phase: 'permissioned',
+            success: true,
+            durationMs: performance.now() - start,
+        };
+    }
+    catch (err) {
+        const message = summarizeError(err);
+        return {
+            phase: 'permissioned',
+            success: false,
+            durationMs: performance.now() - start,
+            error: `Permission check threw: ${message}`,
+            abort: true,
+        };
+    }
+}

package/dist/_internal/platform/runtime/tools/phases/posthook.d.ts

@@ -0,0 +1,15 @@
+import type { Tool, ToolCall } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ToolRuntimeContext } from '../context.js';
+import type { PhaseResult, ToolExecutionRecord } from '@pellux/goodvibes-sdk/platform/runtime/tools/types';
+/**
+ * posthook — Phase 6 of the tool execution pipeline.
+ *
+ * Fires `Post:tool:<toolName>` hook via the HookDispatcher.
+ *
+ * Post-hooks are non-blocking in the following sense: a hook failure does
+ * NOT fail the tool call. The phase always returns success=true so the
+ * executor can proceed to `succeeded`. Hook errors are captured in the
+ * PhaseResult.error field for observability without aborting the call.
+ */
+export declare function posthookPhase(call: ToolCall, _tool: Tool, context: ToolRuntimeContext, record: ToolExecutionRecord): Promise<PhaseResult>;
+//# sourceMappingURL=posthook.d.ts.map

package/dist/_internal/platform/runtime/tools/phases/posthook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posthook.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tools/phases/posthook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAC;AAG3G;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,IAAI,EACX,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,WAAW,CAAC,CAoCtB"}

package/dist/_internal/platform/runtime/tools/phases/posthook.js

@@ -0,0 +1,47 @@
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/**
+ * posthook — Phase 6 of the tool execution pipeline.
+ *
+ * Fires `Post:tool:<toolName>` hook via the HookDispatcher.
+ *
+ * Post-hooks are non-blocking in the following sense: a hook failure does
+ * NOT fail the tool call. The phase always returns success=true so the
+ * executor can proceed to `succeeded`. Hook errors are captured in the
+ * PhaseResult.error field for observability without aborting the call.
+ */
+export async function posthookPhase(call, _tool, context, record) {
+    const start = performance.now();
+    try {
+        await context.hookDispatcher.fire({
+            path: `Post:tool:${call.name}`,
+            phase: 'Post',
+            category: 'tool',
+            specific: call.name,
+            sessionId: context.ids.sessionId,
+            timestamp: Date.now(),
+            payload: {
+                callId: call.id,
+                toolName: call.name,
+                args: record._updatedArgs ?? call.arguments,
+                result: record.result,
+                success: record.result?.success ?? false,
+            },
+            agentId: context.agent?.agentId,
+        });
+        return {
+            phase: 'posthooked',
+            success: true,
+            durationMs: performance.now() - start,
+        };
+    }
+    catch (err) {
+        // Post-hook failure must not fail the tool call
+        const message = summarizeError(err);
+        return {
+            phase: 'posthooked',
+            success: true,
+            durationMs: performance.now() - start,
+            error: `Post-hook threw (non-fatal): ${message}`,
+        };
+    }
+}

package/dist/_internal/platform/runtime/tools/phases/prehook.d.ts

@@ -0,0 +1,16 @@
+import type { Tool, ToolCall } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ToolRuntimeContext } from '../context.js';
+import type { PhaseResult, ToolExecutionRecord } from '@pellux/goodvibes-sdk/platform/runtime/tools/types';
+/**
+ * prehook — Phase 2 of the tool execution pipeline.
+ *
+ * Fires `Pre:tool:<toolName>` hook via the HookDispatcher.
+ * If the hook returns a `deny` decision, execution is aborted.
+ * If the hook returns `updatedInput`, the record's args are updated
+ * in-place so subsequent phases see the modified arguments.
+ *
+ * Hook failures (network, timeout, etc.) are treated as allow to avoid
+ * blocking tool execution on non-critical infrastructure errors.
+ */
+export declare function prehookPhase(call: ToolCall, _tool: Tool, context: ToolRuntimeContext, record: ToolExecutionRecord): Promise<PhaseResult>;
+//# sourceMappingURL=prehook.d.ts.map

package/dist/_internal/platform/runtime/tools/phases/prehook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prehook.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tools/phases/prehook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAC;AAE3G;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,IAAI,EACX,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,WAAW,CAAC,CA+CtB"}

package/dist/_internal/platform/runtime/tools/phases/prehook.js

@@ -0,0 +1,56 @@
+/**
+ * prehook — Phase 2 of the tool execution pipeline.
+ *
+ * Fires `Pre:tool:<toolName>` hook via the HookDispatcher.
+ * If the hook returns a `deny` decision, execution is aborted.
+ * If the hook returns `updatedInput`, the record's args are updated
+ * in-place so subsequent phases see the modified arguments.
+ *
+ * Hook failures (network, timeout, etc.) are treated as allow to avoid
+ * blocking tool execution on non-critical infrastructure errors.
+ */
+export async function prehookPhase(call, _tool, context, record) {
+    const start = performance.now();
+    try {
+        const hookResult = await context.hookDispatcher.fire({
+            path: `Pre:tool:${call.name}`,
+            phase: 'Pre',
+            category: 'tool',
+            specific: call.name,
+            sessionId: context.ids.sessionId,
+            timestamp: Date.now(),
+            payload: {
+                callId: call.id,
+                toolName: call.name,
+                args: call.arguments,
+            },
+            agentId: context.agent?.agentId,
+        });
+        if (hookResult.decision === 'deny') {
+            return {
+                phase: 'prehooked',
+                success: false,
+                durationMs: performance.now() - start,
+                error: hookResult.reason ?? 'Pre-hook denied tool execution',
+                abort: true,
+            };
+        }
+        // Allow hooks to modify input arguments for subsequent phases
+        if (hookResult.updatedInput) {
+            record._updatedArgs = hookResult.updatedInput;
+        }
+        return {
+            phase: 'prehooked',
+            success: true,
+            durationMs: performance.now() - start,
+        };
+    }
+    catch (_err) {
+        // Hook infrastructure failure — allow execution to proceed
+        return {
+            phase: 'prehooked',
+            success: true,
+            durationMs: performance.now() - start,
+        };
+    }
+}

package/dist/_internal/platform/runtime/tools/phases/validate.d.ts

@@ -0,0 +1,18 @@
+import type { Tool, ToolCall } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ToolRuntimeContext } from '../context.js';
+import type { PhaseResult, ToolExecutionRecord } from '@pellux/goodvibes-sdk/platform/runtime/tools/types';
+/**
+ * validate — Phase 1 of the tool execution pipeline.
+ *
+ * Performs lightweight pre-flight checks:
+ * - The call has a non-empty id
+ * - The call has a non-empty tool name
+ * - Args is a plain object (not null)
+ * - The tool object is present
+ *
+ * Heavy schema validation (JSON Schema against parameters) is intentionally
+ * left to a future tier — this phase acts as a guard against programmer
+ * errors and malformed LLM payloads.
+ */
+export declare function validatePhase(call: ToolCall, tool: Tool, _context: ToolRuntimeContext, _record: ToolExecutionRecord): Promise<PhaseResult>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/_internal/platform/runtime/tools/phases/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tools/phases/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAC;AAE3G;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,WAAW,CAAC,CAoBtB"}

package/dist/_internal/platform/runtime/tools/phases/validate.js

@@ -0,0 +1,38 @@
+/**
+ * validate — Phase 1 of the tool execution pipeline.
+ *
+ * Performs lightweight pre-flight checks:
+ * - The call has a non-empty id
+ * - The call has a non-empty tool name
+ * - Args is a plain object (not null)
+ * - The tool object is present
+ *
+ * Heavy schema validation (JSON Schema against parameters) is intentionally
+ * left to a future tier — this phase acts as a guard against programmer
+ * errors and malformed LLM payloads.
+ */
+export async function validatePhase(call, tool, _context, _record) {
+    const start = performance.now();
+    if (!call.id || call.id.trim().length === 0) {
+        return result(start, false, 'Tool call is missing a valid id');
+    }
+    if (!call.name || call.name.trim().length === 0) {
+        return result(start, false, 'Tool call is missing a tool name');
+    }
+    if (call.arguments === null || typeof call.arguments !== 'object' || Array.isArray(call.arguments)) {
+        return result(start, false, `Tool call args must be a plain object, got: ${typeof call.arguments}`);
+    }
+    if (!tool || typeof tool.execute !== 'function') {
+        return result(start, false, `Tool '${call.name}' is not a valid tool implementation`);
+    }
+    return result(start, true);
+}
+function result(start, success, error) {
+    return {
+        phase: 'validated',
+        success,
+        durationMs: performance.now() - start,
+        error,
+        abort: success ? undefined : true,
+    };
+}

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

@@ -0,0 +1,34 @@
+import type { SharedApprovalRecord, SharedSessionRecord } from '../../control-plane/index.js';
+import { type DirectTransportServices } from '../foundation-services.js';
+import { type OperatorClient, type OperatorControlPlaneSnapshot, type OperatorProvidersSnapshot } from '../operator-client.js';
+import { type PeerClient, type PeerClientSnapshot } from '../peer-client.js';
+import type { RuntimeServices } from '../services.js';
+import type { UiSessionSnapshot, UiTasksSnapshot } from '../ui-read-models.js';
+import type { ShellPathService } from '@pellux/goodvibes-sdk/platform/runtime/shell-paths';
+export { createDirectClientTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/direct-client';
+export type { DirectClientTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/direct-client';
+export interface DirectTransportSnapshot {
+    readonly kind: 'direct';
+    readonly operator: {
+        readonly currentSession: UiSessionSnapshot;
+        readonly tasks: UiTasksSnapshot;
+        readonly approvals: readonly SharedApprovalRecord[];
+        readonly sessions: readonly SharedSessionRecord[];
+        readonly controlPlane: OperatorControlPlaneSnapshot;
+        readonly providers: OperatorProvidersSnapshot;
+        readonly shellPaths: ShellPathService;
+    };
+    readonly peer: PeerClientSnapshot;
+}
+export interface DirectTransport {
+    readonly kind: 'direct';
+    readonly operator: OperatorClient;
+    readonly peer: PeerClient;
+    getOperatorClient(): OperatorClient;
+    getPeerClient(): PeerClient;
+    snapshot(): Promise<DirectTransportSnapshot>;
+}
+export declare function createDirectTransportFromServices(services: DirectTransportServices): DirectTransport;
+export declare function createRuntimeDirectTransport(runtimeServices: RuntimeServices): DirectTransport;
+export declare function createDirectTransport(runtimeServices: RuntimeServices): DirectTransport;
+//# sourceMappingURL=direct.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"direct.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/transports/direct.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAC9F,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAwB,KAAK,cAAc,EAAE,KAAK,4BAA4B,EAAE,KAAK,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACrJ,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC/F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAC;AAG3F,OAAO,EAAE,2BAA2B,EAAE,MAAM,iEAAiE,CAAC;AAC9G,YAAY,EAAE,qBAAqB,EAAE,MAAM,iEAAiE,CAAC;AAE7G,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,cAAc,EAAE,iBAAiB,CAAC;QAC3C,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;QAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,oBAAoB,EAAE,CAAC;QACpD,QAAQ,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;QAClD,QAAQ,CAAC,YAAY,EAAE,4BAA4B,CAAC;QACpD,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;QAC9C,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;KACvC,CAAC;IACF,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;CACnC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,iBAAiB,IAAI,cAAc,CAAC;IACpC,aAAa,IAAI,UAAU,CAAC;IAC5B,QAAQ,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC9C;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,uBAAuB,GAAG,eAAe,CA0BpG;AAED,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,eAAe,GAAG,eAAe,CAE9F;AAED,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,eAAe,GAAG,eAAe,CAEvF"}

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

@@ -0,0 +1,37 @@
+import { createDirectTransportServices, } from '../foundation-services.js';
+import { createOperatorClient } from '../operator-client.js';
+import { createPeerClient } from '../peer-client.js';
+import { createDirectClientTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/direct-client';
+export { createDirectClientTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/direct-client';
+export function createDirectTransportFromServices(services) {
+    const operator = createOperatorClient(services.operator);
+    const peer = createPeerClient(services.peer);
+    const transport = createDirectClientTransport(operator, peer);
+    return Object.freeze({
+        ...transport,
+        async snapshot() {
+            const [providers] = await Promise.all([
+                operator.providers.snapshot(),
+            ]);
+            return {
+                kind: 'direct',
+                operator: {
+                    currentSession: operator.sessions.current(),
+                    tasks: operator.tasks.snapshot(),
+                    approvals: operator.approvals.list(),
+                    sessions: operator.sessions.list(),
+                    controlPlane: operator.controlPlane.snapshot(),
+                    providers,
+                    shellPaths: operator.shellPaths,
+                },
+                peer: peer.getSnapshot(),
+            };
+        },
+    });
+}
+export function createRuntimeDirectTransport(runtimeServices) {
+    return createDirectTransportFromServices(createDirectTransportServices(runtimeServices));
+}
+export function createDirectTransport(runtimeServices) {
+    return createRuntimeDirectTransport(runtimeServices);
+}

package/dist/_internal/platform/runtime/transports/http-helpers.d.ts

@@ -0,0 +1,18 @@
+import type { TelemetryFilter } from '../telemetry/api.js';
+import type { UiControlPlaneSnapshot } from '../ui-read-models.js';
+import type { TransportPaths } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
+import type { HttpSessionEnsureInput, HttpSessionMessageInput, HttpSteerSessionMessageInput, HttpTaskSubmitInput, HttpTransportTelemetryQuery, HttpTransportTelemetryStreamHandlers } from './http-types.js';
+export declare function createJsonRequestInit(token: string | null | undefined, body?: unknown, method?: string): RequestInit;
+export declare function maybeObject<T extends object>(value: unknown): T | null;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function readArrayResponse<T>(body: unknown, key: string): readonly T[];
+export declare function readControlPlaneSnapshot(fetchImpl: typeof fetch, paths: TransportPaths, token: string | null | undefined): Promise<UiControlPlaneSnapshot>;
+export declare function buildSessionEnsureBody(input?: HttpSessionEnsureInput): Record<string, unknown>;
+export declare function buildSessionMessageBody(input: HttpSessionMessageInput): Record<string, unknown>;
+export declare function buildSteerSessionMessageBody(input: HttpSteerSessionMessageInput): Record<string, unknown>;
+export declare function buildTaskSubmitBody(input: HttpTaskSubmitInput): Record<string, unknown>;
+export declare function normalizeTelemetryQuery(query: HttpTransportTelemetryQuery | undefined, defaultLimit: number): TelemetryFilter;
+export declare function appendTelemetryQuery(url: URL, query: TelemetryFilter): void;
+export declare function connectTelemetryStream(fetchImpl: typeof fetch, url: string, token: string | null | undefined, handlers: HttpTransportTelemetryStreamHandlers): Promise<() => void>;
+export declare function buildTransportUrl(baseUrl: string, path: string): string;
+//# sourceMappingURL=http-helpers.d.ts.map

package/dist/_internal/platform/runtime/transports/http-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-helpers.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/transports/http-helpers.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mEAAmE,CAAC;AAIxG,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,4BAA4B,EAC5B,mBAAmB,EACnB,2BAA2B,EAC3B,oCAAoC,EAErC,MAAM,iBAAiB,CAAC;AAEzB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,SAAQ,GAAG,WAAW,CAEnH;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,GAAG,IAAI,CAEtE;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,EAAE,CAO7E;AAwBD,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,OAAO,KAAK,EACvB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CAoCjC;AAED,wBAAgB,sBAAsB,CAAC,KAAK,GAAE,sBAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgBlG;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAc/F;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,4BAA4B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzG;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiBvF;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,2BAA2B,GAAG,SAAS,EAAE,YAAY,EAAE,MAAM,GAAG,eAAe,CAQ7H;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI,CAc3E;AAED,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,OAAO,KAAK,EACvB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,QAAQ,EAAE,oCAAoC,GAC7C,OAAO,CAAC,MAAM,IAAI,CAAC,CAerB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvE"}

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

@@ -0,0 +1,182 @@
+import { buildUrl } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
+import { createJsonInit, requestJson } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
+import { openServerSentEventStream } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
+export function createJsonRequestInit(token, body, method = 'GET') {
+    return createJsonInit(token, body, method);
+}
+export function maybeObject(value) {
+    return typeof value === 'object' && value !== null ? value : null;
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function readArrayResponse(body, key) {
+    if (Array.isArray(body))
+        return body;
+    if (isRecord(body)) {
+        const maybeEntries = body[key];
+        if (Array.isArray(maybeEntries))
+            return maybeEntries;
+    }
+    return [];
+}
+function readControlPlaneClients(body) {
+    if (!isRecord(body))
+        return [];
+    return Array.isArray(body.clients) ? body.clients : [];
+}
+function readControlPlaneEvents(body) {
+    if (!isRecord(body))
+        return [];
+    return Array.isArray(body.recentEvents) ? body.recentEvents : [];
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function readString(value, fallback = '') {
+    return typeof value === 'string' ? value : fallback;
+}
+function readBoolean(value) {
+    return value === true;
+}
+export async function readControlPlaneSnapshot(fetchImpl, paths, token) {
+    const approvalsUrl = new URL(paths.approvalsUrl);
+    approvalsUrl.searchParams.set('limit', '6');
+    const [gatewaySnapshot, approvals, sessions] = await Promise.all([
+        requestJson(fetchImpl, paths.controlPlaneUrl, createJsonRequestInit(token)),
+        requestJson(fetchImpl, approvalsUrl.toString(), createJsonRequestInit(token)),
+        requestJson(fetchImpl, paths.sessionsUrl, createJsonRequestInit(token)),
+    ]);
+    const server = maybeObject(isRecord(gatewaySnapshot) ? gatewaySnapshot.server : null) ?? {};
+    const totals = maybeObject(isRecord(gatewaySnapshot) ? gatewaySnapshot.totals : null) ?? {};
+    const clients = readControlPlaneClients(gatewaySnapshot);
+    const recentEvents = readControlPlaneEvents(gatewaySnapshot).slice(0, 6);
+    const sessionList = readArrayResponse(sessions, 'sessions');
+    const approvalList = readArrayResponse(approvals, 'approvals');
+    return {
+        connectionState: readString(server.connectionState, 'unknown'),
+        activeClientIds: clients.filter((client) => readBoolean(client.connected)).map((client) => client.id),
+        requestCount: readNumber(totals.requests),
+        errorCount: readNumber(totals.errors),
+        host: readString(server.host, ''),
+        port: readNumber(server.port),
+        clients,
+        approvals: approvalList.slice(0, 6),
+        sessions: sessionList.length > 0
+            ? sessionList.slice(0, 6)
+            : readArrayResponse(sessions, 'session').slice(0, 6),
+        recentEvents,
+    };
+}
+export function buildSessionEnsureBody(input = {}) {
+    return {
+        ...(input.sessionId ? { id: input.sessionId } : {}),
+        ...(input.title ? { title: input.title } : {}),
+        ...(input.metadata ? { metadata: input.metadata } : {}),
+        ...(input.routeId ? { routeId: input.routeId } : {}),
+        ...(input.participant
+            ? {
+                surfaceKind: input.participant.surfaceKind,
+                surfaceId: input.participant.surfaceId,
+                ...(input.participant.externalId ? { externalId: input.participant.externalId } : {}),
+                ...(input.participant.userId ? { userId: input.participant.userId } : {}),
+                ...(input.participant.displayName ? { displayName: input.participant.displayName } : {}),
+            }
+            : {}),
+    };
+}
+export function buildSessionMessageBody(input) {
+    return {
+        body: input.body,
+        ...(input.surfaceKind ? { surfaceKind: input.surfaceKind } : {}),
+        ...(input.surfaceId ? { surfaceId: input.surfaceId } : {}),
+        ...(input.externalId ? { externalId: input.externalId } : {}),
+        ...(input.threadId ? { threadId: input.threadId } : {}),
+        ...(input.userId ? { userId: input.userId } : {}),
+        ...(input.displayName ? { displayName: input.displayName } : {}),
+        ...(input.title ? { title: input.title } : {}),
+        ...(input.routeId ? { routeId: input.routeId } : {}),
+        ...(input.metadata ? { metadata: input.metadata } : {}),
+        ...(input.routing ? { routing: input.routing } : {}),
+    };
+}
+export function buildSteerSessionMessageBody(input) {
+    return {
+        ...buildSessionMessageBody(input),
+        ...(input.allowSpawnFallback === true ? { allowSpawnFallback: true } : {}),
+    };
+}
+export function buildTaskSubmitBody(input) {
+    return {
+        task: input.task,
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.tools ? { tools: [...input.tools] } : {}),
+        ...(input.routing ? { routing: input.routing } : {}),
+        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        ...(input.routeId ? { routeId: input.routeId } : {}),
+        ...(input.surfaceKind ? { surfaceKind: input.surfaceKind } : {}),
+        ...(input.surfaceId ? { surfaceId: input.surfaceId } : {}),
+        ...(input.externalId ? { externalId: input.externalId } : {}),
+        ...(input.threadId ? { threadId: input.threadId } : {}),
+        ...(input.userId ? { userId: input.userId } : {}),
+        ...(input.displayName ? { displayName: input.displayName } : {}),
+        ...(input.title ? { title: input.title } : {}),
+        ...(input.metadata ? { metadata: input.metadata } : {}),
+    };
+}
+export function normalizeTelemetryQuery(query, defaultLimit) {
+    if (typeof query === 'number') {
+        return { limit: Math.max(1, Math.floor(query)) };
+    }
+    return {
+        ...(query ?? {}),
+        ...(query?.limit !== undefined ? { limit: Math.max(1, Math.floor(query.limit)) } : { limit: defaultLimit }),
+    };
+}
+export function appendTelemetryQuery(url, query) {
+    if (query.limit !== undefined)
+        url.searchParams.set('limit', String(Math.max(1, Math.floor(query.limit))));
+    if (query.since !== undefined)
+        url.searchParams.set('since', String(query.since));
+    if (query.until !== undefined)
+        url.searchParams.set('until', String(query.until));
+    if (query.domains?.length)
+        url.searchParams.set('domains', query.domains.join(','));
+    if (query.eventTypes?.length)
+        url.searchParams.set('types', query.eventTypes.join(','));
+    if (query.severity)
+        url.searchParams.set('severity', query.severity);
+    if (query.traceId)
+        url.searchParams.set('traceId', query.traceId);
+    if (query.sessionId)
+        url.searchParams.set('sessionId', query.sessionId);
+    if (query.turnId)
+        url.searchParams.set('turnId', query.turnId);
+    if (query.agentId)
+        url.searchParams.set('agentId', query.agentId);
+    if (query.taskId)
+        url.searchParams.set('taskId', query.taskId);
+    if (query.cursor)
+        url.searchParams.set('cursor', query.cursor);
+    if (query.view)
+        url.searchParams.set('view', query.view);
+}
+export async function connectTelemetryStream(fetchImpl, url, token, handlers) {
+    return await openServerSentEventStream(fetchImpl, url, {
+        onEvent: (eventName, payload) => {
+            if (eventName === 'telemetry' && payload && typeof payload === 'object') {
+                handlers.onRecord(payload);
+            }
+        },
+        onReady: handlers.onReady
+            ? (payload) => {
+                handlers.onReady?.(payload);
+            }
+            : undefined,
+    }, {
+        authToken: token,
+    });
+}
+export function buildTransportUrl(baseUrl, path) {
+    return buildUrl(baseUrl, path);
+}