@pasko70/pibo 3.0.2 → 3.1.1

package/dist/previews/config.js

@@ -1,45 +1,15 @@
-import { isIP } from "node:net";
 import { loadPiboConfig } from "../config/config.js";
+import { parsePreviewBaseURL } from "./base-url.js";
 export const DEFAULT_PREVIEW_TTL_MINUTES = 8 * 60;
 export const DEFAULT_PREVIEW_TICKET_TTL_SECONDS = 60;
 export const DEFAULT_PREVIEW_SESSION_TTL_MINUTES = 8 * 60;
-function isLocalPreviewHostname(hostname) {
-    return hostname === "localhost" || hostname.endsWith(".localhost");
-}
-function isValidDnsHostname(hostname) {
-    return isIP(hostname) === 0 &&
-        hostname.length <= 253 &&
-        !hostname.endsWith(".") &&
-        hostname.split(".").every((label) => label.length >= 1 &&
-            label.length <= 63 &&
-            /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label));
-}
 export function loadPreviewConfig() {
     return loadPiboConfig().preview ?? {};
 }
 export function requirePreviewBaseURL(value = loadPreviewConfig().baseURL) {
     if (!value)
         throw new Error("preview.baseURL is required. Set it with `pibo config set preview.baseURL https://preview.example.com`.");
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        throw new Error("preview.baseURL must be an absolute HTTP or HTTPS URL");
-    }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error("preview.baseURL must use http or https");
-    }
-    if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
-        throw new Error("preview.baseURL must contain only scheme, hostname, and optional port");
-    }
-    if (!isValidDnsHostname(url.hostname)) {
-        throw new Error("preview.baseURL hostname must be a DNS hostname without wildcards, IP literals, or a trailing dot");
-    }
-    if (url.protocol === "http:" && !isLocalPreviewHostname(url.hostname)) {
-        throw new Error("preview.baseURL must use https except for localhost development");
-    }
-    return url;
+    return parsePreviewBaseURL(value);
 }
 export function previewPublicURL(previewId, baseURL = requirePreviewBaseURL()) {
     if (previewId.length > 63 || !/^pv-[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(previewId)) {

package/dist/ralph/store.js

@@ -407,6 +407,11 @@ export class PiboRalphStore {
                 this.db.exec('COMMIT');
                 return undefined;
             }
+            if (job.maxIterations !== undefined && (job.state.completedIterations ?? 0) >= job.maxIterations) {
+                this.db.prepare('UPDATE pibo_ralph_jobs SET enabled = 0, updated_at = ? WHERE id = ?').run(timestamp, job.id);
+                this.db.exec('COMMIT');
+                return undefined;
+            }
             const run = this.createRunLocked(job, timestamp);
             const state = { ...job.state, runningAt: timestamp, lastRunAt: timestamp, lastRunId: run.id };
             this.updateJobStateLocked(job.id, state, timestamp);

package/dist/reliability/store.js

@@ -5,6 +5,8 @@ import { ensurePrivatePiboHomeForPath, piboHomePath } from "../core/pibo-home.js
 import { protectPrivateFileSync } from "../core/private-path.js";
 import { sqliteTableColumns } from "../data/sqlite-schema.js";
 import { DatabaseSync } from "node:sqlite";
+const MAX_ATTEMPTS_ERROR = "Job exhausted retry attempts.";
+const MAX_ATTEMPTS_REASON = "max_attempts";
 function now() {
     return new Date().toISOString();
 }
@@ -352,41 +354,73 @@ export class PiboReliabilityStore {
     claimBatch(workerId, limit, options = {}) {
         const timestamp = now();
         const claimExpiresAt = new Date(Date.now() + (options.visibilityTimeoutMs ?? 30000)).toISOString();
-        const clauses = [
-            "((state = 'pending' AND run_at <= ?) OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?))",
-            "(expires_at IS NULL OR expires_at > ?)",
-        ];
-        const values = [timestamp, timestamp, timestamp];
-        if (options.queue) {
-            clauses.push("queue = ?");
-            values.push(options.queue);
-        }
-        this.moveExpiredJobs(timestamp);
-        const rows = this.db
-            .prepare(`
-				UPDATE pibo_jobs
-				SET state = 'running',
-					worker_id = ?,
-					claim_expires_at = ?,
-					claim_token = claim_token + 1,
-					attempts = attempts + 1,
-					updated_at = ?
-				WHERE job_id IN (
-					SELECT job_id FROM pibo_jobs
-					WHERE ${clauses.join(" AND ")}
-					ORDER BY priority DESC, run_at ASC, created_at ASC
-					LIMIT ?
-				)
-				RETURNING *
-			`)
-            .all(workerId, claimExpiresAt, timestamp, ...values, clampLimit(limit));
-        return rows.map(jobFromRow);
+        return this.inImmediateTransaction(() => {
+            const clauses = [
+                "((state = 'pending' AND run_at <= ?) OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?))",
+                "(expires_at IS NULL OR expires_at > ?)",
+                "attempts < max_attempts",
+            ];
+            const values = [timestamp, timestamp, timestamp];
+            if (options.queue) {
+                clauses.push("queue = ?");
+                values.push(options.queue);
+            }
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { queue: options.queue });
+            const rows = this.db
+                .prepare(`
+					UPDATE pibo_jobs
+					SET state = 'running',
+						worker_id = ?,
+						claim_expires_at = ?,
+						claim_token = claim_token + 1,
+						attempts = attempts + 1,
+						updated_at = ?
+					WHERE job_id IN (
+						SELECT job_id FROM pibo_jobs
+						WHERE ${clauses.join(" AND ")}
+						ORDER BY priority DESC, run_at ASC, created_at ASC
+						LIMIT ?
+					)
+					RETURNING *
+				`)
+                .all(workerId, claimExpiresAt, timestamp, ...values, clampLimit(limit));
+            return rows.map(jobFromRow);
+        });
     }
     claimJob(jobId, workerId, visibilityTimeoutMs = 30000) {
         const timestamp = now();
         const claimExpiresAt = new Date(Date.now() + visibilityTimeoutMs).toISOString();
-        const row = this.db
-            .prepare(`
+        return this.inImmediateTransaction(() => {
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { jobId });
+            const row = this.db
+                .prepare(`
+					UPDATE pibo_jobs
+					SET state = 'running',
+						worker_id = ?,
+						claim_expires_at = ?,
+						claim_token = claim_token + 1,
+						attempts = attempts + 1,
+						updated_at = ?
+					WHERE job_id = ?
+						AND state = 'pending'
+						AND run_at <= ?
+						AND attempts < max_attempts
+						AND (expires_at IS NULL OR expires_at > ?)
+					RETURNING *
+				`)
+                .get(workerId, claimExpiresAt, timestamp, jobId, timestamp, timestamp);
+            return row ? jobFromRow(row) : undefined;
+        });
+    }
+    claimRecoverableJob(jobId, workerId, visibilityTimeoutMs = 30000, forcePending = false) {
+        const timestamp = now();
+        const claimExpiresAt = new Date(Date.now() + visibilityTimeoutMs).toISOString();
+        return this.inImmediateTransaction(() => {
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { jobId });
+            const row = this.db.prepare(`
 				UPDATE pibo_jobs
 				SET state = 'running',
 					worker_id = ?,
@@ -395,34 +429,16 @@ export class PiboReliabilityStore {
 					attempts = attempts + 1,
 					updated_at = ?
 				WHERE job_id = ?
-					AND state = 'pending'
-					AND run_at <= ?
+					AND (
+						(state = 'pending' AND (? = 1 OR run_at <= ?))
+						OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
+					)
+					AND attempts < max_attempts
 					AND (expires_at IS NULL OR expires_at > ?)
 				RETURNING *
-			`)
-            .get(workerId, claimExpiresAt, timestamp, jobId, timestamp, timestamp);
-        return row ? jobFromRow(row) : undefined;
-    }
-    claimRecoverableJob(jobId, workerId, visibilityTimeoutMs = 30000, forcePending = false) {
-        const timestamp = now();
-        const claimExpiresAt = new Date(Date.now() + visibilityTimeoutMs).toISOString();
-        const row = this.db.prepare(`
-			UPDATE pibo_jobs
-			SET state = 'running',
-				worker_id = ?,
-				claim_expires_at = ?,
-				claim_token = claim_token + 1,
-				attempts = attempts + 1,
-				updated_at = ?
-			WHERE job_id = ?
-				AND (
-					(state = 'pending' AND (? = 1 OR run_at <= ?))
-					OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
-				)
-				AND (expires_at IS NULL OR expires_at > ?)
-			RETURNING *
-		`).get(workerId, claimExpiresAt, timestamp, jobId, forcePending ? 1 : 0, timestamp, timestamp, timestamp);
-        return row ? jobFromRow(row) : undefined;
+			`).get(workerId, claimExpiresAt, timestamp, jobId, forcePending ? 1 : 0, timestamp, timestamp, timestamp);
+            return row ? jobFromRow(row) : undefined;
+        });
     }
     updateJobPayload(jobId, workerId, payload, claimToken) {
         const result = this.db.prepare(`
@@ -436,15 +452,23 @@ export class PiboReliabilityStore {
     }
     releaseJob(jobId, workerId, delayMs = 0, claimToken) {
         const timestamp = now();
-        const runAt = new Date(Date.parse(timestamp) + Math.max(0, delayMs)).toISOString();
-        const result = this.db.prepare(`
-			UPDATE pibo_jobs
-			SET state = 'pending', worker_id = NULL, claim_expires_at = NULL, run_at = ?, updated_at = ?
-			WHERE job_id = ? AND state = 'running' AND worker_id = ?
-				AND (? IS NULL OR claim_token = ?)
-				AND claim_expires_at IS NOT NULL AND claim_expires_at > ?
-		`).run(runAt, timestamp, jobId, workerId, claimToken ?? null, claimToken ?? null, timestamp);
-        return Number(result.changes ?? 0) > 0;
+        return this.inImmediateTransaction(() => {
+            const row = this.getLiveWorkerJob(jobId, workerId, timestamp, claimToken);
+            if (!row)
+                return false;
+            if (row.attempts >= row.max_attempts) {
+                this.moveJobToDead(row, MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
+                return true;
+            }
+            const runAt = new Date(Date.parse(timestamp) + Math.max(0, delayMs)).toISOString();
+            const result = this.db.prepare(`
+				UPDATE pibo_jobs
+				SET state = 'pending', worker_id = NULL, claim_expires_at = NULL, run_at = ?, updated_at = ?
+				WHERE job_id = ? AND state = 'running' AND worker_id = ?
+					AND (? IS NULL OR claim_token = ?)
+			`).run(runAt, timestamp, jobId, workerId, claimToken ?? null, claimToken ?? null);
+            return Number(result.changes ?? 0) > 0;
+        });
     }
     ack(jobId, workerId, claimToken) {
         const timestamp = now();
@@ -469,7 +493,7 @@ export class PiboReliabilityStore {
                 return false;
             const job = jobFromRow(row);
             if (job.attempts >= job.maxAttempts) {
-                this.moveJobToDead(row, input.error ?? "Job exhausted retry attempts.", "max_attempts", timestamp);
+                this.moveJobToDead(row, input.error ?? MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
                 return true;
             }
             const delayMs = input.delayMs ?? retryDelayMs(job.attempts, input);
@@ -602,16 +626,21 @@ export class PiboReliabilityStore {
     }
     hasRecoverableJobs(queue, includeDeferredPending = false) {
         const timestamp = now();
-        return this.db.prepare(`
-			SELECT 1 AS found FROM pibo_jobs
-			WHERE queue = ?
-				AND (
-					(state = 'pending' AND (? = 1 OR run_at <= ?))
-					OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
-				)
-				AND (expires_at IS NULL OR expires_at > ?)
-			LIMIT 1
-		`).get(queue, includeDeferredPending ? 1 : 0, timestamp, timestamp, timestamp) !== undefined;
+        return this.inImmediateTransaction(() => {
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { queue });
+            return this.db.prepare(`
+				SELECT 1 AS found FROM pibo_jobs
+				WHERE queue = ?
+					AND (
+						(state = 'pending' AND (? = 1 OR run_at <= ?))
+						OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
+					)
+					AND attempts < max_attempts
+					AND (expires_at IS NULL OR expires_at > ?)
+				LIMIT 1
+			`).get(queue, includeDeferredPending ? 1 : 0, timestamp, timestamp, timestamp) !== undefined;
+        });
     }
     quarantineJob(jobId, reason, correlation = {}) {
         const row = this.db.prepare("SELECT * FROM pibo_jobs WHERE job_id = ?").get(jobId);
@@ -749,46 +778,62 @@ export class PiboReliabilityStore {
         return Number(result.changes ?? 0);
     }
     recoverInterruptedRuns(workerId = `run-registry:${process.pid}`) {
-        const rows = this.db.prepare("SELECT * FROM pibo_runs WHERE status = 'running'").all();
-        const recovered = [];
-        const timestamp = now();
-        for (const row of rows) {
-            if (row.job_id && this.hasUnexpiredJobClaim(row.job_id, timestamp, workerId))
-                continue;
-            const run = runFromRow(row);
-            if (run.timeoutAt && run.timeoutAt <= timestamp) {
-                const error = `Run deadline ${run.timeoutAt} elapsed before the interrupted runtime recovered.`;
-                if (run.jobId)
-                    this.moveLiveJobToDead(run.jobId, error, "timeout", timestamp);
-                recovered.push(this.updateRun(run.runId, {
-                    status: "timed_out",
-                    error,
-                    timeoutPhase: "lifetime",
-                    summary: `${run.toolName} run started successfully, then reached its configured timeout.`,
-                    completedAt: timestamp,
-                }) ?? run);
-                continue;
-            }
-            if (run.retryable && run.maxAttempts > 1) {
-                if (run.jobId)
-                    this.releaseJobForRetry(run.jobId, timestamp);
-                recovered.push(this.updateRun(run.runId, {
-                    status: "queued",
-                    summary: `${run.toolName} run is queued for retry after interruption.`,
-                }) ?? run);
-            }
-            else {
-                if (run.jobId)
-                    this.moveLiveJobToDead(run.jobId, "Run was interrupted before completion and the tool is not retryable.", "interrupted", timestamp);
+        return this.inImmediateTransaction(() => {
+            const rows = this.db.prepare("SELECT * FROM pibo_runs WHERE status = 'running'").all();
+            const recovered = [];
+            const timestamp = now();
+            for (const row of rows) {
+                if (row.job_id && this.hasUnexpiredJobClaim(row.job_id, timestamp, workerId))
+                    continue;
+                const run = runFromRow(row);
+                if (run.timeoutAt && run.timeoutAt <= timestamp) {
+                    const error = `Run deadline ${run.timeoutAt} elapsed before the interrupted runtime recovered.`;
+                    if (run.jobId)
+                        this.moveLiveJobToDead(run.jobId, error, "timeout", timestamp);
+                    recovered.push(this.updateRun(run.runId, {
+                        status: "timed_out",
+                        error,
+                        timeoutPhase: "lifetime",
+                        summary: `${run.toolName} run started successfully, then reached its configured timeout.`,
+                        completedAt: timestamp,
+                    }) ?? run);
+                    continue;
+                }
+                const jobRow = run.jobId
+                    ? this.db.prepare("SELECT * FROM pibo_jobs WHERE job_id = ?").get(run.jobId)
+                    : undefined;
+                if (run.retryable && jobRow && jobRow.attempts < jobRow.max_attempts) {
+                    this.releaseJobForRetry(jobRow.job_id, timestamp);
+                    recovered.push(this.updateRun(run.runId, {
+                        status: "queued",
+                        summary: `${run.toolName} run is queued for retry after interruption.`,
+                    }) ?? run);
+                    continue;
+                }
+                if (run.retryable && jobRow && jobRow.attempts >= jobRow.max_attempts) {
+                    this.moveJobToDead(jobRow, MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
+                    recovered.push(this.updateRun(run.runId, {
+                        status: "failed",
+                        error: MAX_ATTEMPTS_ERROR,
+                        summary: `${run.toolName} run failed after exhausting retry attempts.`,
+                        completedAt: timestamp,
+                    }) ?? run);
+                    continue;
+                }
+                const error = run.retryable
+                    ? "Run was interrupted before completion and its retry job is no longer available."
+                    : "Run was interrupted before completion and the tool is not retryable.";
+                if (jobRow)
+                    this.moveJobToDead(jobRow, error, "interrupted", timestamp);
                 recovered.push(this.updateRun(run.runId, {
                     status: "failed",
-                    error: "Run was interrupted before completion and the tool is not retryable.",
+                    error,
                     summary: `${run.toolName} run failed.`,
                     completedAt: timestamp,
                 }) ?? run);
             }
-        }
-        return recovered;
+            return recovered;
+        });
     }
     close() {
         this.db.close();
@@ -843,6 +888,24 @@ export class PiboReliabilityStore {
         for (const row of expired)
             this.moveJobToDead(row, row.last_error ?? "Job expired.", "expired", timestamp);
     }
+    moveExhaustedRecoverableJobs(timestamp, options = {}) {
+        const clauses = [
+            "attempts >= max_attempts",
+            "(state = 'pending' OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?))",
+        ];
+        const values = [timestamp];
+        if (options.jobId) {
+            clauses.push("job_id = ?");
+            values.push(options.jobId);
+        }
+        if (options.queue) {
+            clauses.push("queue = ?");
+            values.push(options.queue);
+        }
+        const exhausted = this.db.prepare(`SELECT * FROM pibo_jobs WHERE ${clauses.join(" AND ")}`).all(...values);
+        for (const row of exhausted)
+            this.moveJobToDead(row, MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
+    }
     hasUnexpiredJobClaim(jobId, timestamp, workerId) {
         const row = this.db
             .prepare(`

package/dist/session-ui/terminalRows.js

@@ -63,7 +63,8 @@ function applyToolDisplayMode(rows, mode) {
     });
 }
 function isToolDisplayRow(row) {
-    return row.id.startsWith("terminal:tool:")
+    return row.sourceNodeIds.some((nodeId) => parseTraceToolNodeIdentity(nodeId) !== undefined)
+        || row.id.startsWith("terminal:tool:")
         || row.kind === "tool.call"
         || row.kind === "tool.image"
         || row.kind === "tool.group.exploring"

package/dist/sessions/pibo-data-store.js

@@ -147,6 +147,65 @@ export class PiboDataSessionStore {
 			`).run(sequence, new Date().toISOString(), piboSessionId);
         });
     }
+    claimOrAttachOutputPart(input) {
+        return this.dataStore.transaction(() => {
+            const indexAttribute = outputPartIndexAttribute(input.kind);
+            const eventTypes = outputPartEventTypes(input.kind);
+            const placeholders = eventTypes.map(() => "?").join(", ");
+            const rows = this.db.prepare(`
+				SELECT type, attributes_json
+				FROM event_log
+				WHERE session_id = ? AND event_id = ? AND type IN (${placeholders})
+				ORDER BY stream_id ASC
+			`).all(input.piboSessionId, input.eventId, ...eventTypes);
+            let maximum = -1;
+            const latestTypeByIndex = new Map();
+            for (const row of rows) {
+                const attributes = parseJsonObject(row.attributes_json);
+                const index = attributes[indexAttribute];
+                if (typeof index !== "number" || !Number.isSafeInteger(index) || index < 0)
+                    continue;
+                maximum = Math.max(maximum, index);
+                if (attributes.outputPartFingerprint === input.fingerprint
+                    || attributes.identityFingerprint === input.identityFingerprint) {
+                    this.observeOutputPartIndex(input, index);
+                    return index;
+                }
+                latestTypeByIndex.set(index, row.type);
+            }
+            const latestOpen = [...latestTypeByIndex.entries()]
+                .filter(([, eventType]) => !outputPartEventIsTerminal(eventType))
+                .sort(([left], [right]) => right - left)[0]?.[0];
+            if (latestOpen !== undefined) {
+                this.observeOutputPartIndex(input, latestOpen);
+                return latestOpen;
+            }
+            const minimum = Math.max(input.proposedIndex, maximum + 1);
+            const row = this.db.prepare(`
+				INSERT INTO session_output_part_counters (
+					pibo_session_id, event_id, part_kind, next_index, updated_at
+				) VALUES (?, ?, ?, ? + 1, ?)
+				ON CONFLICT(pibo_session_id, event_id, part_kind) DO UPDATE SET
+					next_index = MAX(session_output_part_counters.next_index, ?) + 1,
+					updated_at = excluded.updated_at
+				RETURNING next_index - 1 AS part_index
+			`).get(input.piboSessionId, input.eventId, input.kind, minimum, new Date().toISOString(), minimum);
+            return row.part_index;
+        });
+    }
+    observeOutputPartIndex(input, index) {
+        this.db.prepare(`
+			INSERT INTO session_output_part_counters (
+				pibo_session_id, event_id, part_kind, next_index, updated_at
+			) VALUES (?, ?, ?, ?, ?)
+			ON CONFLICT(pibo_session_id, event_id, part_kind) DO UPDATE SET
+				next_index = MAX(session_output_part_counters.next_index, excluded.next_index),
+				updated_at = CASE
+					WHEN excluded.next_index > session_output_part_counters.next_index THEN excluded.updated_at
+					ELSE session_output_part_counters.updated_at
+				END
+		`).run(input.piboSessionId, input.eventId, input.kind, index + 1, new Date().toISOString());
+    }
     claimOutputToolInvocationOrdinal(piboSessionId, eventId, toolCallId) {
         return this.dataStore.transaction(() => {
             const durable = this.db.prepare(`
@@ -562,6 +621,28 @@ function runtimeBindingFromRow(row) {
 function isRuntimeBindingState(value) {
     return value === "unbound" || value === "bound" || value === "missing" || value === "error";
 }
+function outputPartIndexAttribute(kind) {
+    switch (kind) {
+        case "assistant": return "assistantIndex";
+        case "thinking": return "thinkingIndex";
+        case "usage": return "usageIndex";
+        case "compaction": return "compactionIndex";
+    }
+}
+function outputPartEventTypes(kind) {
+    switch (kind) {
+        case "assistant": return ["assistant_delta", "assistant_message"];
+        case "thinking": return ["thinking_started", "thinking_delta", "thinking_finished"];
+        case "usage": return ["assistant_usage"];
+        case "compaction": return ["compaction_start", "compaction_end"];
+    }
+}
+function outputPartEventIsTerminal(eventType) {
+    return eventType === "assistant_message"
+        || eventType === "thinking_finished"
+        || eventType === "assistant_usage"
+        || eventType === "compaction_end";
+}
 function parseJsonObject(json) {
     if (!json)
         return {};

package/dist/subagents/observation-query.js

@@ -0,0 +1,121 @@
+import { PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES, normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, normalizePiboAgentObservationToolDetail, parsePiboAgentObservationTimestamp, piboAgentObservationKind, piboAgentObservationToolSummary, } from "./observations.js";
+export function preparePiboAgentObservationQuery(input = {}) {
+    const order = normalizePiboAgentObservationOrder(input.order);
+    const limit = normalizePiboAgentObservationLimit(input.limit);
+    const toolDetail = normalizePiboAgentObservationToolDetail(input.toolDetail);
+    const afterSequence = normalizePiboAgentObservationCursor(input.afterSequence);
+    const since = parsePiboAgentObservationTimestamp(input.since, "since");
+    const until = parsePiboAgentObservationTimestamp(input.until, "until");
+    if (since !== undefined && until !== undefined && since > until) {
+        throw new Error("Agent observation since must not be after until.");
+    }
+    if (input.toolCallIds && input.toolCallIds.length > 50) {
+        throw new Error("Agent observation toolCallIds must contain at most 50 entries.");
+    }
+    const requestIds = input.requestIds ? new Set(input.requestIds) : undefined;
+    const toolCallIds = input.toolCallIds ? new Set(input.toolCallIds) : undefined;
+    const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
+    const names = input.names ? new Set(input.names) : undefined;
+    const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
+    const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
+    const kinds = input.kinds ? new Set(input.kinds) : undefined;
+    const roles = input.roles ? new Set(input.roles) : undefined;
+    const textContains = input.textContains?.toLowerCase();
+    const defaultMessageView = eventTypes === undefined && kinds === undefined;
+    const explicitlySelectsTools = input.eventTypes?.some((eventType) => piboAgentObservationKind(eventType) === "tool") === true
+        || input.kinds?.includes("tool") === true
+        || toolCallIds !== undefined;
+    const includeTools = input.includeTools === true || (input.includeTools === undefined && explicitlySelectsTools);
+    const defaultEventTypes = includeTools
+        ? [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, ...PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES]
+        : [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES];
+    const defaultEventTypeSet = new Set(defaultEventTypes);
+    const scanEventTypes = defaultMessageView
+        ? defaultEventTypes
+        : input.eventTypes && input.eventTypes.length > 0
+            ? [...input.eventTypes]
+            : undefined;
+    return {
+        filters: {
+            ...input,
+            ...(defaultMessageView ? { eventTypes: defaultEventTypes } : {}),
+            ...(afterSequence !== undefined ? { afterSequence } : {}),
+            order,
+            limit,
+            includeTools,
+            toolDetail,
+            includeDetails: input.includeDetails === true,
+        },
+        ...(afterSequence !== undefined ? { afterSequence } : {}),
+        order,
+        scanOrder: afterSequence !== undefined ? "asc" : order,
+        limit,
+        includeTools,
+        toolDetail,
+        ...(scanEventTypes ? { scanEventTypes } : {}),
+        matches(observation) {
+            if (requestIds && (!observation.requestId || !requestIds.has(observation.requestId)))
+                return false;
+            if (toolCallIds && (!observation.toolCallId || !toolCallIds.has(observation.toolCallId)))
+                return false;
+            if (agentIds && !agentIds.has(observation.agentId))
+                return false;
+            if (names && !names.has(observation.name))
+                return false;
+            if (threadKeys && (!observation.threadKey || !threadKeys.has(observation.threadKey)))
+                return false;
+            if (observation.kind === "tool" && !includeTools)
+                return false;
+            if (defaultMessageView && !defaultEventTypeSet.has(observation.eventType))
+                return false;
+            if (eventTypes && !eventTypes.has(observation.eventType))
+                return false;
+            if (kinds && !kinds.has(observation.kind))
+                return false;
+            if (roles && (!observation.role || !roles.has(observation.role)))
+                return false;
+            if (afterSequence !== undefined && observation.sequence <= afterSequence)
+                return false;
+            const createdAt = Date.parse(observation.createdAt);
+            if (since !== undefined && createdAt < since)
+                return false;
+            if (until !== undefined && createdAt > until)
+                return false;
+            if (textContains && !(observation.text ?? "").toLowerCase().includes(textContains))
+                return false;
+            return true;
+        },
+    };
+}
+export function selectPiboAgentObservationPage(observations, query, options = {}) {
+    const matches = [];
+    for (const observation of observations) {
+        if (!query.matches(observation))
+            continue;
+        matches.push(observation);
+        if (matches.length > query.limit)
+            break;
+    }
+    const pageLimited = matches.length > query.limit;
+    const selected = matches.slice(0, query.limit);
+    if (query.afterSequence !== undefined && query.order === "desc")
+        selected.reverse();
+    const projected = selected.map((observation) => {
+        const { details, ...visible } = observation;
+        const compact = visible.kind === "tool" && query.toolDetail === "summary"
+            ? { ...visible, text: piboAgentObservationToolSummary(visible.text, visible.isError, details) }
+            : visible;
+        return query.filters.includeDetails === true && details !== undefined ? { ...compact, details } : compact;
+    });
+    const evictedThrough = options.evictedThrough ?? 0;
+    const retentionTruncated = query.afterSequence === undefined
+        ? evictedThrough > 0
+        : query.afterSequence < evictedThrough;
+    const nextAfterSequence = projected.reduce((maximum, observation) => Math.max(maximum, observation.sequence), query.afterSequence === undefined ? 0 : Math.max(query.afterSequence, evictedThrough));
+    return {
+        filters: query.filters,
+        observations: projected,
+        nextAfterSequence,
+        truncated: retentionTruncated || pageLimited,
+    };
+}