@getpaseo/server 0.3.0-beta.4 → 0.3.0

package/dist/server/server/agent/mcp-shared.d.ts

@@ -8,9 +8,9 @@ import type { AgentProvider } from "./agent-sdk-types.js";
 export declare const AgentProviderEnum: z.ZodString;
 export declare const AgentStatusEnum: z.ZodEnum<{
     error: "error";
+    initializing: "initializing";
     idle: "idle";
     running: "running";
-    initializing: "initializing";
     closed: "closed";
 }>;
 export declare const ProviderModeSchema: z.ZodObject<{
@@ -83,7 +83,7 @@ export declare function serializeSnapshotWithMetadata(agentStorage: AgentStorage
     createdAt: string;
     updatedAt: string;
     lastUserMessageAt: string | null;
-    status: "error" | "idle" | "running" | "initializing" | "closed";
+    status: "error" | "initializing" | "idle" | "running" | "closed";
     capabilities: import("@getpaseo/protocol/agent-types").AgentCapabilityFlags;
     currentModeId: string | null;
     availableModes: import("@getpaseo/protocol/agent-types").AgentMode[];

package/dist/server/server/agent-history-search.d.ts

@@ -0,0 +1,48 @@
+import type { AgentSearchMatch, AgentSnapshotPayload, ProjectPlacementPayload } from "@getpaseo/protocol/messages";
+/**
+ * History search ranks what the daemon already knows about a session: the four
+ * names attached to it. Transcripts are deliberately out — they are unbounded,
+ * and a partial-transcript index would answer "not found" for sessions that do
+ * contain the phrase, which is worse than never claiming to search them.
+ *
+ * Field order is the tie-break order. Workspace and agent titles are what
+ * people actually recall; a project name matches every session in the repo, so
+ * it ranks last and only decides ties.
+ */
+export interface AgentHistorySearchCandidate {
+    agent: AgentSnapshotPayload;
+    project: ProjectPlacementPayload;
+}
+/**
+ * Every token has to match something, so adding a word always narrows. Tokens
+ * may land on different fields — "stripe main" finds the Stripe workspace on
+ * the main branch.
+ */
+export declare function scoreAgentHistoryCandidate(query: string, candidate: AgentHistorySearchCandidate): number | null;
+/**
+ * Where the query landed in each field, for the rows that will actually be
+ * rendered. The ranker already knows this; sending it means the client never
+ * has to re-derive a second opinion that could disagree with the ranking it is
+ * explaining.
+ */
+export declare function describeAgentHistoryMatches(query: string, candidate: AgentHistorySearchCandidate): AgentSearchMatch[];
+export interface RankedAgentHistoryCandidate<T extends AgentHistorySearchCandidate> {
+    candidate: T;
+    searchScore: number;
+}
+/**
+ * Ranks the whole candidate set rather than a page of it. The daemon holds
+ * every persisted agent in memory already, so search is complete by
+ * construction and the client never has to warn that it only looked at what it
+ * had loaded.
+ *
+ * A searched response is one page: the best `limit` matches, and a flag saying
+ * more matched. There is no search cursor. Offsets into a ranking that is
+ * recomputed per request duplicate and skip rows as history mutates underneath
+ * them, and a keyset cursor would buy the ability to walk past result 200 of a
+ * relevance order — which is browsing, not searching. Narrowing the query is
+ * the answer, and the global top K is exactly recoverable from each host's own
+ * top K, which is what lets several hosts merge without a federated pager.
+ */
+export declare function rankAgentHistoryCandidates<T extends AgentHistorySearchCandidate>(query: string, candidates: readonly T[], compareTies: (left: T, right: T) => number): RankedAgentHistoryCandidate<T>[];
+//# sourceMappingURL=agent-history-search.d.ts.map

package/dist/server/server/agent-history-search.js

@@ -0,0 +1,129 @@
+import { compareMatchScores, fuzzyPolicyForToken, matchRanges, scoreMatch, tokenizeQuery, } from "@getpaseo/protocol/search/text-match";
+/** In tie-break order; the index into this list is a field's rank. */
+const SEARCH_FIELDS = ["workspace", "title", "branch", "project"];
+function searchableFields(candidate) {
+    const { agent, project } = candidate;
+    return [
+        project.workspaceName ?? "",
+        agent.title ?? "",
+        project.checkout.currentBranch ?? "",
+        project.projectName,
+    ];
+}
+function bestFieldMatch(token, fields) {
+    const fuzzy = fuzzyPolicyForToken(token);
+    let best = null;
+    for (let fieldRank = 0; fieldRank < fields.length; fieldRank += 1) {
+        const field = fields[fieldRank];
+        if (!field)
+            continue;
+        const score = scoreMatch(token, field, { fuzzy });
+        if (!score)
+            continue;
+        if (!best || compareMatchScores(score, best.score) < 0) {
+            best = { score, fieldRank, token };
+        }
+    }
+    return best;
+}
+/** Overlapping spans from different tokens would double-mark the same glyphs. */
+function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((left, right) => left.start - right.start);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged.at(-1);
+        if (last && range.start <= last.start + last.length) {
+            last.length = Math.max(last.length, range.start + range.length - last.start);
+            continue;
+        }
+        merged.push({ ...range });
+    }
+    return merged;
+}
+/**
+ * One number so the wire can carry relevance and several hosts' pages can be
+ * merged by it. Tier dominates, then which field matched, then how deep into
+ * that field the match sat.
+ */
+function toSearchScore(matches) {
+    let total = 0;
+    for (const match of matches) {
+        total += match.score.tier * 1000 + match.fieldRank * 100 + Math.min(match.score.offset, 99);
+    }
+    return total;
+}
+/**
+ * Every token has to match something, so adding a word always narrows. Tokens
+ * may land on different fields — "stripe main" finds the Stripe workspace on
+ * the main branch.
+ */
+export function scoreAgentHistoryCandidate(query, candidate) {
+    const matches = matchAgentHistoryCandidate(query, candidate);
+    return matches ? toSearchScore(matches) : null;
+}
+function matchAgentHistoryCandidate(query, candidate) {
+    const tokens = tokenizeQuery(query);
+    if (tokens.length === 0)
+        return null;
+    const fields = searchableFields(candidate);
+    const matches = [];
+    for (const token of tokens) {
+        const match = bestFieldMatch(token, fields);
+        if (!match)
+            return null;
+        matches.push(match);
+    }
+    return matches;
+}
+/**
+ * Where the query landed in each field, for the rows that will actually be
+ * rendered. The ranker already knows this; sending it means the client never
+ * has to re-derive a second opinion that could disagree with the ranking it is
+ * explaining.
+ */
+export function describeAgentHistoryMatches(query, candidate) {
+    const matches = matchAgentHistoryCandidate(query, candidate);
+    if (!matches)
+        return [];
+    const fields = searchableFields(candidate);
+    const rangesByField = new Map();
+    for (const match of matches) {
+        const field = SEARCH_FIELDS[match.fieldRank];
+        const ranges = matchRanges(match.token, fields[match.fieldRank], match.score);
+        rangesByField.set(field, [...(rangesByField.get(field) ?? []), ...ranges]);
+    }
+    return [...rangesByField.entries()].map(([field, ranges]) => ({
+        field,
+        ranges: mergeRanges(ranges),
+    }));
+}
+/**
+ * Ranks the whole candidate set rather than a page of it. The daemon holds
+ * every persisted agent in memory already, so search is complete by
+ * construction and the client never has to warn that it only looked at what it
+ * had loaded.
+ *
+ * A searched response is one page: the best `limit` matches, and a flag saying
+ * more matched. There is no search cursor. Offsets into a ranking that is
+ * recomputed per request duplicate and skip rows as history mutates underneath
+ * them, and a keyset cursor would buy the ability to walk past result 200 of a
+ * relevance order — which is browsing, not searching. Narrowing the query is
+ * the answer, and the global top K is exactly recoverable from each host's own
+ * top K, which is what lets several hosts merge without a federated pager.
+ */
+export function rankAgentHistoryCandidates(query, candidates, compareTies) {
+    const ranked = [];
+    for (const candidate of candidates) {
+        const searchScore = scoreAgentHistoryCandidate(query, candidate);
+        if (searchScore === null)
+            continue;
+        ranked.push({ candidate, searchScore });
+    }
+    ranked.sort((left, right) => {
+        if (left.searchScore !== right.searchScore)
+            return left.searchScore - right.searchScore;
+        return compareTies(left.candidate, right.candidate);
+    });
+    return ranked;
+}
+//# sourceMappingURL=agent-history-search.js.map

