@agent-native/core 0.53.0 → 0.54.1

package/dist/provider-api/corpus-jobs.d.ts

@@ -142,5 +142,85 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     deleted?: undefined;
     jobId?: undefined;
 }>;
+export declare function createProviderCorpusJobReadAction(options: Pick<CreateProviderCorpusJobActionOptions, "appId">): import("../action.js").ActionDefinition<{
+    operation?: "status" | "list" | "results" | undefined;
+    jobId?: string | undefined;
+    offset?: unknown;
+    limit?: unknown;
+}, {
+    job: {
+        id: string;
+        name: string;
+        mode: string;
+        status: ProviderCorpusJobStatus;
+        provider: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+    coverage: {
+        pagesProcessed: number;
+        batchesProcessed: number;
+        itemsProcessed: number;
+        matchedItems: number;
+        totalHits: number;
+        storedHits: number;
+        truncatedHits: boolean;
+    };
+    checkpoint: Record<string, unknown>;
+    error: string | null;
+    nextResumeAt: string | null;
+} | {
+    jobs: {
+        job: {
+            id: string;
+            name: string;
+            mode: string;
+            status: ProviderCorpusJobStatus;
+            provider: string;
+            createdAt: string;
+            updatedAt: string;
+        };
+        coverage: {
+            pagesProcessed: number;
+            batchesProcessed: number;
+            itemsProcessed: number;
+            matchedItems: number;
+            totalHits: number;
+            storedHits: number;
+            truncatedHits: boolean;
+        };
+        checkpoint: Record<string, unknown>;
+        error: string | null;
+        nextResumeAt: string | null;
+    }[];
+    total: number;
+} | {
+    hits: Record<string, unknown>[];
+    offset: number;
+    limit: number;
+    job: {
+        id: string;
+        name: string;
+        mode: string;
+        status: ProviderCorpusJobStatus;
+        provider: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+    coverage: {
+        pagesProcessed: number;
+        batchesProcessed: number;
+        itemsProcessed: number;
+        matchedItems: number;
+        totalHits: number;
+        storedHits: number;
+        truncatedHits: boolean;
+    };
+    checkpoint: Record<string, unknown>;
+    error: string | null;
+    nextResumeAt: string | null;
+    jobs?: undefined;
+    total?: undefined;
+}>;
 export {};
 //# sourceMappingURL=corpus-jobs.d.ts.map

package/dist/provider-api/corpus-jobs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"corpus-jobs.d.ts","sourceRoot":"","sources":["../../src/provider-api/corpus-jobs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAqB,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE5E,OAAO,EASL,KAAK,uBAAuB,EAC7B,MAAM,wBAAwB,CAAC;AAEhC,KAAK,qBAAqB,GAAG;IAC3B,cAAc,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAChE,CAAC;AAEF,MAAM,WAAW,oCAAoC;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,qBAAqB,CAAC;CACzC;AAiOD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAa9C"}
+{"version":3,"file":"corpus-jobs.d.ts","sourceRoot":"","sources":["../../src/provider-api/corpus-jobs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAqB,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE5E,OAAO,EASL,KAAK,uBAAuB,EAC7B,MAAM,wBAAwB,CAAC;AAEhC,KAAK,qBAAqB,GAAG;IAC3B,cAAc,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAChE,CAAC;AAEF,MAAM,WAAW,oCAAoC;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,qBAAqB,CAAC;CACzC;AA0PD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAa9C;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,IAAI,CAAC,oCAAoC,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAY7D"}

package/dist/provider-api/corpus-jobs.js

@@ -178,6 +178,18 @@ const ProviderCorpusJobSchema = z.object({
         .optional()
         .describe("Results/list limit."),
 });
+const ProviderCorpusJobReadSchema = z.object({
+    operation: z.enum(["list", "status", "results"]).default("list"),
+    jobId: z.string().optional().describe("Existing job id for status/results."),
+    offset: z.coerce.number().int().min(0).optional().describe("Results offset."),
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(1_000)
+        .optional()
+        .describe("Results/list limit."),
+});
 const DEFAULT_PAGE_BUDGET = 25;
 const DEFAULT_BATCH_BUDGET = 25;
 const DEFAULT_RUNTIME_MS = 90_000;
@@ -196,6 +208,17 @@ export function createProviderCorpusJobAction(options) {
         run: async (args) => runProviderCorpusJobAction(args, options),
     });
 }
+export function createProviderCorpusJobReadAction(options) {
+    return defineAction({
+        description: "Read provider corpus job status and stored results for the current user. " +
+            "This read-only companion is for UI polling and status surfaces; it cannot start or continue provider requests.",
+        schema: ProviderCorpusJobReadSchema,
+        http: { method: "GET" },
+        readOnly: true,
+        agentTool: false,
+        run: async (args) => runProviderCorpusJobReadAction(args, options),
+    });
+}
 async function runProviderCorpusJobAction(args, options) {
     const ctx = getCredentialContext();
     if (!ctx)
@@ -256,6 +279,45 @@ async function runProviderCorpusJobAction(args, options) {
     }
     throw new Error(`Unsupported provider corpus operation ${args.operation}.`);
 }
+async function runProviderCorpusJobReadAction(args, options) {
+    const ctx = getCredentialContext();
+    if (!ctx)
+        throw new Error("No authenticated context for provider corpus jobs.");
+    if (args.operation === "list") {
+        const jobs = await listProviderCorpusJobs({
+            appId: options.appId,
+            ownerEmail: ctx.userEmail,
+            limit: args.limit,
+        });
+        return { jobs: jobs.map(jobStatus), total: jobs.length };
+    }
+    const jobId = args.jobId?.trim();
+    if (!jobId)
+        throw new Error(`${args.operation} requires jobId.`);
+    const job = await getProviderCorpusJob({
+        id: jobId,
+        appId: options.appId,
+        ownerEmail: ctx.userEmail,
+    });
+    if (!job) {
+        throw new Error(`Provider corpus job ${jobId} not found or belongs to another owner/app.`);
+    }
+    if (args.operation === "status")
+        return jobStatus(job);
+    const hits = await getProviderCorpusJobHits({
+        jobId,
+        appId: options.appId,
+        ownerEmail: ctx.userEmail,
+        offset: args.offset,
+        limit: args.limit,
+    });
+    return {
+        ...jobStatus(job),
+        hits,
+        offset: args.offset ?? 0,
+        limit: args.limit ?? 100,
+    };
+}
 async function startJob(args, appId, ownerEmail) {
     if (!args.mode)
         throw new Error("start requires mode.");
@@ -697,7 +759,11 @@ function searchItems(items, search, options) {
                     kind: match.kind,
                     query: match.query,
                     match: match.match,
-                    snippet: makeSnippet(field.text, match.index, search.contextChars),
+                    snippet: match.snippet ??
+                        makeSnippet(field.text, match.index, search.contextChars, match.endIndex),
+                    ...(match.matchedTerms?.length
+                        ? { matchedTerms: match.matchedTerms }
+                        : {}),
                     ...(Object.keys(metadata).length ? { metadata } : {}),
                 });
             }
