@a5c-ai/genty-platform 5.1.1-staging.0007199a1cb2

package/dist/harness/selectionPolicies.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * GAP-HADAPT-008: Harness Selection Policies.
+ *
+ * Configurable policies for harness selection: cost-optimized,
+ * latency-optimized, capability-first, user-preferred.
+ * Policy evaluator scores candidates using selectHarness from capabilityRouter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultPolicy = getDefaultPolicy;
+exports.getPolicyByName = getPolicyByName;
+exports.createPolicyEvaluator = createPolicyEvaluator;
+exports.evaluatePolicy = evaluatePolicy;
+const capabilityRouter_1 = require("./capabilityRouter");
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Policy implementations
+// ---------------------------------------------------------------------------
+const capabilityFirstPolicy = {
+    name: "capability-first",
+    description: "Select the harness with the highest capability score",
+    evaluate(candidates, requirements) {
+        const result = (0, capabilityRouter_1.selectHarness)(requirements, candidates);
+        if (!result) {
+            return { selected: null, policyName: "capability-first", score: 0, reason: "No candidate met threshold", routingResult: null };
+        }
+        return {
+            selected: result.selected,
+            policyName: "capability-first",
+            score: result.score,
+            reason: `Selected ${result.selected.name} with score ${result.score}`,
+            routingResult: result,
+        };
+    },
+};
+const costOptimizedPolicy = {
+    name: "cost-optimized",
+    description: "Prefer harnesses with fewer capabilities (proxy for lower cost)",
+    evaluate(candidates, requirements) {
+        const result = (0, capabilityRouter_1.selectHarness)(requirements, candidates);
+        if (!result) {
+            return { selected: null, policyName: "cost-optimized", score: 0, reason: "No candidate met threshold", routingResult: null };
+        }
+        // Among eligible candidates (those that passed the threshold), pick the one
+        // with the fewest capabilities — a proxy for cost
+        const eligible = result.scores
+            .filter((s) => !s.disqualified && s.total >= 50)
+            .map((s) => s.name);
+        const eligibleCandidates = candidates.filter((c) => eligible.includes(c.name));
+        if (eligibleCandidates.length === 0) {
+            return { selected: null, policyName: "cost-optimized", score: 0, reason: "No eligible candidate", routingResult: result };
+        }
+        // Sort by fewest capabilities ascending
+        const sorted = [...eligibleCandidates].sort((a, b) => a.capabilities.length - b.capabilities.length);
+        const pick = sorted[0];
+        const pickScore = result.scores.find((s) => s.name === pick.name);
+        return {
+            selected: pick,
+            policyName: "cost-optimized",
+            score: pickScore?.total ?? 0,
+            reason: `Selected ${pick.name} (fewest capabilities: ${pick.capabilities.length})`,
+            routingResult: result,
+        };
+    },
+};
+const latencyOptimizedPolicy = {
+    name: "latency-optimized",
+    description: "Prefer harnesses with Programmatic + StopHook for lowest latency",
+    evaluate(candidates, requirements) {
+        const result = (0, capabilityRouter_1.selectHarness)(requirements, candidates);
+        if (!result) {
+            return { selected: null, policyName: "latency-optimized", score: 0, reason: "No candidate met threshold", routingResult: null };
+        }
+        const eligible = result.scores
+            .filter((s) => !s.disqualified && s.total >= 50)
+            .map((s) => s.name);
+        const eligibleCandidates = candidates.filter((c) => eligible.includes(c.name));
+        if (eligibleCandidates.length === 0) {
+            return { selected: null, policyName: "latency-optimized", score: 0, reason: "No eligible candidate", routingResult: result };
+        }
+        // Score: +2 for StopHook, +2 for Programmatic, +1 for SessionBinding
+        const latencyScore = (c) => {
+            let s = 0;
+            if (c.capabilities.includes(types_1.HarnessCapability.StopHook))
+                s += 2;
+            if (c.capabilities.includes(types_1.HarnessCapability.Programmatic))
+                s += 2;
+            if (c.capabilities.includes(types_1.HarnessCapability.SessionBinding))
+                s += 1;
+            return s;
+        };
+        const sorted = [...eligibleCandidates].sort((a, b) => latencyScore(b) - latencyScore(a));
+        const pick = sorted[0];
+        const pickScore = result.scores.find((s) => s.name === pick.name);
+        return {
+            selected: pick,
+            policyName: "latency-optimized",
+            score: pickScore?.total ?? 0,
+            reason: `Selected ${pick.name} (latency-optimized: StopHook+Programmatic)`,
+            routingResult: result,
+        };
+    },
+};
+const userPreferredPolicy = {
+    name: "user-preferred",
+    description: "Select the user-preferred harness if it qualifies, else fall back to capability-first",
+    evaluate(candidates, requirements, options) {
+        const preferred = options?.preferredHarness;
+        if (preferred) {
+            // Try routing with the preferred harness hint
+            const augmented = {
+                ...requirements,
+                preferredHarness: preferred,
+            };
+            const result = (0, capabilityRouter_1.selectHarness)(augmented, candidates);
+            if (result && result.selected.name === preferred) {
+                return {
+                    selected: result.selected,
+                    policyName: "user-preferred",
+                    score: result.score,
+                    reason: `Selected user-preferred harness ${preferred}`,
+                    routingResult: result,
+                };
+            }
+        }
+        // Fall back to capability-first
+        const fallback = capabilityFirstPolicy.evaluate(candidates, requirements);
+        return {
+            ...fallback,
+            policyName: "user-preferred",
+            reason: preferred
+                ? `Preferred harness '${preferred}' not available, fell back to ${fallback.selected?.name ?? "none"}`
+                : fallback.reason,
+        };
+    },
+};
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+const POLICIES = {
+    "capability-first": capabilityFirstPolicy,
+    "cost-optimized": costOptimizedPolicy,
+    "latency-optimized": latencyOptimizedPolicy,
+    "user-preferred": userPreferredPolicy,
+};
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function getDefaultPolicy() {
+    return POLICIES["capability-first"];
+}
+function getPolicyByName(name) {
+    const policy = POLICIES[name];
+    if (!policy) {
+        throw new TypeError(`Unknown selection policy: ${String(name)}`);
+    }
+    return policy;
+}
+function createPolicyEvaluator(policy) {
+    return (candidates, requirements, options) => policy.evaluate(candidates, requirements, options);
+}
+function evaluatePolicy(policyName, candidates, requirements, options) {
+    const policy = getPolicyByName(policyName);
+    return policy.evaluate(candidates, requirements, options);
+}

