@abot-ai/runtime 1.1.0 → 1.3.0

package/README.md

@@ -13,6 +13,7 @@ hardcoded defaults.
 - Configurable local and hosted model providers
 - Persistent conversations, request events, and replay
 - Optional passive long-term memory across sessions
+- Local scheduled requests bound to their conversations
 - Planning, execution, and review workflows
 - Manifest-based tools and plugins with explicit runtime boundaries
 - Workspace, file, skill, and memory capabilities
@@ -34,11 +35,24 @@ The Web UI supports:
 - steering an active request or queuing the next message
 - editing runtime configuration
 - configuring passive long-term memory with a consumer-selected embedding model
+- managing schedules, their saved models, and run history in the Schedules workspace
 - inspecting runtime status, logs, and health
 
 The UI is a client of the runtime; persisted sessions, events, and request state
 remain owned by the runtime.
 
+Schedules can also be managed through the model's built-in `schedules` capability.
+Every Job belongs to a conversation and runs there with its saved model and FULL
+tool permissions. The chat shows a compact run card; expand it to read the exact
+historical prompt. ABot must be running at the scheduled time. Missed offline
+occurrences and failed runs are not retried. Cancelling a Job or deleting its
+conversation prevents pending starts; an already-started run continues.
+
+Timers, one-time requests, intervals, and daily/weekly/monthly schedules are
+supported. Calendar schedules require an exact time and IANA time zone. Jobs and
+run history are stored locally under the environment's runtime directory.
+Scheduling uses the Runtime directly and requires no plugin or external bridge.
+
 ## Requirements
 
 - Node.js `^20.19.0` or `>=22.12.0` (Node.js 21 is not supported)
@@ -219,9 +233,12 @@ from core-owned passive long-term memory.
 The Web plugin exposes two distinct capabilities:
 
 - `web_fetch` retrieves a specific public HTTP(S) page without a search API key.
-- `web_search` uses the Brave Search API and requires
-  `BRAVE_SEARCH_API_KEY`. Without it, the capability returns a clear local
-  configuration error before making a search request.
+- `web_search` uses Brave Search when `BRAVE_SEARCH_API_KEY` is configured.
+  Without a key, it uses Light search: bounded discovery and ranking within a
+  catalog of public Hebrew and English sources, without an external search
+  engine. Light has limited coverage; an empty result does not mean the
+  information is absent from the web. A configured Brave key that fails does
+  not trigger an automatic switch to Light.
 
 Some plugins have platform-specific requirements. See [Plugins](docs/plugins.md)
 for their contracts, limits, and configuration.

package/dist/src/bridge/request-steering.d.ts

@@ -1,8 +1,9 @@
 import type WebSocket from "ws";
+import type { RuntimeRequestHandler } from "../runtime/composition.js";
 import { type RequestSteeringInbox } from "../runtime/request/request-steering.js";
 export type BridgeRequestSteeringRegistry = Readonly<{
     close(requestId: string, inbox: RequestSteeringInbox): Promise<void>;
     handleMessage(ws: WebSocket, message: Record<string, unknown>): Promise<boolean>;
     open(requestId: string): RequestSteeringInbox;
 }>;
-export declare function createBridgeRequestSteeringRegistry(): BridgeRequestSteeringRegistry;
+export declare function createBridgeRequestSteeringRegistry(steer?: RuntimeRequestHandler["steer"]): BridgeRequestSteeringRegistry;

package/dist/src/bridge/request-steering.js

@@ -1,7 +1,7 @@
 import { traceDebug } from "../runtime/observability/debug-logger.js";
 import { createRequestSteeringInbox, } from "../runtime/request/request-steering.js";
 const LOG_SCOPE = "agent-bridge.request_steering";