@@ -1072,21 +1138,54 @@ function findItemWideTermMatch(fields, search) {
     if (!terms.length || search.matchMode === "anyTerm")
         return null;
     const caseSensitive = Boolean(search.caseSensitive);
+    const fieldWindows = fields
+        .map((field) => {
+        const hits = bestTermClusterInText(field.text, terms, caseSensitive).map((hit) => ({ ...hit, field }));
+        if (hits.length !== terms.length)
+            return null;
+        const start = Math.min(...hits.map((hit) => hit.index));
+        const end = Math.max(...hits.map((hit) => hit.end));
+        return {
+            field,
+            hits,
+            start,
+            end,
+            length: end - start,
+        };
+    })
+        .filter((result) => Boolean(result))
+        .sort((a, b) => a.length - b.length || a.start - b.start);
+    const bestFieldWindow = fieldWindows[0];
+    if (bestFieldWindow) {
+        const context = boundedNumber(search.contextChars, 180, 20, 1_000);
+        const snippet = bestFieldWindow.length > context * 4
+            ? makeCombinedTermSnippet(bestFieldWindow.hits, search.contextChars)
+            : undefined;
+        return {
+            field: bestFieldWindow.field,
+            match: {
+                kind: "allTerms",
+                query: terms.join(" "),
+                index: bestFieldWindow.start,
+                endIndex: bestFieldWindow.end,
+                match: bestFieldWindow.field.text.slice(bestFieldWindow.start, bestFieldWindow.end),
+                matchedTerms: terms,
+                snippet,
+            },
+        };
+    }
     const termHits = terms.map((term) => {
-        const needle = caseSensitive ? term : term.toLowerCase();
         for (const field of fields) {
-            const haystack = caseSensitive ? field.text : field.text.toLowerCase();
-            const index = haystack.indexOf(needle);
-            if (index >= 0)
-                return { term, field, index };
+            const hit = firstTermHitInField(field, term, caseSensitive);
+            if (hit)
+                return hit;
         }
-        return { term, field: null, index: -1 };
+        return null;
     });
-    if (termHits.some((hit) => !hit.field || hit.index < 0))
+    if (termHits.some((hit) => !hit))
         return null;
-    const first = termHits
-        .filter((hit) => Boolean(hit.field))
-        .sort((a, b) => a.index - b.index)[0];
+    const hits = termHits.filter(isTermHit);
+    const first = hits.sort((a, b) => a.index - b.index)[0];
     if (!first)
         return null;
     return {
@@ -1095,7 +1194,10 @@ function findItemWideTermMatch(fields, search) {
             kind: "allTerms",
             query: terms.join(" "),
             index: first.index,
-            match: first.term,
+            endIndex: first.end,
+            match: first.match,
+            matchedTerms: terms,
+            snippet: makeCombinedTermSnippet(hits, search.contextChars),
         },
     };
 }