package/dist/harness/streamingParallelism.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Streaming parallelism — merge and fan-out async streams (GAP-PAR-006).
+ *
+ * StreamMerger: merges multiple async iterables into a single ordered-by-arrival
+ *               async generator.
+ * StreamFanout: pushes items to multiple consumers concurrently.
+ */
+interface TaggedItem<T> {
+    streamId: string;
+    value: T;
+}
+/**
+ * Merges multiple async iterables into a single async generator that yields
+ * items as they arrive from any source.
+ */
+export declare class StreamMerger<T> {
+    private streams;
+    /** Register an async iterable source with a unique id. */
+    addStream(id: string, iterable: AsyncIterable<T>): void;
+    /**
+     * Async generator that yields `{ streamId, value }` tuples from all
+     * registered streams, in order of arrival.
+     */
+    merged(): AsyncGenerator<TaggedItem<T>>;
+}
+export type FanoutCallback<T> = (item: T) => void | Promise<void>;
+/**
+ * Forwards each pushed item to all registered consumers.
+ */
+export declare class StreamFanout<T> {
+    private consumers;
+    /** Register a consumer callback with a unique id. */
+    addConsumer(id: string, callback: FanoutCallback<T>): void;
+    /** Remove a consumer by id. Returns true if it existed. */
+    removeConsumer(id: string): boolean;
+    /**
+     * Push an item to all consumers. If any consumer returns a Promise,
+     * push waits for all of them to settle.
+     */
+    push(item: T): Promise<void>;
+}
+export {};
+//# sourceMappingURL=streamingParallelism.d.ts.map