-export function createBridgeRequestSteeringRegistry() {
+export function createBridgeRequestSteeringRegistry(steer) {
     const active = new Map();
     return Object.freeze({
         async close(requestId, inbox) {
@@ -23,7 +23,9 @@ export function createBridgeRequestSteeringRegistry() {
             const steerId = readString(message.steerId).trim();
             const text = readString(message.text).trim();
             const current = active.get(requestId);
-            const result = current?.inbox.append({ steerId, text }) ??
+            const result = (steer && current
+                ? await steer(requestId, { steerId, text })
+                : current?.inbox.append({ steerId, text })) ??
                 Object.freeze({
                     ok: false,
                     reason: "request_not_active",

package/dist/src/bridge/runtime-replay.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { clearSessionMessages, deleteMessageWithStats, deleteSessionWithStats, getRequestReplayById, getSessionSnapshot, listSessions, } from "../sessions/index.js";
 import { DEFAULT_MAX_ATTACHMENT_BYTES, } from "../runtime/attachments/store.js";
+import { deleteSessionWithAttachments, deleteSessionAttachmentsIfSupported, } from "../runtime/session/session-attachment-deletion.js";
 import { resolveRuntimeAttachmentMimeType } from "../shared/attachments.js";
 const defaultRuntimeReplaySessionStore = {
     clearSessionMessages,
@@ -344,10 +345,7 @@ async function handleSessionDeleteRequest(ws, msg, sessionStore, attachmentStore
         return;
     }
     try {
-        const result = await sessionStore.deleteSessionWithStats(sessionId);
-        if (result.deleted) {
-            await deleteSessionAttachmentsIfSupported(attachmentStore, sessionId);
-        }
+        const result = await deleteSessionWithAttachments(sessionStore, attachmentStore, sessionId);
         sendRuntimeReplayResponse(ws, {
             type: "session.delete.response",
             correlationId,
@@ -402,21 +400,6 @@ async function handleSessionMessagesClearRequest(ws, msg, sessionStore, attachme
         }, error instanceof Error ? error.message : String(error));
     }
 }
-async function deleteSessionAttachmentsIfSupported(attachmentStore, sessionId) {
-    if (!attachmentStore) {
-        return;
-    }
-    try {
-        await attachmentStore.deleteSessionAttachments(sessionId);
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message === "attachment_owner_invalid") {
-            return;
-        }
-        throw error;
-    }
-}
 async function deleteAttachmentIfSupported(attachmentStore, attachment, sessionId) {
     if (!attachmentStore?.deleteAttachment) {
         return;

package/dist/src/bridge/start-agent-bridge.js

@@ -109,7 +109,7 @@ export function startAgentBridge(options = {}) {
     let lastMessageAt;
     let lastPongAt;
     const pendingToolApprovals = new Map();
-    const requestSteering = createBridgeRequestSteeringRegistry();
+    const requestSteering = createBridgeRequestSteeringRegistry(requestHandler.steer);
     function getStatus() {
         return {
             runtimeId,

package/dist/src/capabilities/normal-invocation/validator.js

@@ -1,5 +1,5 @@
 import { TOOL_NORMAL_INVOCATION_IDENTIFIER_MAX_LENGTH, TOOL_NORMAL_INVOCATION_PAYLOAD_MAX_BYTES, TOOL_NORMAL_INVOCATION_VERSION, } from "./contracts.js";
-const MAX_OPERATIONS = 16;
+const MAX_OPERATIONS = 32;
 const MAX_SUMMARY_LENGTH = 512;
 const MAX_INSTRUCTIONS_LENGTH = 1_024;
 const MAX_PROPERTIES = 16;

package/dist/src/capabilities/tool-definition-validator/event-presentation.js

@@ -1,4 +1,5 @@
 import { isToolDefinitionRecordValue } from "./definition-shape.js";
+import { parseEventResultMetadata } from "./event-result-metadata.js";
 const EVENT_PROJECTION_KINDS = [
     "string",
     "number",
@@ -16,8 +17,10 @@ export function parseEventPresentation(toolName, raw) {
     }
     const metadata = Object.fromEntries(Object.entries(raw.metadata).map(([key, projection]) => parseEventMetadataProjection(toolName, key, projection)));
     const lifecycle = parseEventLifecycle(toolName, raw.lifecycle);
+    const resultMetadata = parseEventResultMetadata(raw.resultMetadata, `eventPresentation.resultMetadata (${toolName})`);
     return {
         metadata,
+        ...(resultMetadata ? { resultMetadata } : {}),
         ...(lifecycle ? { lifecycle } : {}),
     };
 }

package/dist/src/capabilities/tool-definition-validator/event-result-metadata.d.ts

@@ -0,0 +1,2 @@
+import type { ToolEventPresentation } from "../tool-types.js";
+export declare function parseEventResultMetadata(raw: unknown, path: string): ToolEventPresentation["resultMetadata"];

package/dist/src/capabilities/tool-definition-validator/event-result-metadata.js

@@ -0,0 +1,74 @@
+import { isToolDefinitionRecordValue } from "./definition-shape.js";
+const RESULT_METADATA_LIMIT = 16;
+const RESULT_PATH_SEGMENT_LIMIT = 4;
+const RESULT_PROJECTION_KINDS = ["preview", "number", "boolean"];
+const FORBIDDEN_PATH_SEGMENTS = new Set([
+    "__proto__",
+    "prototype",
+    "constructor",
+]);
+export function parseEventResultMetadata(raw, path) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw new Error(`${path} must be an object`);
+    }
+    const entries = Object.entries(raw);
+    if (entries.length > RESULT_METADATA_LIMIT) {
+        throw new Error(`${path} exceeds ${RESULT_METADATA_LIMIT} projections`);
+    }
+    const result = Object.fromEntries(entries.map(([key, value]) => {
+        if (!hasSupportedResultMetadataKey(key)) {
+            throw new Error(`${path} contains an invalid metadata key`);
+        }
+        if (!isToolDefinitionRecordValue(value)) {
+            throw new Error(`${path}.${key} must be an object`);
+        }
+        if (hasUnknownResultProjectionFields(value)) {
+            throw new Error(`${path}.${key} contains an unknown field`);
+        }
+        if (!hasSupportedResultMetadataPath(value.path)) {
+            throw new Error(`${path}.${key}.path must select output or data`);
+        }
+        if (!isResultProjectionKind(value.kind)) {
+            throw new Error(`${path}.${key}.kind is not supported`);
+        }
+        return [key, { path: value.path, kind: value.kind }];
+    }));
+    for (const [key, projection] of Object.entries(result)) {
+        if (projection.kind !== "preview")
+            continue;
+        if (Object.hasOwn(result, `${key}Truncated`)) {
+            throw new Error(`${path}.${key} conflicts with its truncation metadata`);
+        }
+    }
+    return result;
+}
+function hasSupportedResultMetadataKey(key) {
+    if (!/^[a-zA-Z][a-zA-Z0-9]{0,63}$/u.test(key))
+        return false;
+    return !FORBIDDEN_PATH_SEGMENTS.has(key);
+}
+function hasSupportedResultMetadataPath(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value === "output")
+        return true;
+    const segments = value.split(".");
+    if (segments[0] !== "data")
+        return false;
+    if (segments.length < 2 || segments.length > RESULT_PATH_SEGMENT_LIMIT)
+        return false;
+    return segments.every(isSupportedResultPathSegment);
+}
+function hasUnknownResultProjectionFields(value) {
+    return Object.keys(value).some((field) => field !== "path" && field !== "kind");
+}
+function isSupportedResultPathSegment(segment) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/u.test(segment))
+        return false;
+    return !FORBIDDEN_PATH_SEGMENTS.has(segment);
+}
+function isResultProjectionKind(value) {
+    return RESULT_PROJECTION_KINDS.includes(value);
+}

package/dist/src/capabilities/tool-event-metadata.js

@@ -1,3 +1,4 @@
+import { projectToolResultEventMetadata } from "./tool-result-event-projection.js";
 function safeTrim(value) {
     return typeof value === "string" ? value.trim() : "";
 }
@@ -177,5 +178,7 @@ export function buildToolCompletedEventMetadata(call, result, definition) {
         ...(buildCallMeta(call, definition) || {}),
         ...toolResultData,
         ...(buildResultMeta(result, actions) || {}),
+        // Explicit result mappings override generic display fallbacks when present.
+        ...projectToolResultEventMetadata(result, definition?.eventPresentation?.resultMetadata),
     });
 }

package/dist/src/capabilities/tool-result-event-projection.d.ts

@@ -0,0 +1,3 @@
+import type { ToolEventMetadata, ToolEventPresentation, ToolExecutionResult } from "./tool-types.js";
+/** Derive display metadata without changing canonical tool evidence. */
+export declare function projectToolResultEventMetadata(result: ToolExecutionResult, projections: ToolEventPresentation["resultMetadata"]): ToolEventMetadata | undefined;

package/dist/src/capabilities/tool-result-event-projection.js

@@ -0,0 +1,82 @@
+const PREVIEW_CHARACTER_LIMIT = 1_200;
+const PREVIEW_LINE_LIMIT = 20;
+const EVENT_PREVIEW_CHARACTER_LIMIT = 2_400;
+/** Derive display metadata without changing canonical tool evidence. */
+export function projectToolResultEventMetadata(result, projections) {
+    if (!projections)
+        return undefined;
+    const metadata = {};
+    let remainingCharacters = EVENT_PREVIEW_CHARACTER_LIMIT;
+    for (const [key, projection] of Object.entries(projections)) {
+        const value = readProjectedResultValue(result, projection);
+        if (value === undefined)
+            continue;
+        if (typeof value !== "string") {
+            metadata[key] = value;
+            continue;
+        }
+        const preview = boundResultPreview(value, remainingCharacters);
+        metadata[key] = preview.text;
+        metadata[`${key}Truncated`] = preview.truncated;
+        remainingCharacters -= preview.text.length;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+function readProjectedResultValue(result, projection) {
+    const value = readOwnResultPath(result, projection.path);
+    if (projection.kind === "number") {
+        return isFiniteResultNumber(value) ? value : undefined;
+    }
+    if (projection.kind === "boolean") {
+        return typeof value === "boolean" ? value : undefined;
+    }
+    return typeof value === "string" ? value : undefined;
+}
+function readOwnResultPath(result, path) {
+    let value = result;
+    for (const segment of path.split(".")) {
+        if (!isOwnResultContainer(value, segment))
+            return undefined;
+        value = value[segment];
+    }
+    return value;
+}
+function isOwnResultContainer(value, key) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return false;
+    return Object.hasOwn(value, key);
+}
+function isFiniteResultNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function boundResultPreview(value, remainingCharacters) {
+    const characterLimit = Math.min(PREVIEW_CHARACTER_LIMIT, remainingCharacters);
+    let end = Math.min(value.length, characterLimit);
+    let lineCount = 1;
+    for (let index = 0; index < end; index += 1) {
+        if (!startsPreviewLine(value, index))
+            continue;
+        lineCount += 1;
+        if (lineCount <= PREVIEW_LINE_LIMIT)
+            continue;
+        end = index;
+        break;
+    }
+    if (splitsSurrogatePair(value, end))
+        end -= 1;
+    return { text: value.slice(0, end), truncated: end < value.length };
+}
+function startsPreviewLine(value, index) {
+    if (value[index] === "\r")
+        return true;
+    return value[index] === "\n" && value[index - 1] !== "\r";
+}
+function splitsSurrogatePair(value, end) {
+    if (end <= 0 || end >= value.length)
+        return false;
+    const before = value.charCodeAt(end - 1);
+    const after = value.charCodeAt(end);
+    return (before >= 0xd800 && before <= 0xdbff && after >= 0xdc00 && after <= 0xdfff);
+}

package/dist/src/capabilities/tool-types.d.ts

@@ -18,8 +18,13 @@ export type ToolEventLifecycleCopy = Readonly<{
     status: string;
     message: string;
 }>;
+export type ToolEventResultMetadataProjection = Readonly<{
+    path: string;
+    kind: "preview" | "number" | "boolean";
+}>;
 export type ToolEventPresentation = Readonly<{
     metadata: Readonly<Record<string, ToolEventMetadataProjection>>;
+    resultMetadata?: Readonly<Record<string, ToolEventResultMetadataProjection>>;
     lifecycle?: Readonly<{
         started?: ToolEventLifecycleCopy;
         completed?: ToolEventLifecycleCopy;
@@ -115,7 +120,7 @@ export type ToolRequestAttachment = Readonly<{
     name?: string;
     size?: number;
 }>;
-/** Minimal config-filtered tool fact projected to plugin execution only. */
+/** Minimal config-filtered tool fact; consumers project it for their own context. */
 export type ToolAvailabilityEntry = Readonly<{
     toolName: string;
     operationId: string;

package/dist/src/cli/abot.js

@@ -4,6 +4,7 @@ import { runInitRuntime } from "../../scripts/init-runtime.js";
 import { runConfigureLongTermMemory } from "../../scripts/configure-long-term-memory.js";
 import { createModelGatewayServer, resolveProviderAdapters, resolveModelGatewayPort, } from "../model-gateway/server.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
+import { closeHttpServerImmediately } from "../shared/http-server-shutdown.js";
 import { startWebUiServer } from "../web-ui/server.js";
 import { resolveWebUiAddress } from "../web-ui/web-ui-address.js";
 function printHelp() {
@@ -23,16 +24,6 @@ function printHelp() {
         "  start      Start the local model gateway and Web UI.",
     ].join("\n"));
 }
-function closeServer(server) {
-    return new Promise((resolveClose, reject) => {
-        server.close((error) => {
-            if (error)
-                reject(error);
-            else
-                resolveClose();
-        });
-    });
-}
 async function runStart(args) {
     if (args.includes("--help") || args.includes("-h")) {
         console.log("Usage: abot start");
@@ -75,7 +66,7 @@ async function runStart(args) {
             closing = true;
             void Promise.all([
                 webUi.close(),
-                ...(gateway ? [closeServer(gateway)] : []),
+                ...(gateway ? [closeHttpServerImmediately(gateway)] : []),
             ]).then(() => resolveExit(), rejectExit);
         };
         process.once("SIGINT", shutdown);

package/dist/src/model-gateway/providers/ollama/generation-options.d.ts

@@ -1,4 +1,4 @@
-import type { ModelGatewayFormat, ResolvedModelInvocation } from "../../types.js";
+import type { ResolvedModelInvocation } from "../../types.js";
 export declare function readOptionalPositiveIntEnv(name: string): number | undefined;
 export declare function buildOllamaOptions(params: {
     baseOptions: Record<string, unknown>;
@@ -13,8 +13,6 @@ export declare function buildOllamaOptions(params: {
 export declare function deriveOllamaNumPredict(params: {
     payload: Readonly<Record<string, unknown>>;
     invocation: ResolvedModelInvocation;
-    effectiveFormat?: ModelGatewayFormat;
-    useStructuredOutputCeiling: boolean;
     outputTokenLimit?: number;
 }): number;
 export declare function resolveOllamaKeepAlive(invocation: ResolvedModelInvocation): string;

package/dist/src/model-gateway/providers/ollama/generation-options.js

@@ -1,4 +1,3 @@
-import { estimateStrictStructuredOutputTokenCeiling } from "../../structured-output/budget.js";
 import { estimateProviderEnvelopeInputTokens } from "../envelope-budget.js";
 const DEFAULT_OLLAMA_KEEP_ALIVE = "3m";
 export function readOptionalPositiveIntEnv(name) {
@@ -38,10 +37,7 @@ export function buildOllamaOptions(params) {
 export function deriveOllamaNumPredict(params) {
     const estimatedInputTokens = estimateProviderEnvelopeInputTokens(params.payload, params.invocation.profile.context.tokenEstimation);
     const physicalRemainingTokens = Math.max(1, params.invocation.profile.contextWindowTokens - estimatedInputTokens);
-    const structuredOutputCeiling = params.useStructuredOutputCeiling
-        ? estimateStrictStructuredOutputTokenCeiling(params.effectiveFormat, params.invocation.profile.context.tokenEstimation)
-        : undefined;
-    return Math.max(1, Math.min(physicalRemainingTokens, structuredOutputCeiling ?? physicalRemainingTokens, params.outputTokenLimit ?? physicalRemainingTokens));
+    return Math.max(1, Math.min(physicalRemainingTokens, params.outputTokenLimit ?? physicalRemainingTokens));
 }
 export function resolveOllamaKeepAlive(invocation) {
     const configured = invocation.profile.providerConfig?.keepAlive?.trim();

package/dist/src/model-gateway/providers/ollama/payload.js

@@ -28,10 +28,6 @@ function applyGenerationOptions(params) {
         derivedNumPredict: deriveOllamaNumPredict({
             payload: params.payload,
             invocation: params.invocation,
-            ...(params.effectiveFormat
-                ? { effectiveFormat: params.effectiveFormat }
-                : {}),
-            useStructuredOutputCeiling: params.useStructuredOutputCeiling,
             ...(params.outputTokenLimit !== undefined
                 ? { outputTokenLimit: params.outputTokenLimit }
                 : {}),
@@ -71,8 +67,6 @@ export function buildOllamaPayload(requestBody, payloadOptions = {}) {
     applyGenerationOptions({
         payload,
         invocation,
-        ...(effectiveFormat ? { effectiveFormat } : {}),
-        useStructuredOutputCeiling: !invocation.profile.supportsThinking || invocation.think === "none",
         ...(outputTokenLimit !== undefined ? { outputTokenLimit } : {}),
     });
     return payload;
@@ -103,8 +97,6 @@ export function buildOllamaRawPayload(requestBody, payloadOptions = {}) {
     applyGenerationOptions({
         payload,
         invocation,
-        ...(effectiveFormat ? { effectiveFormat } : {}),
-        useStructuredOutputCeiling: false,
         ...(outputTokenLimit !== undefined ? { outputTokenLimit } : {}),
     });
     return payload;

package/dist/src/model-gateway/server/request-body.js

@@ -1,4 +1,5 @@
 export async function readJsonBody(request) {
+    request.setEncoding("utf8");
     let raw = "";
     for await (const chunk of request) {
         raw += chunk;

package/dist/src/plugin-sdk/index.d.ts

@@ -4,4 +4,6 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./tool-availability-brief.js";
+export * from "./tool-availability-overview.js";
 export * from "../plugin-contract/index.js";

package/dist/src/plugin-sdk/index.js

@@ -4,4 +4,6 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./tool-availability-brief.js";
+export * from "./tool-availability-overview.js";
 export * from "../plugin-contract/index.js";

package/dist/src/plugin-sdk/tool-availability-brief.d.ts

@@ -0,0 +1,9 @@
+import type { ToolAvailabilityEntry } from "../plugin-contract/entrypoint.js";
+import { type BoundedCollectionMetadata, type BoundedTextMetadata } from "./bounds.js";
+export type ToolAvailabilityBrief = Readonly<{
+    text: string;
+    collection: BoundedCollectionMetadata;
+    output: BoundedTextMetadata;
+}>;
+/** Formats the existing bounded, on-demand tool brief without executing tools. */
+export declare function buildToolAvailabilityBrief(entries: readonly ToolAvailabilityEntry[]): ToolAvailabilityBrief;

package/dist/src/plugin-sdk/tool-availability-brief.js

@@ -0,0 +1,48 @@
+import { boundCollection, boundText, } from "./bounds.js";
+const TOOL_COUNT_MAX = 64;
+const OUTPUT_CHARACTER_MAX = 16_000;
+/** Formats the existing bounded, on-demand tool brief without executing tools. */
+export function buildToolAvailabilityBrief(entries) {
+    const orderedTools = [...entries].sort(compareAvailableTools);
+    const boundedTools = boundCollection(orderedTools, {
+        maxItems: TOOL_COUNT_MAX,
+    });
+    const rawOutput = [
+        `Available tool operations: ${entries.length}`,
+        ...boundedTools.items.map(formatAvailableTool),
+        ...(boundedTools.metadata.truncated
+            ? [
+                `[${boundedTools.metadata.omittedItems} additional tool operations omitted]`,
+            ]
+            : []),
+    ].join("\n");
+    const boundedOutput = boundText(rawOutput, {
+        maxChars: OUTPUT_CHARACTER_MAX,
+        marker: "\n[available tool brief truncated]",
+    });
+    return Object.freeze({
+        text: boundedOutput.text,
+        collection: boundedTools.metadata,
+        output: boundedOutput.metadata,
+    });
+}
+function formatAvailableTool(tool) {
+    return [
+        `- ${tool.operationId}`,
+        `(tool=${tool.toolName}; effect=${tool.effect}; groups=${tool.catalogGroups.join(",")})`,
+        tool.summary,
+    ].join(" ");
+}
+function compareAvailableTools(left, right) {
+    const byOperation = compareAscii(left.operationId, right.operationId);
+    if (byOperation !== 0)
+        return byOperation;
+    return compareAscii(left.toolName, right.toolName);
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/plugin-sdk/tool-availability-overview.d.ts

@@ -0,0 +1,9 @@
+import type { ToolAvailabilityEntry } from "../plugin-contract/entrypoint.js";
+export type ToolAvailabilityOverviewLevel = "detailed" | "titles" | "groups";
+export type ToolAvailabilityOverviewGroup = Readonly<{
+    groupId: string;
+    memberCount: number;
+    effects: readonly string[];
+}>;
+/** Complete informational candidates; callers own admission and context budget. */
+export declare function buildToolAvailabilityOverview(entries: readonly ToolAvailabilityEntry[], groups: readonly ToolAvailabilityOverviewGroup[], level: ToolAvailabilityOverviewLevel): string;

package/dist/src/plugin-sdk/tool-availability-overview.js

@@ -0,0 +1,62 @@
+/** Complete informational candidates; callers own admission and context budget. */
+export function buildToolAvailabilityOverview(entries, groups, level) {
+    if (level === "detailed")
+        return describeAvailableTools(entries);
+    const orderedGroups = [...groups].sort((left, right) => compareAscii(left.groupId, right.groupId));
+    if (level === "titles")
+        return describeGroupTools(entries, orderedGroups);
+    return orderedGroups.map(describeGroupMetadata).join("\n");
+}
+function describeAvailableTools(entries) {
+    const tools = new Map();
+    for (const entry of entries) {
+        const tool = tools.get(entry.toolName) ?? {
+            operationIds: new Set(),
+            catalogGroups: new Set(),
+        };
+        tool.operationIds.add(entry.operationId);
+        for (const groupId of entry.catalogGroups)
+            tool.catalogGroups.add(groupId);
+        tools.set(entry.toolName, tool);
+    }
+    return [...tools.entries()]
+        .sort(([left], [right]) => compareAscii(left, right))
+        .map(([toolName, tool]) => `- ${formatOverviewIdentifier(toolName)} — ${sortedValues(tool.operationIds)} [${sortedValues(tool.catalogGroups)}]`)
+        .join("\n");
+}
+function describeGroupTools(entries, groups) {
+    return groups
+        .map((group) => {
+        const toolNames = new Set(entries
+            .filter((entry) => entry.catalogGroups.includes(group.groupId))
+            .map((entry) => entry.toolName));
+        return `- ${group.groupId}: ${sortedValues(toolNames)}`;
+    })
+        .join("\n");
+}
+function describeGroupMetadata(group) {
+    return `- ${group.groupId} (memberCount=${group.memberCount}; effects=${sortedValues(group.effects)})`;
+}
+function sortedValues(values) {
+    return [...values]
+        .sort(compareAscii)
+        .map(formatOverviewIdentifier)
+        .join(", ");
+}
+function formatOverviewIdentifier(value) {
+    if (isPlainOverviewIdentifier(value))
+        return value;
+    return JSON.stringify(value)
+        .replace(/\u2028/gu, "\\u2028")
+        .replace(/\u2029/gu, "\\u2029");
+}
+function isPlainOverviewIdentifier(value) {
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(value);
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/runtime/adapters/in-memory-session-store.js

@@ -175,6 +175,7 @@ class InMemorySessionStore {
                 taskType: options.taskType,
                 requestId: options.requestId,
                 cronJobId: options.cronJobId,
+                ...(options.schedule ? { schedule: options.schedule } : {}),
                 cronTitle: options.cronTitle,
                 triggerType: options.triggerType,
                 attachments: options.attachments,