@@ -1150,22 +1252,29 @@ function findSearchMatches(text, search, includeTerms) {
         addSubstring(query, query, "query");
     const terms = includeTerms ? normalizedTerms(search) : [];
     if (terms.length) {
-        const hits = terms
-            .map((term) => {
-            const needle = caseSensitive ? term : term.toLowerCase();
-            return { term, index: haystack.indexOf(needle) };
-        })
-            .filter((hit) => hit.index >= 0);
         const mode = search.matchMode === "anyTerm" ? "anyTerm" : "allTerms";
+        const hits = mode === "allTerms"
+            ? bestTermClusterInText(source, terms, caseSensitive)
+            : terms
+                .map((term) => firstTermHitInText(source, haystack, caseSensitive ? term : term.toLowerCase(), term))
+                .filter(isInlineTermHit)
+                .sort((a, b) => a.index - b.index);
         if ((mode === "allTerms" && hits.length === terms.length) ||
             (mode === "anyTerm" && hits.length > 0)) {
-            const first = hits.sort((a, b) => a.index - b.index)[0];
+            const first = hits[0];
             if (first) {
+                const endIndex = mode === "allTerms"
+                    ? Math.max(...hits.map((hit) => hit.end))
+                    : first.end;
                 matches.push({
                     kind: mode,
                     query: terms.join(" "),
                     index: first.index,
-                    match: first.term,
+                    endIndex,
+                    match: mode === "allTerms"
+                        ? source.slice(first.index, endIndex)
+                        : first.match,
+                    matchedTerms: mode === "allTerms" ? terms : hits.map((hit) => hit.term),
                 });
             }
         }
@@ -1179,14 +1288,102 @@ function normalizeRegexFlags(flags, caseSensitive) {
     const withCase = caseSensitive || /i/.test(allowed) ? allowed : `${allowed}i`;
     return `${withCase}g`;
 }
-function makeSnippet(text, index, contextChars) {
+function makeSnippet(text, index, contextChars, endIndex = index) {
     const context = boundedNumber(contextChars, 180, 20, 1_000);
     const start = Math.max(0, index - context);
-    const end = Math.min(text.length, index + context);
+    const end = Math.min(text.length, Math.max(index, endIndex) + context);
     const prefix = start > 0 ? "..." : "";
     const suffix = end < text.length ? "..." : "";
     return `${prefix}${text.slice(start, end)}${suffix}`
         .replace(/\s+/g, " ")
         .trim();
 }
+function firstTermHitInText(source, haystack, needle, term) {
+    const index = haystack.indexOf(needle);
+    return index >= 0
+        ? {
+            term,
+            index,
+            end: index + term.length,
+            match: source.slice(index, index + term.length),
+        }
+        : null;
+}
+function firstTermHitInField(field, term, caseSensitive) {
+    const source = field.text;
+    const haystack = caseSensitive ? source : source.toLowerCase();
+    const needle = caseSensitive ? term : term.toLowerCase();
+    const hit = firstTermHitInText(source, haystack, needle, term);
+    return hit ? { ...hit, term, field } : null;
+}
+function isInlineTermHit(hit) {
+    return Boolean(hit);
+}
+function isTermHit(hit) {
+    return Boolean(hit);
+}
+function bestTermClusterInText(source, terms, caseSensitive) {
+    const haystack = caseSensitive ? source : source.toLowerCase();
+    const allHits = terms.map((term) => {
+        const needle = caseSensitive ? term : term.toLowerCase();
+        const hits = [];
+        let from = 0;
+        while (from <= haystack.length) {
+            const index = haystack.indexOf(needle, from);
+            if (index < 0)
+                break;
+            hits.push({
+                term,
+                index,
+                end: index + term.length,
+                match: source.slice(index, index + term.length),
+            });
+            from = index + Math.max(1, needle.length);
+            if (hits.length >= 100)
+                break;
+        }
+        return hits;
+    });
+    if (allHits.some((hits) => hits.length === 0))
+        return [];
+    const flattened = allHits
+        .flat()
+        .sort((a, b) => a.index - b.index || a.end - b.end);
+    let best = null;
+    let bestLength = Infinity;
+    for (let start = 0; start < flattened.length; start++) {
+        const selected = new Map();
+        for (let end = start; end < flattened.length; end++) {
+            const hit = flattened[end];
+            selected.set(hit.term, hit);
+            if (selected.size !== terms.length)
+                continue;
+            const cluster = terms
+                .map((term) => selected.get(term))
+                .filter(isInlineTermHit)
+                .sort((a, b) => a.index - b.index);
+            const length = Math.max(...cluster.map((item) => item.end)) -
+                Math.min(...cluster.map((item) => item.index));
+            if (length < bestLength) {
+                best = cluster;
+                bestLength = length;
+            }
+            break;
+        }
+    }
+    return best ?? [];
+}
+function makeCombinedTermSnippet(hits, contextChars) {
+    const context = boundedNumber(contextChars, 180, 20, 1_000);
+    const shownHits = hits.slice(0, 5);
+    const perHitContext = Math.max(20, Math.min(120, Math.floor(context / Math.max(1, Math.min(3, hits.length)))));
+    const parts = shownHits.map((hit) => {
+        const snippet = makeSnippet(hit.field.text, hit.index, perHitContext, hit.end);
+        return `${hit.field.path}: ${snippet}`;
+    });
+    if (hits.length > shownHits.length) {
+        parts.push(`... +${hits.length - shownHits.length} more terms`);
+    }
+    return parts.join(" | ");
+}
 //# sourceMappingURL=corpus-jobs.js.map