package/dist/harness/streamingParallelism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamingParallelism.d.ts","sourceRoot":"","sources":["../../src/harness/streamingParallelism.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,UAAU,UAAU,CAAC,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV;AAED;;;GAGG;AACH,qBAAa,YAAY,CAAC,CAAC;IACzB,OAAO,CAAC,OAAO,CAAuC;IAEtD,0DAA0D;IAC1D,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAIvD;;;OAGG;IACI,MAAM,IAAI,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;CA6D/C;AAMD,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAElE;;GAEG;AACH,qBAAa,YAAY,CAAC,CAAC;IACzB,OAAO,CAAC,SAAS,CAAwC;IAEzD,qDAAqD;IACrD,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI;IAI1D,2DAA2D;IAC3D,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAInC;;;OAGG;IACG,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAYnC"}

package/dist/harness/streamingParallelism.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Streaming parallelism — merge and fan-out async streams (GAP-PAR-006).
+ *
+ * StreamMerger: merges multiple async iterables into a single ordered-by-arrival
+ *               async generator.
+ * StreamFanout: pushes items to multiple consumers concurrently.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamFanout = exports.StreamMerger = void 0;
+/**
+ * Merges multiple async iterables into a single async generator that yields
+ * items as they arrive from any source.
+ */
+class StreamMerger {
+    streams = new Map();
+    /** Register an async iterable source with a unique id. */
+    addStream(id, iterable) {
+        this.streams.set(id, iterable);
+    }
+    /**
+     * Async generator that yields `{ streamId, value }` tuples from all
+     * registered streams, in order of arrival.
+     */
+    async *merged() {
+        if (this.streams.size === 0)
+            return;
+        // We use a shared queue + resolvers pattern to merge multiple iterators
+        const queue = [];
+        let done = 0;
+        const total = this.streams.size;
+        let resolve = null;
+        let finished = false;
+        function enqueue(item) {
+            queue.push(item);
+            if (resolve) {
+                const r = resolve;
+                resolve = null;
+                r();
+            }
+        }
+        function signalDone() {
+            done++;
+            if (done >= total) {
+                finished = true;
+                if (resolve) {
+                    const r = resolve;
+                    resolve = null;
+                    r();
+                }
+            }
+        }
+        // Start consuming each stream
+        const consumers = [];
+        for (const [id, iterable] of this.streams.entries()) {
+            consumers.push((async () => {
+                try {
+                    for await (const value of iterable) {
+                        enqueue({ streamId: id, value });
+                    }
+                }
+                finally {
+                    signalDone();
+                }
+            })());
+        }
+        // Yield items as they arrive
+        while (!finished || queue.length > 0) {
+            if (queue.length > 0) {
+                yield queue.shift();
+            }
+            else if (!finished) {
+                await new Promise((r) => {
+                    resolve = r;
+                });
+            }
+        }
+        // Wait for all consumer promises to settle
+        await Promise.allSettled(consumers);
+    }
+}
+exports.StreamMerger = StreamMerger;
+/**
+ * Forwards each pushed item to all registered consumers.
+ */
+class StreamFanout {
+    consumers = new Map();
+    /** Register a consumer callback with a unique id. */
+    addConsumer(id, callback) {
+        this.consumers.set(id, callback);
+    }
+    /** Remove a consumer by id. Returns true if it existed. */
+    removeConsumer(id) {
+        return this.consumers.delete(id);
+    }
+    /**
+     * Push an item to all consumers. If any consumer returns a Promise,
+     * push waits for all of them to settle.
+     */
+    async push(item) {
+        const promises = [];
+        for (const cb of this.consumers.values()) {
+            const result = cb(item);
+            if (result && typeof result === 'object' && 'then' in result) {
+                promises.push(result);
+            }
+        }
+        if (promises.length > 0) {
+            await Promise.all(promises);
+        }
+    }
+}
+exports.StreamFanout = StreamFanout;

