@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-lifecycle.js

@@ -1,4 +1,4 @@
-import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-plan.js";
+import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-related-artifacts.js";
 import { normalizePayloadAuthoringResult } from "./payload-authoring-result.js";
 import { executionFreshnessRejection, payloadRejection, rejectPayloadLifecycle, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, } from "./payload-rejection.js";
 import { prepareStagedOperationPayload } from "./payload-stages.js";
@@ -11,6 +11,9 @@ export async function prepareOperationPayload(params) {
             sharedState: params.sharedState,
             ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
             call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             executionId: params.executionId,
             descriptor: params.descriptor,
             intent: params.intent,
@@ -55,10 +58,17 @@ export async function prepareOperationPayload(params) {
             targetParam: params.projection.payloadContextPlan?.targetParam,
             controls: params.controls,
             sharedState: params.sharedState,
+            call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             settledCapabilityResults: params.settledCapabilityResults,
         });
         rawAuthored = await params.payloadAuthor.author({
             call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             executionId: params.executionId,
             descriptor: params.descriptor,
             ...(params.authoringObjective

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-observability.js

@@ -11,8 +11,8 @@ export function createDeferredPayloadObservability(params) {
             const prepared = params.executor.preparePayloadLifecycle(input);
             if (prepared.status === "rejected")
                 return prepared;
-            deferred.push(() => {
-                prepared.emit();
+            deferred.push((executionId) => {
+                prepared.emit(executionId, params.call);
             });
             return Object.freeze({ status: "emitted" });
         },

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-stages.d.ts

@@ -11,6 +11,7 @@ export type StagedOperationPayloadParams = Readonly<{
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
+    assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;
     descriptor: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["descriptor"];
     intent: string;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-stages.js

@@ -1,4 +1,5 @@
-import { materializeRegisteredToolPayloadStageResponseFormat, resolveRegisteredToolPayloadRelatedArtifactContexts, resolveRegisteredToolPayloadStageLiteralOutput, resolveRegisteredToolPayloadStageMinBytes, resolveRegisteredToolPayloadTargetContext, validateRegisteredToolPayloadStageTargetLineBounds, } from "../registered-tool-payload-plan.js";
+import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-related-artifacts.js";
+import { materializeRegisteredToolPayloadStageResponseFormat, resolveRegisteredToolPayloadStageLiteralOutput, resolveRegisteredToolPayloadStageMinBytes, resolveRegisteredToolPayloadTargetContext, validateRegisteredToolPayloadStageTargetLineBounds, } from "../registered-tool-payload-plan.js";
 import { normalizePayloadAuthoringResult } from "./payload-authoring-result.js";
 import { executionFreshnessRejection, payloadRejection, rejectPayloadLifecycle, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, } from "./payload-rejection.js";
 export async function prepareStagedOperationPayload(params) {
@@ -172,10 +173,17 @@ class PayloadStageRunner {
                     targetParam: this.params.plan.targetParam,
                     controls: this.params.controls,
                     sharedState: this.params.sharedState,
+                    call: this.params.call,
+                    ...(this.params.assignmentProvenance
+                        ? { assignmentProvenance: this.params.assignmentProvenance }
+                        : {}),
                     settledCapabilityResults: this.params.settledCapabilityResults,
                 });
                 rawAuthored = await payloadAuthor.author({
                     call: this.params.call,
+                    ...(this.params.assignmentProvenance
+                        ? { assignmentProvenance: this.params.assignmentProvenance }
+                        : {}),
                     executionId: this.params.executionId,
                     descriptor: this.params.descriptor,
                     ...(this.params.authoringObjective

package/dist/src/runtime/adapters/scheduled-request-outcome.d.ts

@@ -0,0 +1,11 @@
+import type { SessionStore } from "../ports.js";
+import type { SchedulerRun, SchedulerRunOutcome } from "../scheduler/contracts.js";
+export type ScheduledRequestEvent = Record<string, unknown>;
+export type ScheduledRequestSettlement = Readonly<{
+    outcome: SchedulerRunOutcome;
+    event: ScheduledRequestEvent;
+}>;
+export declare function isScheduledTerminalEvent(event: ScheduledRequestEvent): boolean;
+export declare function failedScheduledRequestOutcome(error: unknown): ScheduledRequestSettlement;
+/** A captured completion is provisional until canonical assistant persistence is proven. */
+export declare function resolveScheduledRequestOutcome(terminal: ScheduledRequestEvent | undefined, sessions: SessionStore, run: SchedulerRun): Promise<ScheduledRequestSettlement>;

package/dist/src/runtime/adapters/scheduled-request-outcome.js

@@ -0,0 +1,41 @@
+export function isScheduledTerminalEvent(event) {
+    return event.type === "completed" || event.type === "failed";
+}
+export function failedScheduledRequestOutcome(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        outcome: { status: "failed", error: message },
+        event: { type: "failed", error: message },
+    };
+}
+/** A captured completion is provisional until canonical assistant persistence is proven. */
+export async function resolveScheduledRequestOutcome(terminal, sessions, run) {
+    if (!terminal)
+        return failedScheduledRequestOutcome("scheduled_request_missing_terminal");
+    if (terminal.type === "failed") {
+        const failure = failedScheduledRequestOutcome(terminal.error ?? "scheduled_request_failed");
+        return { ...failure, event: { ...terminal, ...failure.event } };
+    }
+    try {
+        const session = await sessions.getSessionById(run.sessionId);
+        const result = session?.messages.find((message) => isScheduledAssistantReply(message, run.requestId));
+        if (!result)
+            return failedScheduledRequestOutcome("scheduled_result_not_persisted");
+        return {
+            outcome: {
+                status: "succeeded",
+                resultText: String(terminal.output ?? ""),
+                resultMessageId: result.id,
+            },
+            event: terminal,
+        };
+    }
+    catch (error) {
+        return failedScheduledRequestOutcome(error);
+    }
+}
+function isScheduledAssistantReply(message, requestId) {
+    if (message.role !== "assistant")
+        return false;
+    return message.requestId === requestId;
+}

package/dist/src/runtime/adapters/scheduler-runtime.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeConfig, SessionStore } from "../ports.js";
+import type { RuntimeRequestHandler, RuntimeRequestOptions } from "../composition.js";
+import type { SchedulerRun } from "../scheduler/contracts.js";
+import type { SessionRequestAdmission } from "../request/session-admission.js";
+import { type ScheduledRequestEvent } from "./scheduled-request-outcome.js";
+export declare function createRuntimeScheduler(options: {
+    config: RuntimeConfig;
+    sessions: SessionStore;
+    admission: SessionRequestAdmission;
+    isDeleted(sessionId: string): boolean;
+    handle: RuntimeRequestHandler["handle"];
+    requestOptions?: (run: SchedulerRun) => RuntimeRequestOptions;
+}): {
+    scheduler: import("../scheduler/contracts.js").SchedulerService;
+    start: () => Promise<void>;
+    ensureStarted(): Promise<void>;
+    stop(): Promise<void>;
+    subscribe(listener: (event: ScheduledRequestEvent) => void): () => void;
+};

package/dist/src/runtime/adapters/scheduler-runtime.js

@@ -0,0 +1,138 @@
+import { join } from "node:path";
+import { createFileSchedulerStore } from "../scheduler/file-store.js";
+import { createSchedulerService } from "../scheduler/scheduler-service.js";
+import { withScheduledExecution } from "../request/scheduled-execution.js";
+import { resolveModelSelection } from "../model/model-selection.js";
+import { failedScheduledRequestOutcome, isScheduledTerminalEvent, resolveScheduledRequestOutcome, } from "./scheduled-request-outcome.js";
+export function createRuntimeScheduler(options) {
+    const listeners = new Set();
+    let startup;
+    let stopped = false;
+    let generation = 0;
+    function canPublishRunEvents(runGeneration) {
+        if (stopped)
+            return false;
+        return runGeneration === generation;
+    }
+    function publish(event, sessionId, runGeneration) {
+        if (!canPublishRunEvents(runGeneration))
+            return;
+        const isDeletedSession = options.isDeleted(sessionId);
+        const isTerminalEvent = isScheduledTerminalEvent(event);
+        if (isDeletedSession && !isTerminalEvent)
+            return;
+        const outbound = isDeletedSession
+            ? { ...event, sessionDeleted: true }
+            : event;
+        for (const listener of [...listeners]) {
+            if (!canPublishRunEvents(runGeneration))
+                return;
+            try {
+                listener(outbound);
+            }
+            catch {
+                /* A view cannot alter execution settlement. */
+            }
+        }
+    }
+    async function execute(job, run) {
+        const runGeneration = generation;
+        const publishForRun = (event) => {
+            publish({
+                ...event,
+                requestId: run.requestId,
+                sessionId: job.sessionId,
+                environment: job.environmentId,
+            }, job.sessionId, runGeneration);
+        };
+        const finish = (settlement) => {
+            publishForRun(settlement.event);
+            return settlement.outcome;
+        };
+        if (options.isDeleted(job.sessionId))
+            return finish(failedScheduledRequestOutcome("session_deleted"));
+        const selection = resolveModelSelection({
+            agentMode: job.agentMode,
+            modelPreference: { profileId: job.modelProfileId, scope: "all" },
+            modelPolicy: options.config.models,
+        });
+        if (selection.execution.primaryProfileId !== job.modelProfileId) {
+            return finish(failedScheduledRequestOutcome("scheduled_model_unavailable"));
+        }
+        let terminal;
+        let acceptingEvents = true;
+        const ws = {
+            send(data) {
+                if (!acceptingEvents)
+                    return;
+                const event = JSON.parse(data);
+                if (event.requestId !== run.requestId)
+                    return;
+                if (isScheduledTerminalEvent(event)) {
+                    terminal = event;
+                    return;
+                }
+                publishForRun(event);
+            },
+        };
+        const message = {
+            type: "run_request",
+            requestId: run.requestId,
+            sessionId: job.sessionId,
+            text: run.prompt,
+            agentMode: job.agentMode,
+            modelPreference: { profileId: job.modelProfileId, scope: "all" },
+            toolPermissionMode: "full_access",
+        };
+        try {
+            await options.handle(ws, message, withScheduledExecution(options.requestOptions?.(run), run));
+        }
+        catch (error) {
+            terminal = failedScheduledRequestOutcome(error).event;
+        }
+        finally {
+            acceptingEvents = false;
+        }
+        return finish(await resolveScheduledRequestOutcome(terminal, options.sessions, run));
+    }
+    const scheduler = createSchedulerService({
+        environmentId: options.config.runtimeId,
+        store: createFileSchedulerStore(join(options.config.paths.runtimeDir, "scheduler")),
+        executor: {
+            tryReserve: (sessionId) => options.admission.tryReserve(sessionId),
+            sessionExists: async (sessionId) => {
+                if (options.isDeleted(sessionId))
+                    return false;
+                return (await options.sessions.getSessionById(sessionId)) !== null;
+            },
+            start: execute,
+        },
+    });
+    function start() {
+        stopped = false;
+        startup ??= scheduler.start();
+        return startup;
+    }
+    return {
+        scheduler,
+        start,
+        ensureStarted() {
+            if (stopped)
+                return Promise.reject(new Error("scheduler_stopped"));
+            return start();
+        },
+        stop() {
+            stopped = true;
+            generation += 1;
+            startup = undefined;
+            listeners.clear();
+            return scheduler.stop();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/src/runtime/capabilities/request-bound-tool-registry.js

@@ -1,3 +1,4 @@
+import { projectAvailableTools } from "./tool-availability.js";
 /**
  * Adds trusted request services to an already config-filtered Tool Registry.
  * Tools remain opaque to the request flow.
@@ -54,27 +55,3 @@ export function bindRequestToolRegistry(params) {
         }),
     });
 }
-function projectAvailableTools(registrations) {
-    if (registrations === undefined)
-        return undefined;
-    const entries = registrations.flatMap((registration) => registration.contract.operations.map((operation) => Object.freeze({
-        toolName: registration.toolName,
-        operationId: operation.operationId,
-        summary: operation.summary,
-        catalogGroups: Object.freeze([
-            ...(registration.definition.catalogGroups ?? ["other"]),
-        ]),
-        effect: operation.effect,
-    })));
-    entries.sort(compareAvailableTools);
-    return Object.freeze(entries);
-}
-function compareAvailableTools(left, right) {
-    const byOperation = compareAscii(left.operationId, right.operationId);
-    return byOperation !== 0
-        ? byOperation
-        : compareAscii(left.toolName, right.toolName);
-}
-function compareAscii(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/src/runtime/capabilities/scheduling/create-operations.d.ts

@@ -0,0 +1,55 @@
+export declare const scheduleCreateOperations: readonly [Readonly<{
+    operationId: string;
+    summary: string;
+    input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
+    selectionControlIds?: readonly string[];
+    fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
+    payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
+    approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
+}>, Readonly<{
+    operationId: string;
+    summary: string;
+    input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
+    selectionControlIds?: readonly string[];
+    fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
+    payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
+    approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
+}>, Readonly<{
+    operationId: string;
+    summary: string;
+    input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
+    selectionControlIds?: readonly string[];
+    fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
+    payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
+    approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
+}>, Readonly<{
+    operationId: string;
+    summary: string;
+    input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
+    selectionControlIds?: readonly string[];
+    fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
+    payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
+    approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
+}>, Readonly<{
+    operationId: string;
+    summary: string;
+    input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
+    selectionControlIds?: readonly string[];
+    fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
+    payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
+    approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
+}>, Readonly<{
+    operationId: string;
+    summary: string;
+    input: import("../../../capabilities/tool-types.js").ToolNormalInvocationInput;
+    selectionControlIds?: readonly string[];
+    fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
+    payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
+    approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
+}>];

package/dist/src/runtime/capabilities/scheduling/create-operations.js

@@ -0,0 +1,30 @@
+import { scheduleDetailProperties, scheduleTimingProperties, } from "./tool-input-properties.js";
+function createScheduleOperation(kind, timingSummary, timingFields, requiredTiming = timingFields) {
+    return {
+        operationId: `create_${kind}`,
+        summary: `Schedule a future request in this conversation using the current model. Write prompt as the complete instruction the assistant must execute when this Job runs. For reminders, explicitly ask it to remind the user to act; preserve the exact action and target. For delegated work, retain the work itself. Put timing in the schedule fields and ask for missing timing details before creating. ${timingSummary}`,
+        effect: "mutating",
+        approval: "request_policy",
+        fixedParams: { action: "create", scheduleKind: kind },
+        input: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                ...scheduleDetailProperties,
+                timeZone: scheduleTimingProperties.timeZone,
+                ...Object.fromEntries(timingFields.map((field) => [field, scheduleTimingProperties[field]])),
+            },
+            required: ["title", "prompt", ...requiredTiming],
+        },
+    };
+}
+export const scheduleCreateOperations = [
+    createScheduleOperation("timer", "Run once after delayMs milliseconds.", [
+        "delayMs",
+    ]),
+    createScheduleOperation("once", "Run once at an exact ISO instant in at, including its UTC offset.", ["at"]),
+    createScheduleOperation("interval", "Repeat everyMs milliseconds with optional exact first-run anchorAt ISO instant.", ["everyMs", "anchorAt"], ["everyMs"]),
+    createScheduleOperation("daily", "Run daily at exact HH:mm in at and an explicit IANA timeZone.", ["at"], ["at", "timeZone"]),
+    createScheduleOperation("weekly", "Run on weekdays (Sunday=0) at exact HH:mm in at and an explicit IANA timeZone.", ["at", "weekdays"], ["at", "weekdays", "timeZone"]),
+    createScheduleOperation("monthly", "Run on dayOfMonth at exact HH:mm in at and an explicit IANA timeZone.", ["at", "dayOfMonth"], ["at", "dayOfMonth", "timeZone"]),
+];

package/dist/src/runtime/capabilities/scheduling/create-time-zone.d.ts

@@ -0,0 +1 @@
+export declare function requireCreateCalendarTimeZone(params: Record<string, unknown>): void;

package/dist/src/runtime/capabilities/scheduling/create-time-zone.js

@@ -0,0 +1,11 @@
+export function requireCreateCalendarTimeZone(params) {
+    const isCalendarSchedule = ["daily", "weekly", "monthly"].includes(String(params.scheduleKind));
+    if (!isCalendarSchedule)
+        return;
+    if (typeof params.timeZone !== "string") {
+        throw new Error("schedule_time_zone_required");
+    }
+    if (!params.timeZone.trim()) {
+        throw new Error("schedule_time_zone_required");
+    }
+}

package/dist/src/runtime/capabilities/scheduling/job-list-page.d.ts

@@ -0,0 +1,25 @@
+import type { SchedulerJob } from "../../scheduler/contracts.js";
+/** A bounded, passive projection; cursors bind to exact Jobs in this session. */
+export declare function createSchedulerJobPage(jobs: readonly SchedulerJob[], params: {
+    cursor?: unknown;
+    limit?: unknown;
+}): {
+    jobs: {
+        id: string;
+        environmentId: string;
+        sessionId: string;
+        title: string;
+        modelProfileId: string;
+        agentMode: import("../../../shared/types.js").AgentMode;
+        toolPermissionMode: "full_access";
+        timeZone: string;
+        schedule: import("../../scheduler/contracts.js").SchedulerSchedule;
+        state: import("../../scheduler/contracts.js").SchedulerJobState;
+        createdAt: string;
+        updatedAt: string;
+        nextRunAt: string | null;
+        revision: number;
+    }[];
+    omittedCount: number;
+    nextCursor: string | null;
+};

package/dist/src/runtime/capabilities/scheduling/job-list-page.js

@@ -0,0 +1,40 @@
+/** A bounded, passive projection; cursors bind to exact Jobs in this session. */
+export function createSchedulerJobPage(jobs, params) {
+    const limit = params.limit === undefined ? 100 : params.limit;
+    if (!isSupportedPageLimit(limit))
+        throw new Error("schedule_page_limit_invalid");
+    const ordered = [...jobs].sort(compareNewestJobs);
+    const offset = cursorOffset(ordered, params.cursor);
+    const page = ordered.slice(offset, offset + limit);
+    const omittedCount = Math.max(0, ordered.length - offset - page.length);
+    return {
+        jobs: page.map(({ prompt: _prompt, ...job }) => job),
+        omittedCount,
+        nextCursor: omittedCount > 0 ? page.at(-1).id : null,
+    };
+}
+function isSupportedPageLimit(value) {
+    if (!Number.isSafeInteger(value))
+        return false;
+    if (Number(value) < 1)
+        return false;
+    return Number(value) <= 100;
+}
+function cursorOffset(jobs, cursor) {
+    if (cursor === undefined)
+        return 0;
+    if (typeof cursor !== "string")
+        throw new Error("schedule_cursor_invalid");
+    if (!cursor)
+        throw new Error("schedule_cursor_invalid");
+    const index = jobs.findIndex((job) => job.id === cursor);
+    if (index < 0)
+        throw new Error("schedule_cursor_not_found");
+    return index + 1;
+}
+function compareNewestJobs(left, right) {
+    const created = right.createdAt.localeCompare(left.createdAt);
+    if (created !== 0)
+        return created;
+    return right.id.localeCompare(left.id);
+}

package/dist/src/runtime/capabilities/scheduling/model-validation.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeConfig } from "../../ports.js";
+export declare function requireAvailableScheduleModel(config: RuntimeConfig, modelProfileId: unknown): void;

package/dist/src/runtime/capabilities/scheduling/model-validation.js

@@ -0,0 +1,15 @@
+import { resolveModelSelection } from "../../model/model-selection.js";
+export function requireAvailableScheduleModel(config, modelProfileId) {
+    if (typeof modelProfileId !== "string") {
+        throw new Error("scheduler_model_required");
+    }
+    const selection = resolveModelSelection({
+        agentMode: "reasoning",
+        modelPreference: { profileId: modelProfileId },
+        modelPolicy: config.models,
+    });
+    const isSelectedScheduleModel = selection.execution.primaryProfileId === modelProfileId;
+    if (!isSelectedScheduleModel) {
+        throw new Error("scheduler_model_unavailable");
+    }
+}

package/dist/src/runtime/capabilities/scheduling/tool-contract.d.ts

@@ -0,0 +1,2 @@
+import type { ToolNormalInvocationContract } from "../../../capabilities/tool-types.js";
+export declare const schedulingToolContract: ToolNormalInvocationContract;

package/dist/src/runtime/capabilities/scheduling/tool-contract.js

@@ -0,0 +1,35 @@
+import { scheduleCreateOperations } from "./create-operations.js";
+import { scheduleUpdateOperations } from "./update-operations.js";
+import { scheduleTextField as text } from "./tool-input-properties.js";
+const identity = { jobId: text(200) };
+function operation(operationId, summary, properties, required, effect) {
+    return {
+        operationId,
+        summary,
+        effect,
+        approval: "request_policy",
+        fixedParams: { action: operationId },
+        input: {
+            type: "object",
+            additionalProperties: false,
+            properties,
+            required,
+        },
+    };
+}
+export const schedulingToolContract = {
+    version: 1,
+    operations: [
+        ...scheduleCreateOperations,
+        operation("list", "List this conversation's schedules newest first, without executing them or exposing their task prompts. Each page has up to 100 Jobs; pass its nextCursor to retrieve the next page until null. A stale cursor requires a fresh list without cursor.", {
+            cursor: text(200),
+            limit: { type: "integer", minimum: 1, maximum: 100 },
+        }, [], "read_only"),
+        operation("get", "Read this conversation's Job and recent run history by exact Job ID.", identity, ["jobId"], "read_only"),
+        ...scheduleUpdateOperations,
+        operation("pause", "Pause future starts of this Job, including its pending occurrence. An already-started run continues.", identity, ["jobId"], "mutating"),
+        operation("resume", "Resume this paused Job from its next future occurrence, without backfill.", identity, ["jobId"], "mutating"),
+        operation("cancel", "Cancel this Job and its pending occurrence. An already-started run continues.", identity, ["jobId"], "mutating"),
+        operation("run_now", "Request one immediate run of this Job; wait if this conversation is busy. Does not change its ordinary recurrence.", identity, ["jobId"], "mutating"),
+    ],
+};

package/dist/src/runtime/capabilities/scheduling/tool-input-properties.d.ts

@@ -0,0 +1,43 @@
+import type { ToolNormalInvocationPropertyInput } from "../../../capabilities/tool-types.js";
+export declare const scheduleTextField: (maxLength: number) => ToolNormalInvocationPropertyInput;
+export declare const scheduleTimingProperties: {
+    scheduleKind: {
+        type: "string";
+        enum: string[];
+    };
+    at: ToolNormalInvocationPropertyInput;
+    delayMs: {
+        type: "integer";
+        minimum: number;
+        maximum: number;
+    };
+    everyMs: {
+        type: "integer";
+        minimum: number;
+        maximum: number;
+    };
+    anchorAt: ToolNormalInvocationPropertyInput;
+    weekdays: {
+        type: "array";
+        items: {
+            type: "integer";
+            minimum: number;
+            maximum: number;
+        };
+        minItems: number;
+        maxItems: number;
+    };
+    dayOfMonth: {
+        type: "integer";
+        minimum: number;
+        maximum: number;
+    };
+    timeZone: ToolNormalInvocationPropertyInput;
+};
+export declare const scheduleDetailProperties: {
+    title: ToolNormalInvocationPropertyInput;
+    prompt: {
+        type: "string";
+        minLength: number;
+    };
+};

package/dist/src/runtime/capabilities/scheduling/tool-input-properties.js

@@ -0,0 +1,27 @@
+export const scheduleTextField = (maxLength) => ({
+    type: "string",
+    minLength: 1,
+    maxLength,
+});
+export const scheduleTimingProperties = {
+    scheduleKind: {
+        type: "string",
+        enum: ["timer", "once", "interval", "daily", "weekly", "monthly"],
+    },
+    at: scheduleTextField(64),
+    delayMs: { type: "integer", minimum: 1_000, maximum: 31_536_000_000 },
+    everyMs: { type: "integer", minimum: 1_000, maximum: 31_536_000_000 },
+    anchorAt: scheduleTextField(64),
+    weekdays: {
+        type: "array",
+        items: { type: "integer", minimum: 0, maximum: 6 },
+        minItems: 1,
+        maxItems: 7,
+    },
+    dayOfMonth: { type: "integer", minimum: 1, maximum: 31 },
+    timeZone: scheduleTextField(100),
+};
+export const scheduleDetailProperties = {
+    title: scheduleTextField(200),
+    prompt: { type: "string", minLength: 1 },
+};

package/dist/src/runtime/capabilities/scheduling/tool-module.d.ts

@@ -0,0 +1,4 @@
+import type { ToolModuleDeclaration } from "../../../capabilities/tool-types.js";
+import type { RuntimeConfig } from "../../ports.js";
+import type { SchedulerService } from "../../scheduler/contracts.js";
+export declare function createSchedulingToolModule(service: SchedulerService, config: RuntimeConfig, ready: () => Promise<void>): ToolModuleDeclaration;