package/dist/server/server/session.d.ts

@@ -364,6 +364,13 @@ export declare class Session {
     private buildActiveProjectPlacementsByWorkspaceId;
     private collectFetchAgentsEntries;
     private listFetchAgentsEntries;
+    /**
+     * The searched history page. Ranking has to see every candidate before it can
+     * name the best one, so this path resolves placements for the whole set
+     * instead of stopping at the page limit — that is what makes a query answer
+     * from all persisted sessions rather than from the first page of them.
+     */
+    private listRankedAgentHistoryEntries;
     private readonly agentsPager;
     private decodeAgentCursor;
     private describeWorkspaceRecord;

package/dist/server/server/session.js

@@ -8,6 +8,7 @@ import { serializeAgentStreamEvent, } from "./messages.js";
 import { TerminalSessionController } from "../terminal/terminal-session-controller.js";
 import { CursorError } from "./pagination/cursor.js";
 import { SortablePager } from "./pagination/sortable-pager.js";
+import { describeAgentHistoryMatches, rankAgentHistoryCandidates } from "./agent-history-search.js";
 import { buildConfigOverrides, isStoredAgentProviderAvailable, toAgentPersistenceHandle, } from "./persistence-hooks.js";
 import { ensureAgentLoaded, ensureUnarchivedAgentLoaded } from "./agent/agent-loading.js";
 import { formatSystemNotificationPrompt, sendPromptToAgent, waitForAgentRunStartWithTimeout, unarchiveAgentState, } from "./agent/agent-prompt.js";
@@ -131,6 +132,15 @@ export function resolveWaitForFinishError(options) {
     const message = options.final?.lastError;
     return typeof message === "string" && message.trim().length > 0 ? message : "Agent failed";
 }
+/**
+ * Only history carries a query. The active-agents directory filters on
+ * structure and never ranks, so it always reads as no query at all.
+ */
+function agentDirectorySearchQuery(request) {
+    if (request.type !== "fetch_agent_history_request")
+        return "";
+    return request.search?.trim() ?? "";
+}
 class SessionRequestError extends Error {
     constructor(code, message) {
         super(message);
@@ -3198,6 +3208,17 @@ export class Session {
             placementByWorkspaceId.set(workspaceId, placementPromise);
             return placementPromise;
         };
+        const search = agentDirectorySearchQuery(request);
+        if (search) {
+            return this.listRankedAgentHistoryEntries({
+                search,
+                agents,
+                sort,
+                filter,
+                getPlacement,
+                page: request.page,
+            });
+        }
         let candidates = [...agents];
         candidates.sort((left, right) => this.agentsPager.compare(left, right, sort));
         const cursorToken = request.page?.cursor;
@@ -3226,6 +3247,41 @@ export class Session {
             },
         };
     }
+    /**
+     * The searched history page. Ranking has to see every candidate before it can
+     * name the best one, so this path resolves placements for the whole set
+     * instead of stopping at the page limit — that is what makes a query answer
+     * from all persisted sessions rather than from the first page of them.
+     */
+    async listRankedAgentHistoryEntries(params) {
+        const { search, agents, sort, filter, getPlacement, page } = params;
+        if (page?.cursor) {
+            // A ranked result set has no pages to walk, so a cursor here is caller
+            // misuse. Returning the ranked head instead would hide it.
+            throw new SessionRequestError("invalid_cursor", "A history search returns one ranked page; it cannot be paged with a cursor.");
+        }
+        const allEntries = await this.collectFetchAgentsEntries({
+            candidates: agents,
+            limit: Number.MAX_SAFE_INTEGER,
+            getPlacement,
+            filter,
+        });
+        const ranked = rankAgentHistoryCandidates(search, allEntries, (left, right) => this.agentsPager.compare(left.agent, right.agent, sort));
+        const limit = page?.limit ?? 200;
+        // Ranges are derived only for the rows that will be rendered; ranking
+        // itself never needs them.
+        const entries = ranked.slice(0, limit).map((result) => Object.assign({}, result.candidate, {
+            searchScore: result.searchScore,
+            searchMatches: describeAgentHistoryMatches(search, result.candidate),
+        }));
+        return {
+            entries,
+            // No next page exists, so `hasMore` is false and truncation is reported
+            // on its own field. See the note on rankAgentHistoryCandidates.
+            pageInfo: { nextCursor: null, prevCursor: null, hasMore: false },
+            searchTruncated: ranked.length > limit,
+        };
+    }
     decodeAgentCursor(token, sort) {
         try {
             return this.agentsPager.decode(token, sort);

package/dist/server/server/websocket-server.js

@@ -1062,6 +1062,8 @@ export class VoiceAssistantWebSocketServer {
                 rewind: true,
                 // COMPAT(agentTimelinePromptIndex): added in v0.2.X, drop the gate when floor >= v0.2.X.
                 agentTimelinePromptIndex: true,
+                // COMPAT(agentHistorySearch): added in v0.3.0, remove gate after 2027-02-07.
+                agentHistorySearch: true,
                 // COMPAT(checkoutRefresh): added in v0.1.86, remove gate after 2026-11-29.
                 checkoutRefresh: true,
                 // COMPAT(workspaceMultiplicity): added in v0.1.97, drop the gate when floor >= v0.1.97

package/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-bridge-280bd28c6e8031e562e84a5381d2c1c1.js → desktop-attachment-bridge-78bca55e001d8c210fd05d625c99acf2.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},4672,[4123,4124]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},4676,[4123,4124]);

package/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-store-453c818cb8f94014304c6c7d1a2b2e40.js → desktop-attachment-store-fb478be7d05fee363960b3c2f31779a1.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},4671,[4117]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},4675,[4117]);