package/dist/harness/streamingRenderer.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Streaming Renderer (GAP-PERF-004).
+ *
+ * Buffers and dispatches streaming output chunks from harness sessions.
+ * Supports typed chunk handling with listener registration and
+ * buffered replay for late subscribers.
+ */
+/** Type of streaming content chunk. */
+export type StreamChunkType = "text" | "tool_use" | "tool_result" | "thinking" | "error";
+/** A single chunk of streaming output. */
+export interface StreamChunk {
+    /** Chunk type discriminator. */
+    type: StreamChunkType;
+    /** The content of the chunk. */
+    content: string;
+    /** When the chunk was received (ISO 8601). */
+    timestamp: string;
+    /** Sequence number within the stream. */
+    seq: number;
+}
+/** Callback invoked for each incoming chunk. */
+export type StreamChunkListener = (chunk: StreamChunk) => void;
+/**
+ * Buffers streaming output and dispatches chunks to registered listeners.
+ *
+ * Designed for single-session use: one renderer per harness invocation.
+ */
+export declare class StreamingRenderer {
+    private readonly buffer;
+    private readonly listeners;
+    private seq;
+    /**
+     * Push a new chunk into the stream.
+     * Immediately dispatches to all registered listeners.
+     */
+    push(type: StreamChunkType, content: string): StreamChunk;
+    /**
+     * Register a listener for incoming chunks.
+     * Returns an unsubscribe function.
+     */
+    onChunk(listener: StreamChunkListener): () => void;
+    /**
+     * Flush the buffer and return all accumulated chunks.
+     * Clears the internal buffer after flushing.
+     */
+    flush(): StreamChunk[];
+    /**
+     * Get the current buffer contents without clearing.
+     */
+    getBuffer(): readonly StreamChunk[];
+    /**
+     * Get the number of chunks currently in the buffer.
+     */
+    get size(): number;
+    /**
+     * Get all chunks of a specific type from the buffer.
+     */
+    getByType(type: StreamChunkType): StreamChunk[];
+    /**
+     * Clear the buffer and reset the sequence counter.
+     */
+    reset(): void;
+}
+//# sourceMappingURL=streamingRenderer.d.ts.map

package/dist/harness/streamingRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamingRenderer.d.ts","sourceRoot":"","sources":["../../src/harness/streamingRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,UAAU,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,CAAC;AAEzF,0CAA0C;AAC1C,MAAM,WAAW,WAAW;IAC1B,gCAAgC;IAChC,IAAI,EAAE,eAAe,CAAC;IACtB,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,gDAAgD;AAChD,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAM/D;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuC;IACjE,OAAO,CAAC,GAAG,CAAK;IAEhB;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW;IAgBzD;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,IAAI;IAOlD;;;OAGG;IACH,KAAK,IAAI,WAAW,EAAE;IAMtB;;OAEG;IACH,SAAS,IAAI,SAAS,WAAW,EAAE;IAInC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,EAAE;IAI/C;;OAEG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/harness/streamingRenderer.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Streaming Renderer (GAP-PERF-004).
+ *
+ * Buffers and dispatches streaming output chunks from harness sessions.
+ * Supports typed chunk handling with listener registration and
+ * buffered replay for late subscribers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingRenderer = void 0;
+// ---------------------------------------------------------------------------
+// Renderer
+// ---------------------------------------------------------------------------
+/**
+ * Buffers streaming output and dispatches chunks to registered listeners.
+ *
+ * Designed for single-session use: one renderer per harness invocation.
+ */
+class StreamingRenderer {
+    buffer = [];
+    listeners = new Set();
+    seq = 0;
+    /**
+     * Push a new chunk into the stream.
+     * Immediately dispatches to all registered listeners.
+     */
+    push(type, content) {
+        const chunk = {
+            type,
+            content,
+            timestamp: new Date().toISOString(),
+            seq: this.seq++,
+        };
+        this.buffer.push(chunk);
+        for (const listener of this.listeners) {
+            listener(chunk);
+        }
+        return chunk;
+    }
+    /**
+     * Register a listener for incoming chunks.
+     * Returns an unsubscribe function.
+     */
+    onChunk(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Flush the buffer and return all accumulated chunks.
+     * Clears the internal buffer after flushing.
+     */
+    flush() {
+        const flushed = [...this.buffer];
+        this.buffer.length = 0;
+        return flushed;
+    }
+    /**
+     * Get the current buffer contents without clearing.
+     */
+    getBuffer() {
+        return [...this.buffer];
+    }
+    /**
+     * Get the number of chunks currently in the buffer.
+     */
+    get size() {
+        return this.buffer.length;
+    }
+    /**
+     * Get all chunks of a specific type from the buffer.
+     */
+    getByType(type) {
+        return this.buffer.filter((c) => c.type === type);
+    }
+    /**
+     * Clear the buffer and reset the sequence counter.
+     */
+    reset() {
+        this.buffer.length = 0;
+        this.seq = 0;
+    }
+}
+exports.StreamingRenderer = StreamingRenderer;