@nylorun/runtime 0.20.0-beta → 0.21.0-beta

package/dist/tenant/store-pg.js

@@ -55,6 +55,15 @@ export function createPostgresTenantOpener(options) {
                 from: opened.migrated.from,
                 to: opened.migrated.to,
             });
+        // Protocol 10 removed the vault's `oauth` credential type: the migration deleted them.
+        for (const removed of opened.removedCredentials)
+            logger?.warn("oauth_credential_removed", {
+                tenantId,
+                vaultId: removed.vaultId,
+                credentialId: removed.credentialId,
+                url: removed.url,
+                message: "MCP OAuth credentials are gone (protocol 10): store a key for this server in a vault, or reach it through a gateway",
+            });
         let reads;
         try {
             reads = createPostgresReadStore(options.sql, tenantId);

package/dist/tenant/tool-results.d.ts

@@ -0,0 +1,57 @@
+import type { HostEffect } from "@nylorun/harness/run";
+import type { TenantContext } from "./context.js";
+/** The most of one tool result that is recorded inline (Q22): 32 KiB, as JSON. */
+export declare const TOOL_RESULT_INLINE_BYTES: number;
+/** How much of a stored result's start, and of its end, the preview keeps. */
+export declare const PREVIEW_HEAD_BYTES: number;
+export declare const PREVIEW_TAIL_BYTES = 1024;
+/**
+ * The most one step's results may hold together: a step's results are one transcript entry, so
+ * one event, which must stay well under S2's 1 MiB record.
+ */
+export declare const STEP_RESULTS_BUDGET_BYTES: number;
+/** A result's cap once its step's budget is spent: a stub naming its artifact. */
+export declare const TOOL_RESULT_STUB_BYTES = 512;
+/** A result this small is never shaped, nor counted against its step's budget. */
+export declare const TOOL_RESULT_SMALL_BYTES = 1024;
+/** The call whose outcome is shaped, and the session its artifacts belong to. */
+export interface ShapedCall {
+    readonly request: HostEffect;
+    readonly session: {
+        readonly id: string;
+        readonly ownerUserId: string;
+    };
+    /** A remote MCP tool's: its output may be the server's content parts. */
+    readonly mcp: boolean;
+    /** This result's cap (`resultLimit`). Default `TOOL_RESULT_INLINE_BYTES`. */
+    readonly limit?: number;
+}
+/** A result's cap when the other results of its step already took `used` bytes. */
+export declare function resultLimit(used: number): number;
+/** The JSON size of `value` in bytes: what it adds to an event or a prompt. */
+export declare function jsonBytes(value: unknown): number;
+/**
+ * What a tool outcome's result weighs in its step's transcript entry: a completed one's output,
+ * a failed one's message; 0 for anything else, such as a model call's outcome.
+ */
+export declare function resultBytes(value: unknown): number;
+/**
+ * False for an outcome `shapeToolOutcome` returns as it is, whatever made it: a model call's, a
+ * small tool result with no parts. Spares a look at the effect for most outcomes.
+ */
+export declare function mayNeedShaping(value: unknown): boolean;
+/**
+ * The outcome `value` of `call`, shaped to fit its cap (see the module comment). An outcome that
+ * fits and has no binary part comes back as it is.
+ */
+export declare function shapeToolOutcome(ctx: TenantContext, call: ShapedCall, value: unknown, signal: AbortSignal): Promise<unknown>;
+/**
+ * The start and end of `text` in whole characters, `budget` bytes split four to one: by default
+ * the first `PREVIEW_HEAD_BYTES` and the last `PREVIEW_TAIL_BYTES`.
+ */
+export declare function previewOf(text: string, budget?: number): string;
+/**
+ * The nearest character boundary of the UTF-8 `bytes` at or before (`down`) or at or after
+ * (`up`) byte `at`: never inside a character.
+ */
+export declare function utf8Boundary(bytes: Uint8Array, at: number, direction: "down" | "up"): number;

package/dist/tenant/tool-results.js

@@ -0,0 +1,298 @@
+/**
+ * Tool results that fit (R2b C11, Q22–Q24): core shapes what an agent's remote MCP tool or HTTP
+ * tool returned before it records the outcome (`harness-api/record.ts`), so no journal row,
+ * event or prompt holds more of one result than the inline cap. The gate already refused an
+ * answer past 8 MiB (`mcp.too-large`, `http.too-large`).
+ *
+ * - An `image`, `audio` or blob `resource` part becomes a file artifact of the session, and the
+ *   part says `{artifactId, version, contentType, size}`. An image also goes to the model as a
+ *   file (`ToolOutcome.files`), which the model call shows to a model that reads images (Q23).
+ * - Text or JSON past `TOOL_RESULT_INLINE_BYTES` (32 KiB, Q22) becomes a file artifact, and the
+ *   model gets `{truncated: true, artifactId, size, preview}`: the first 4 KiB and the last 1 KiB.
+ *   In a result of several parts each part is shaped alone, the largest text first, until the
+ *   whole fits; one that still does not is stored whole.
+ * - A `resource_link` stays a link, never fetched, and a text resource that fits stays inline.
+ * - A failed outcome's message is cut to its start and end.
+ * - When an artifact cannot be stored (the Tenant's artifact limits, an Object store that
+ *   fails), the preview stays and `dropped` says why the rest is gone: a result never passes
+ *   the cap. Only an abort throws.
+ * - **One step's results share a budget** (`STEP_RESULTS_BUDGET_BYTES`, 256 KiB), since the
+ *   transcript keeps a step's results in one entry, one event: the record seam counts what the
+ *   step's other results took, under the session lock, and gives this one the rest as its cap
+ *   (`resultLimit`). Once the budget is spent, a result past `TOOL_RESULT_SMALL_BYTES` becomes a
+ *   stub naming its artifact, its preview cut to fit `TOOL_RESULT_STUB_BYTES`.
+ *
+ * The model reads a stored result with `read_artifact` (`artifact-tool.ts`). Artifacts are the
+ * session's, saved by our engine (`source: "engine"`), with the turn and the tool call on their
+ * `artifact.created` event.
+ */
+import { READ_ARTIFACT_MAX_BYTES } from "@nylorun/core/define";
+import { MODEL_FILE_MAX_BYTES, extensionFor, isModelImage, isText, normalizeContentType, } from "../artifacts/media-types.js";
+import { uploadArtifact } from "../artifacts/service.js";
+import { DEFAULT_CONTENT_TYPE } from "../blob/index.js";
+import { HttpError } from "./http.js";
+import { toolIds } from "./transcript.js";
+/** The most of one tool result that is recorded inline (Q22): 32 KiB, as JSON. */
+export const TOOL_RESULT_INLINE_BYTES = READ_ARTIFACT_MAX_BYTES;
+/** How much of a stored result's start, and of its end, the preview keeps. */
+export const PREVIEW_HEAD_BYTES = 4 * 1024;
+export const PREVIEW_TAIL_BYTES = 1024;
+/**
+ * The most one step's results may hold together: a step's results are one transcript entry, so
+ * one event, which must stay well under S2's 1 MiB record.
+ */
+export const STEP_RESULTS_BUDGET_BYTES = 256 * 1024;
+/** A result's cap once its step's budget is spent: a stub naming its artifact. */
+export const TOOL_RESULT_STUB_BYTES = 512;
+/** A result this small is never shaped, nor counted against its step's budget. */
+export const TOOL_RESULT_SMALL_BYTES = 1024;
+/** A result's cap when the other results of its step already took `used` bytes. */
+export function resultLimit(used) {
+    return Math.max(TOOL_RESULT_STUB_BYTES, Math.min(TOOL_RESULT_INLINE_BYTES, STEP_RESULTS_BUDGET_BYTES - used));
+}
+/** The JSON size of `value` in bytes: what it adds to an event or a prompt. */
+export function jsonBytes(value) {
+    return Buffer.byteLength(JSON.stringify(value) ?? "null");
+}
+/**
+ * What a tool outcome's result weighs in its step's transcript entry: a completed one's output,
+ * a failed one's message; 0 for anything else, such as a model call's outcome.
+ */
+export function resultBytes(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return 0;
+    const outcome = value;
+    if (outcome.kind === "failed")
+        return typeof outcome.message === "string" ? Buffer.byteLength(outcome.message) : 0;
+    if (outcome.kind !== "completed" || outcome.output === undefined)
+        return 0;
+    return jsonBytes(outcome.output);
+}
+/**
+ * False for an outcome `shapeToolOutcome` returns as it is, whatever made it: a model call's, a
+ * small tool result with no parts. Spares a look at the effect for most outcomes.
+ */
+export function mayNeedShaping(value) {
+    const output = value?.output;
+    if (value?.kind === "completed" && Array.isArray(output))
+        return true;
+    return resultBytes(value) > TOOL_RESULT_SMALL_BYTES;
+}
+/**
+ * The outcome `value` of `call`, shaped to fit its cap (see the module comment). An outcome that
+ * fits and has no binary part comes back as it is.
+ */
+export async function shapeToolOutcome(ctx, call, value, signal) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const outcome = value;
+    const limit = call.limit ?? TOOL_RESULT_INLINE_BYTES;
+    if (outcome.kind === "failed" && typeof outcome.message === "string")
+        return Buffer.byteLength(outcome.message) > limit
+            ? { ...outcome, message: cutMessage(outcome.message, limit) }
+            : value;
+    if (outcome.kind !== "completed" || outcome.output === undefined)
+        return value;
+    const shaping = { ...call, limit, ctx, signal, files: [] };
+    let output = outcome.output;
+    if (call.mcp && isContentParts(output))
+        output = await shapeParts(shaping, output);
+    let truncated = false;
+    if (jsonBytes(output) > limit) {
+        output = await storedWhole(shaping, output);
+        truncated = true;
+    }
+    if (output === outcome.output)
+        return value;
+    return {
+        ...outcome,
+        output,
+        ...(shaping.files.length > 0 ? { files: shaping.files } : {}),
+        ...(truncated ? { truncated: true } : {}),
+    };
+}
+/** True for an MCP `content` array: objects with a `type` each. */
+function isContentParts(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((part) => !!part &&
+            typeof part === "object" &&
+            !Array.isArray(part) &&
+            typeof part.type === "string"));
+}
+/** An MCP result's parts: binary ones stored, then the largest text ones until the whole fits. */
+async function shapeParts(shaping, parts) {
+    const shaped = [];
+    for (const [index, part] of parts.entries())
+        shaped.push(await shapeBinary(shaping, part, index));
+    const texts = shaped
+        .map((part, index) => ({ index, bytes: textOf(part) === undefined ? 0 : jsonBytes(part) }))
+        .filter((item) => item.bytes > 0)
+        .sort((a, b) => b.bytes - a.bytes);
+    for (const { index } of texts) {
+        if (jsonBytes(shaped) <= shaping.limit)
+            break;
+        const part = shaped[index];
+        const text = textOf(part);
+        const resource = part.type === "resource" ? part.resource : undefined;
+        const contentType = resource ? textType(resource.mimeType) : "text/plain; charset=utf-8";
+        const kept = await store(shaping, text, contentType, nameOf(shaping, contentType, index));
+        shaped[index] = withPreview({
+            type: part.type,
+            ...(resource && typeof resource.uri === "string" ? { uri: resource.uri } : {}),
+            truncated: true,
+            ...kept,
+        }, text, shaping.limit);
+    }
+    return shaped;
+}
+/** An `image`, `audio` or blob `resource` part, stored; any other part as it is. */
+async function shapeBinary(shaping, part, index) {
+    const resource = part.type === "resource" && part.resource && typeof part.resource === "object"
+        ? part.resource
+        : undefined;
+    const data = part.type === "image" || part.type === "audio"
+        ? part.data
+        : resource !== undefined
+            ? resource.blob
+            : undefined;
+    if (typeof data !== "string")
+        return part;
+    const declared = resource ? resource.mimeType : part.mimeType;
+    const contentType = (typeof declared === "string" ? normalizeContentType(declared) : undefined) ??
+        DEFAULT_CONTENT_TYPE;
+    const name = nameOf(shaping, contentType, index);
+    const kept = await store(shaping, Buffer.from(data, "base64"), contentType, name);
+    // An image the model reads goes to it as a file, beside the part (Q23).
+    if (part.type === "image" &&
+        "artifactId" in kept &&
+        isModelImage(contentType) &&
+        kept.size <= MODEL_FILE_MAX_BYTES)
+        shaping.files.push({
+            mediaType: contentType,
+            reference: { artifactId: kept.artifactId, version: kept.version, name },
+        });
+    return {
+        type: part.type,
+        ...(resource && typeof resource.uri === "string" ? { uri: resource.uri } : {}),
+        ...("artifactId" in kept ? kept : { contentType, ...kept }),
+    };
+}
+/** The text a part carries inline: a text part's, or a text resource's. */
+function textOf(part) {
+    if (part.type === "text" && typeof part.text === "string")
+        return part.text;
+    if (part.type === "resource" && part.resource && typeof part.resource === "object") {
+        const text = part.resource.text;
+        if (typeof text === "string")
+            return text;
+    }
+    return undefined;
+}
+function textType(declared) {
+    const type = typeof declared === "string" ? normalizeContentType(declared) : undefined;
+    return type !== undefined && isText(type) ? type : "text/plain; charset=utf-8";
+}
+/** `value` stored whole, as text or JSON, and the preview the model gets. */
+async function storedWhole(shaping, value) {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    const contentType = typeof value === "string" ? "text/plain; charset=utf-8" : "application/json";
+    const kept = await store(shaping, text, contentType, nameOf(shaping, contentType));
+    return withPreview({ truncated: true, ...kept }, text, shaping.limit);
+}
+/**
+ * `stub` with the preview of `text`: the first 4 KiB and the last 1 KiB, or less, so that the
+ * whole fits `limit` (a step's budget spent, R2b C11); none when even a little does not.
+ */
+function withPreview(stub, text, limit) {
+    let budget = Math.min(PREVIEW_HEAD_BYTES + PREVIEW_TAIL_BYTES, limit);
+    for (;;) {
+        const shaped = { ...stub, preview: previewOf(text, budget) };
+        const over = jsonBytes(shaped) - limit;
+        if (over <= 0 || budget === 0)
+            return shaped;
+        budget = budget - over < 64 ? 0 : budget - over;
+    }
+}
+/** Stores `body` as an artifact of the call's session, or says why it was not. */
+async function store(shaping, body, contentType, name) {
+    const bytes = typeof body === "string" ? Buffer.from(body, "utf8") : body;
+    const { ctx, request, session, signal } = shaping;
+    const ids = toolIds(request.context);
+    try {
+        const saved = await uploadArtifact(ctx, {
+            name,
+            contentType,
+            sessionId: session.id,
+            source: "engine",
+            turnId: request.turnId,
+            ...("callId" in ids ? { callId: ids.callId } : {}),
+        }, bytes, 
+        // Into the call's own session only.
+        { owner: session.ownerUserId }, signal);
+        return {
+            artifactId: saved.artifact.artifactId,
+            version: saved.version.version,
+            contentType: saved.version.contentType,
+            size: saved.version.size,
+        };
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw error;
+        // A limit is the Tenant's to raise; any other failure is the store's. Never the bytes.
+        ctx.config.logger.warn("tool_result_not_stored", {
+            session: session.id,
+            effect: request.effectId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return {
+            dropped: error instanceof HttpError
+                ? `The result could not be stored as an artifact: ${error.message}`
+                : "The result could not be stored as an artifact",
+            size: bytes.byteLength,
+        };
+    }
+}
+/** A name for a stored result: the tool's, with the part's number and the type's extension. */
+function nameOf(shaping, contentType, index) {
+    const tool = (shaping.request.toolName ?? "tool").replace(/[^A-Za-z0-9_.-]/gu, "_");
+    const extension = extensionFor(contentType) ?? "bin";
+    return `${tool.slice(0, 200)}-result${index === undefined ? "" : `-${index + 1}`}.${extension}`;
+}
+/**
+ * The start and end of `text` in whole characters, `budget` bytes split four to one: by default
+ * the first `PREVIEW_HEAD_BYTES` and the last `PREVIEW_TAIL_BYTES`.
+ */
+export function previewOf(text, budget = PREVIEW_HEAD_BYTES + PREVIEW_TAIL_BYTES) {
+    const bytes = Buffer.from(text, "utf8");
+    if (bytes.byteLength <= budget)
+        return text;
+    if (budget <= 0)
+        return "";
+    const tailBytes = Math.floor(budget / 5);
+    const head = utf8Boundary(bytes, budget - tailBytes, "down");
+    const tail = utf8Boundary(bytes, bytes.byteLength - tailBytes, "up");
+    return `${bytes.subarray(0, head).toString("utf8")}\n…\n${bytes.subarray(tail).toString("utf8")}`;
+}
+/** A message past `limit`: its start and end, and how long it was. */
+function cutMessage(message, limit) {
+    const note = `\n(The message was ${Buffer.byteLength(message)} bytes; its middle is not shown.)`;
+    const budget = Math.min(PREVIEW_HEAD_BYTES + PREVIEW_TAIL_BYTES, limit - note.length - 16);
+    return `${previewOf(message, Math.max(0, budget))}${note}`;
+}
+/**
+ * The nearest character boundary of the UTF-8 `bytes` at or before (`down`) or at or after
+ * (`up`) byte `at`: never inside a character.
+ */
+export function utf8Boundary(bytes, at, direction) {
+    let position = Math.max(0, Math.min(at, bytes.byteLength));
+    const inside = (index) => index < bytes.byteLength && (bytes[index] & 0xc0) === 0x80;
+    if (direction === "down")
+        while (position > 0 && inside(position))
+            position -= 1;
+    else
+        while (inside(position))
+            position += 1;
+    return position;
+}

package/dist/tenant/tool-search.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `tool_search` (R2b C10, Q20): core finds an agent's deferred MCP tools in the session's pinned
+ * snapshot, ranked with BM25 over their names and descriptions, and returns each match's name,
+ * description and `inputSchema`, for the model to run with `tool_call`. It reads only the pinned
+ * snapshot, so the same query finds the same tools for the session's life; a tool the turn's
+ * manifest disables is never found.
+ */
+import { type AgentManifest } from "@nylorun/core/define";
+import type { HostEffect } from "@nylorun/harness/run";
+import { type McpToolRecord } from "../mcp/snapshot.js";
+import { type TenantContext } from "./context.js";
+/** True when `request` calls `tool_search` of the `nylorun.tools` capability `manifest` has. */
+export declare function isToolSearchCall(manifest: AgentManifest | undefined, request: HostEffect): boolean;
+/** Runs `tool_search` for the run's agent. */
+export declare function callToolSearch(ctx: TenantContext, request: HostEffect): Promise<{
+    output?: undefined;
+    kind: string;
+    code: string;
+    message: string;
+} | {
+    code?: undefined;
+    message?: undefined;
+    kind: string;
+    output: {
+        tools: {
+            name: string;
+            description?: string | undefined;
+            inputSchema: import("@nylorun/core/define").JsonObject;
+        }[];
+        message?: string | undefined;
+    };
+}>;
+/**
+ * Lower-case words of `text`: `camelCase`, `snake_case` and `kebab-case` split into words, and a
+ * plural `s` dropped (`issues` finds `issue`).
+ */
+export declare function tokens(text: string): string[];
+/**
+ * The tools that match `query`, best first, by BM25 over each tool's name (counted twice, with
+ * the server's own name for it) and description. A tool no word of the query is in is left out;
+ * ties keep the snapshot's order.
+ */
+export declare function rank(tools: readonly McpToolRecord[], query: string): McpToolRecord[];

package/dist/tenant/tool-search.js

@@ -0,0 +1,100 @@
+/**
+ * `tool_search` (R2b C10, Q20): core finds an agent's deferred MCP tools in the session's pinned
+ * snapshot, ranked with BM25 over their names and descriptions, and returns each match's name,
+ * description and `inputSchema`, for the model to run with `tool_call`. It reads only the pinned
+ * snapshot, so the same query finds the same tools for the session's life; a tool the turn's
+ * manifest disables is never found.
+ */
+import { TOOL_SEARCH_DEFAULT_LIMIT, TOOL_SEARCH_MAX_LIMIT, TOOL_SEARCH_TOOL, TOOLS_CAPABILITY_ID, } from "@nylorun/core/define";
+import { isEnabledIn } from "../mcp/snapshot.js";
+import { sessionOf } from "./context.js";
+import { turnManifestOf } from "./session.js";
+/** BM25's term saturation and length normalization, the usual values. */
+const K1 = 1.2;
+const B = 0.75;
+/** True when `request` calls `tool_search` of the `nylorun.tools` capability `manifest` has. */
+export function isToolSearchCall(manifest, request) {
+    return (request.kind === "tool" &&
+        request.capabilityId === TOOLS_CAPABILITY_ID &&
+        request.toolName === TOOL_SEARCH_TOOL &&
+        manifest?.capabilities.some((capability) => capability.id === TOOLS_CAPABILITY_ID) === true);
+}
+/** Runs `tool_search` for the run's agent. */
+export async function callToolSearch(ctx, request) {
+    const input = (request.input ?? {});
+    const query = typeof input.query === "string" ? input.query : "";
+    const limit = typeof input.limit === "number" && Number.isSafeInteger(input.limit)
+        ? Math.min(Math.max(input.limit, 1), TOOL_SEARCH_MAX_LIMIT)
+        : TOOL_SEARCH_DEFAULT_LIMIT;
+    if (query.trim() === "")
+        return { kind: "failed", code: "tools.invalid_input", message: "Give a query: words of what the tool does." };
+    const session = await ctx.store.tx((t) => sessionOf(t, request.sessionId));
+    const manifest = turnManifestOf(session);
+    const deferred = (session.mcpSnapshot?.mcpTools ?? []).filter((tool) => tool.deferred === true &&
+        tool.agentId === request.agent?.id &&
+        // Enabled in the turn's manifest, which a variant may have tightened (R2b C9).
+        isEnabledIn(manifest, tool));
+    const found = rank(deferred, query).slice(0, limit);
+    return {
+        kind: "completed",
+        output: {
+            tools: found.map((tool) => ({
+                name: tool.name,
+                ...(tool.description === undefined ? {} : { description: tool.description }),
+                inputSchema: tool.inputSchema,
+            })),
+            ...(found.length === 0
+                ? { message: `No tool matches '${query}'. Try other words; ${deferred.length} tools are searchable.` }
+                : {}),
+        },
+    };
+}
+/**
+ * Lower-case words of `text`: `camelCase`, `snake_case` and `kebab-case` split into words, and a
+ * plural `s` dropped (`issues` finds `issue`).
+ */
+export function tokens(text) {
+    return text
+        .replace(/([a-z0-9])([A-Z])/gu, "$1 $2")
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter((word) => word.length > 0)
+        .map((word) => (word.length > 3 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word));
+}
+/**
+ * The tools that match `query`, best first, by BM25 over each tool's name (counted twice, with
+ * the server's own name for it) and description. A tool no word of the query is in is left out;
+ * ties keep the snapshot's order.
+ */
+export function rank(tools, query) {
+    const words = [...new Set(tokens(query))];
+    if (words.length === 0 || tools.length === 0)
+        return [];
+    const docs = tools.map((tool) => {
+        const name = [...tokens(tool.name), ...tokens(tool.serverToolName)];
+        const terms = [...name, ...name, ...tokens(tool.description ?? "")];
+        const counts = new Map();
+        for (const term of terms)
+            counts.set(term, (counts.get(term) ?? 0) + 1);
+        return { tool, counts, length: terms.length };
+    });
+    const average = docs.reduce((sum, doc) => sum + doc.length, 0) / docs.length || 1;
+    const idf = new Map(words.map((word) => {
+        const df = docs.filter((doc) => doc.counts.has(word)).length;
+        return [word, Math.log(1 + (docs.length - df + 0.5) / (df + 0.5))];
+    }));
+    return docs
+        .map((doc, order) => {
+        let score = 0;
+        for (const word of words) {
+            const tf = doc.counts.get(word) ?? 0;
+            if (tf === 0)
+                continue;
+            score += idf.get(word) * ((tf * (K1 + 1)) / (tf + K1 * (1 - B + (B * doc.length) / average)));
+        }
+        return { tool: doc.tool, score, order };
+    })
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score || a.order - b.order)
+        .map((item) => item.tool);
+}

package/dist/tenant/transcript.d.ts

@@ -81,8 +81,12 @@ export declare function toolCompleted(request: HostEffect, value: unknown): {
     error: {
         code: string;
         message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
     };
     output?: undefined;
+    redacted: number;
     capabilityId: string;
     toolName: string;
 } | {
@@ -90,20 +94,96 @@ export declare function toolCompleted(request: HostEffect, value: unknown): {
     error: {
         code: string;
         message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
     };
     output?: undefined;
+    redacted: number;
+    capabilityId: string;
+    toolName: string;
+} | {
+    agent: import("@nylorun/core/define").AgentRef;
+    error: {
+        code: string;
+        message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
+    };
+    output?: undefined;
+    redacted?: undefined;
+    capabilityId: string;
+    toolName: string;
+} | {
+    agent?: undefined;
+    error: {
+        code: string;
+        message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
+    };
+    output?: undefined;
+    redacted?: undefined;
     capabilityId: string;
     toolName: string;
 } | {
     agent: import("@nylorun/core/define").AgentRef;
     error?: undefined;
     output: unknown;
+    redacted: number;
     capabilityId: string;
     toolName: string;
 } | {
     agent?: undefined;
     error?: undefined;
     output: unknown;
+    redacted: number;
+    capabilityId: string;
+    toolName: string;
+} | {
+    agent: import("@nylorun/core/define").AgentRef;
+    error?: undefined;
+    output: unknown;
+    redacted?: undefined;
+    capabilityId: string;
+    toolName: string;
+} | {
+    agent?: undefined;
+    error?: undefined;
+    output: unknown;
+    redacted?: undefined;
+    capabilityId: string;
+    toolName: string;
+} | {
+    callId: string;
+    invocationId: string;
+    agent: import("@nylorun/core/define").AgentRef;
+    error: {
+        code: string;
+        message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
+    };
+    output?: undefined;
+    redacted: number;
+    capabilityId: string;
+    toolName: string;
+} | {
+    callId: string;
+    invocationId: string;
+    agent?: undefined;
+    error: {
+        code: string;
+        message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
+    };
+    output?: undefined;
+    redacted: number;
     capabilityId: string;
     toolName: string;
 } | {
@@ -113,8 +193,12 @@ export declare function toolCompleted(request: HostEffect, value: unknown): {
     error: {
         code: string;
         message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
     };
     output?: undefined;
+    redacted?: undefined;
     capabilityId: string;
     toolName: string;
 } | {
@@ -124,8 +208,30 @@ export declare function toolCompleted(request: HostEffect, value: unknown): {
     error: {
         code: string;
         message: string;
+        server?: string | undefined;
+        vault?: string | undefined;
+        retryable?: boolean | undefined;
     };
     output?: undefined;
+    redacted?: undefined;
+    capabilityId: string;
+    toolName: string;
+} | {
+    callId: string;
+    invocationId: string;
+    agent: import("@nylorun/core/define").AgentRef;
+    error?: undefined;
+    output: unknown;
+    redacted: number;
+    capabilityId: string;
+    toolName: string;
+} | {
+    callId: string;
+    invocationId: string;
+    agent?: undefined;
+    error?: undefined;
+    output: unknown;
+    redacted: number;
     capabilityId: string;
     toolName: string;
 } | {
@@ -134,6 +240,7 @@ export declare function toolCompleted(request: HostEffect, value: unknown): {
     agent: import("@nylorun/core/define").AgentRef;
     error?: undefined;
     output: unknown;
+    redacted?: undefined;
     capabilityId: string;
     toolName: string;
 } | {
@@ -142,6 +249,7 @@ export declare function toolCompleted(request: HostEffect, value: unknown): {
     agent?: undefined;
     error?: undefined;
     output: unknown;
+    redacted?: undefined;
     capabilityId: string;
     toolName: string;
 } | undefined;