@sema-agent/core 1.452.0 → 2.0.0

package/dist/core/runner/session-rule-policy.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../../internal/harness.js";
+import type { ExecutionEnv } from "../../internal/harness-types.js";
 import type { ToolEffect } from "../types.js";
 import { type ToolPolicy } from "../tool-policy.js";
 import type { SessionPermissionRules } from "../session-policy-store.js";

package/dist/core/runner/synthetic-tools.d.ts

@@ -1,5 +1,5 @@
 import { type TSchema } from "typebox";
-import type { AgentTool } from "../../internal/harness.js";
+import type { AgentTool } from "../../internal/harness-types.js";
 import type { SkillManifest } from "../types.js";
 import type { ActiveSkillScope } from "./active-skill-scope.js";
 export declare const OUTPUT_TOOL_NAME = "StructuredOutput";
@@ -14,8 +14,8 @@ export interface OutputRef {
     value?: unknown;
     set?: boolean;
 }
-export declare function makeOutputTool(ref: OutputRef, schema: TSchema, strictSchema?: TSchema): AgentTool;
-export declare function makeReportBlockedTool(ref: BlockedRef): AgentTool;
+export declare function createOutputTool(ref: OutputRef, schema: TSchema, strictSchema?: TSchema): AgentTool;
+export declare function createReportBlockedTool(ref: BlockedRef): AgentTool;
 export interface ReportedFinding {
     file: string;
     line?: number;
@@ -25,7 +25,7 @@ export interface ReportedFinding {
     verdict?: "CONFIRMED" | "PLAUSIBLE";
     outcome?: "fixed" | "skipped" | "no_change_needed";
 }
-export declare function makeReportFindingsTool(): AgentTool;
+export declare function createReportFindingsTool(): AgentTool;
 export declare const SKILL_TOOL_NAME = "Skill";
 export declare const SKILL_CONTENT_MAX_CHARS: number;
 export declare const SKILLS_BLOCK_MAX_BYTES = 8000;
@@ -52,5 +52,5 @@ export declare function normalizeSkills(skills: SkillLike[] | undefined): SkillL
 export declare const SKILLS_LISTING_PROBE_HEADER = "The following skills are available for this task.";
 export declare function skillListingLine(s: SkillListingEntry): string;
 export declare function buildSkillsBlock(skills: ReadonlyArray<SkillListingEntry>): string | undefined;
-export declare function makeSkillTool(skills: SkillLike[], scope?: ActiveSkillScope): AgentTool;
+export declare function createSkillTool(skills: SkillLike[], scope?: ActiveSkillScope): AgentTool;
 export {};

package/dist/core/runner/synthetic-tools.js

@@ -11,7 +11,7 @@ export function resolveOutputRetries(outputRetries) {
         return OUTPUT_DEFAULT_RETRIES;
     return Math.floor(outputRetries);
 }
-export function makeOutputTool(ref, schema, strictSchema) {
+export function createOutputTool(ref, schema, strictSchema) {
     return defineTool({
         name: OUTPUT_TOOL_NAME,
         contract: { contractId: "core.structured_output@1", implementationRevision: "1" },
@@ -26,7 +26,7 @@ export function makeOutputTool(ref, schema, strictSchema) {
         },
     });
 }
-export function makeReportBlockedTool(ref) {
+export function createReportBlockedTool(ref) {
     return defineTool({
         name: REPORT_BLOCKED_TOOL_NAME,
         contract: { contractId: "core.report_blocked@1", implementationRevision: "1" },
@@ -55,7 +55,7 @@ const REPORT_FINDING_SCHEMA = Type.Object({
         description: "Set ONLY when re-reporting after applying fixes: what happened to this finding",
     })),
 });
-export function makeReportFindingsTool() {
+export function createReportFindingsTool() {
     return defineTool({
         name: REPORT_FINDINGS_TOOL_NAME,
         contract: { contractId: "core.report_findings@1", implementationRevision: "1" },
@@ -167,7 +167,7 @@ export function buildSkillsBlock(skills) {
     }
     return render([SKILLS_BLOCK_CAP_MARKER, `(… +${skills.length} more skills not listed — the ${SKILL_TOOL_NAME} tool serves them all)`]);
 }
-export function makeSkillTool(skills, scope) {
+export function createSkillTool(skills, scope) {
     const byName = new Map(skills.map((s) => [s.name, s]));
     const names = skills.map((s) => s.name).join(", ");
     return defineTool({

package/dist/core/runner/tool-disclosure.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage, AgentTool } from "../../internal/harness.js";
+import type { AgentMessage, AgentTool } from "../../internal/harness-types.js";
 import type { Model } from "../../internal/llm.js";
 import type { ToolSpec } from "../types.js";
 export declare const TOOL_SEARCH_NAME = "ToolSearch";
@@ -26,7 +26,7 @@ export declare function buildDeferredRegistry(deferred: ReadonlySet<string>, too
     name: string;
     description: string;
 }>): Map<string, DeferredToolInfo>;
-export declare function makePlaceholderTool(info: DeferredToolInfo): AgentTool;
+export declare function createPlaceholderTool(info: DeferredToolInfo): AgentTool;
 export declare function scoreToolMatch(query: string, info: DeferredToolInfo): number;
 export interface ToolSearchArgs {
     query?: string;
@@ -39,7 +39,7 @@ export declare function resolveToolSearchDetailed(args: ToolSearchArgs, registry
 };
 export declare function resolveToolSearch(args: ToolSearchArgs, registry: ReadonlyMap<string, DeferredToolInfo>): string[];
 export declare function extractDiscoveredToolNames(messages: ReadonlyArray<AgentMessage>, registry: ReadonlyMap<string, DeferredToolInfo>): string[];
-export declare function makeToolSearchTool(opts: {
+export declare function createToolSearchTool(opts: {
     registry: ReadonlyMap<string, DeferredToolInfo>;
     active: Set<string>;
     rematerialize: (active: ReadonlySet<string>) => Promise<void>;

package/dist/core/runner/tool-disclosure.js

@@ -52,7 +52,7 @@ export function buildDeferredRegistry(deferred, tools) {
     }
     return reg;
 }
-export function makePlaceholderTool(info) {
+export function createPlaceholderTool(info) {
     const sn = safeName(info.name);
     return defineTool({
         name: info.name,
@@ -152,7 +152,7 @@ export function extractDiscoveredToolNames(messages, registry) {
     }
     return [...names];
 }
-export function makeToolSearchTool(opts) {
+export function createToolSearchTool(opts) {
     const { registry, active, rematerialize, listingRide, mountedNames } = opts;
     let activationChain = Promise.resolve();
     return defineTool({

package/dist/core/runner/tool-output-projection.d.ts

@@ -0,0 +1,6 @@
+export declare const toolOutputFrom: (result: unknown) => {
+    output: unknown;
+    truncated: boolean;
+    totalChars?: number;
+} | undefined;
+export declare const structuredFrom: (result: unknown) => unknown;

package/dist/core/runner/tool-output-projection.js

@@ -0,0 +1,81 @@
+const MAX_TOOL_END_OUTPUT_CHARS = 16384;
+const safeJsonLength = (v) => {
+    try {
+        return JSON.stringify(v)?.length;
+    }
+    catch {
+        return undefined;
+    }
+};
+const trunc = (s) => ({
+    text: s.slice(0, MAX_TOOL_END_OUTPUT_CHARS) + `…[+${s.length - MAX_TOOL_END_OUTPUT_CHARS} chars truncated]`,
+    totalChars: s.length,
+});
+export const toolOutputFrom = (result) => {
+    const content = result !== null && typeof result === "object" ? result.content : result;
+    if (content === undefined)
+        return undefined;
+    if (typeof content === "string") {
+        if (content.length <= MAX_TOOL_END_OUTPUT_CHARS)
+            return { output: content, truncated: false };
+        const t = trunc(content);
+        return { output: t.text, truncated: true, totalChars: t.totalChars };
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(content) ?? "";
+    }
+    catch {
+        return { output: "[unserializable tool output]", truncated: false };
+    }
+    if (serialized.length <= MAX_TOOL_END_OUTPUT_CHARS)
+        return { output: content, truncated: false };
+    let anyNonText = false;
+    let trueChars = 0;
+    const raw = Array.isArray(content)
+        ? content
+            .map((b) => {
+            const block = b;
+            if (block?.type === "text" && typeof block.text === "string") {
+                trueChars += block.text.length;
+                return block.text;
+            }
+            anyNonText = true;
+            trueChars += typeof block?.data === "string" ? block.data.length : (safeJsonLength(block) ?? 0);
+            return `[${typeof block?.type === "string" ? block.type : "block"}${typeof block?.mimeType === "string" ? `: ${block.mimeType}` : ""}]`;
+        })
+            .join("\n")
+        : serialized;
+    const totalChars = Array.isArray(content) ? trueChars : serialized.length;
+    if (raw.length > MAX_TOOL_END_OUTPUT_CHARS) {
+        const t = trunc(raw);
+        return { output: t.text, truncated: true, totalChars };
+    }
+    if (!anyNonText) {
+        return { output: raw, truncated: false };
+    }
+    return { output: raw, truncated: true, totalChars };
+};
+const CC_DETAIL_TYPES = new Set([
+    "edit", "multiedit", "create", "update", "bash", "notebook-edit", "notebook", "text", "grep", "glob", "mcp",
+    "agent", "task", "task-list", "task-output", "memory-saved", "workflow-run",
+    "web-fetch", "web-search", "todo", "cron-create", "cron-delete", "cron-list", "image",
+    "task-stop", "tool-search", "memory-recall", "repo-map", "fork", "enter-plan-mode", "exit-plan-mode",
+]);
+export const structuredFrom = (result) => {
+    const details = result !== null && typeof result === "object" ? result.details : undefined;
+    if (details === null || typeof details !== "object")
+        return undefined;
+    const t = details.type;
+    if (typeof t !== "string" || !CC_DETAIL_TYPES.has(t))
+        return undefined;
+    try {
+        const serialized = JSON.stringify(details) ?? "";
+        if (serialized.length > MAX_TOOL_END_OUTPUT_CHARS * 4)
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return details;
+};

package/dist/core/runtime.d.ts

@@ -1,3 +1,3 @@
-import type { AgentCoreRuntimeDeps } from "../internal/harness.js";
+import type { AgentCoreRuntimeDeps } from "../internal/harness-types.js";
 import type { Brain } from "./types.js";
 export declare function brainToRuntime(brain: Brain): AgentCoreRuntimeDeps;

package/dist/core/scheduler.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv, Result } from "../internal/harness.js";
+import type { ExecutionEnv, Result } from "../internal/harness-types.js";
 export type ScheduledTaskId = string & {
     readonly __brand: "ScheduledTaskId";
 };

package/dist/core/sensitive-path-policy.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../internal/harness.js";
+import type { ExecutionEnv } from "../internal/harness-types.js";
 import type { ToolPolicy } from "./tool-policy.js";
 export declare const RECOMMENDED_SENSITIVE_PATTERNS: readonly string[];
 export declare function createSensitivePathPolicy(opts: {

package/dist/core/session-reconcile.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage } from "../internal/harness.js";
+import type { AgentMessage } from "../internal/harness-types.js";
 import type { Session } from "./session.js";
 import type { ToolEffect } from "./types.js";
 export interface OrphanToolCall {

package/dist/core/session-store.d.ts

@@ -1,6 +1,7 @@
 import { type SessionRepo } from "../internal/harness.js";
 import { type AcquiredSession, type SessionStore, type SessionStoreSummary } from "./session.js";
-export declare const SESSION_DEFAULT_TTL_DAYS = 7;
+import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
+export { SESSION_DEFAULT_TTL_DAYS };
 export type EvictPolicy = "delete" | "forget";
 export interface TtlSessionStoreOptions {
     defaultTtlDays?: number;

package/dist/core/session-store.js

@@ -1,7 +1,8 @@
 import { InMemorySessionRepo, uuidv7, } from "../internal/harness.js";
 import { isSessionConflict } from "./session.js";
 const DAY_MS = 24 * 60 * 60 * 1000;
-export const SESSION_DEFAULT_TTL_DAYS = 7;
+import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
+export { SESSION_DEFAULT_TTL_DAYS };
 export class TtlSessionStore {
     repo;
     entries = new Map();

package/dist/core/session.d.ts

@@ -19,7 +19,6 @@ export interface SessionStoreSummary {
     lastTaskId?: string;
     forkedFrom?: string;
 }
-export type SessionSummary = SessionStoreSummary;
 export interface SessionStore {
     acquire(sessionId?: string, opts?: {
         requireExisting?: boolean;

package/dist/core/task-registry-agent.d.ts

@@ -0,0 +1,115 @@
+import { type BackgroundAgentRecord, type BackgroundAgentStore } from "./background-agent-store.js";
+import { type StopSource, type TaskAccess, type UnifiedTaskResult, type BackgroundAgentTaskHandle, type DurableAgentCore, type ParkedClaimTicket, type RegisterBackgroundAgentInput } from "./task-registry-shared.js";
+export declare function ensureDurableHeartbeatLane(core: DurableAgentCore): void;
+export declare function durableAgentWriteLane(handle: BackgroundAgentTaskHandle, patch: Partial<BackgroundAgentRecord>, clear?: (keyof BackgroundAgentRecord)[]): void;
+export declare function durableAgentArmedLane(core: DurableAgentCore, id: string): boolean;
+export declare function durableAgentRowProbeLane(core: DurableAgentCore, id: string): (() => Promise<boolean>) | undefined;
+export declare function beginDurableClaimLane(core: DurableAgentCore, id: string): boolean;
+export declare function endDurableClaimLane(core: DurableAgentCore, id: string): void;
+export declare function reapDurableAgentsLane(core: DurableAgentCore, scope: string, deps: {
+    store: BackgroundAgentStore;
+    sessions?: {
+        unpin?(sessionId: string): unknown;
+        release(sessionId: string): Promise<void> | void;
+    };
+    mailbox?: {
+        drop(scope: string, handle: string): Promise<void>;
+    };
+}, policy: {
+    now?: number;
+    maxAgeMs?: number;
+    keep?: number;
+    staleRunningMaxAgeMs?: number;
+}): Promise<{
+    rowsReaped: number;
+    sessionsReleased: number;
+    skippedNoSessions: number;
+}>;
+export declare function releaseDurableTranscriptAnchorLane(core: DurableAgentCore, id: string): void;
+export declare function bindBackgroundAgentSessionLane(core: DurableAgentCore, id: string, sessionId: string): void;
+export declare function registerBackgroundAgentLane(core: DurableAgentCore, input: RegisterBackgroundAgentInput): string;
+export declare function parkBackgroundAgentLane(core: DurableAgentCore, id: string, park: {
+    checkpointToken: string;
+    seq?: number;
+    resolveStop?: () => Promise<boolean>;
+}): "parked" | undefined;
+export declare function reconcileParkedAgentsLane(core: DurableAgentCore, stores: {
+    agentStore: import("./background-agent-store.js").BackgroundAgentStore;
+    checkpointStore: Pick<import("./checkpoint-store.js").CheckpointStore, "get">;
+}, scope: string, now: number, opts?: {
+    staleClaimMaxAgeMs?: number;
+}): Promise<{
+    failed: number;
+    rolledBack: number;
+}>;
+export declare function claimParkedAgentLane(stores: {
+    agentStore: import("./background-agent-store.js").BackgroundAgentStore;
+    checkpointStore: Pick<import("./checkpoint-store.js").CheckpointStore, "get">;
+}, handle: string, access: TaskAccess): Promise<{
+    ok: true;
+    ticket: ParkedClaimTicket;
+} | {
+    ok: false;
+    reason: "not_found" | "not_parked" | "binding_broken" | "checkpoint_not_pending" | "claim_lost" | "store_unreachable";
+}>;
+export declare function rollbackParkedClaimLane(core: DurableAgentCore, stores: {
+    agentStore: import("./background-agent-store.js").BackgroundAgentStore;
+    checkpointStore: Pick<import("./checkpoint-store.js").CheckpointStore, "get">;
+}, ticket: ParkedClaimTicket): Promise<"rolled_back" | "failed" | "lost" | "retry">;
+export declare function consumeParkedFlipLane(core: DurableAgentCore, id: string, stores: {
+    agentStore: import("./background-agent-store.js").BackgroundAgentStore;
+}, ticket: ParkedClaimTicket): Promise<boolean>;
+export declare function finalizeParkedResumeLane(core: DurableAgentCore, id: string): void;
+export declare function settleBackgroundAgentLane(core: DurableAgentCore, id: string, outcome: {
+    status: "completed" | "failed" | "killed";
+    result?: string;
+    resultFull?: string;
+    error?: string;
+    stoppedBy?: StopSource;
+    seq?: number;
+}): "completed" | "failed" | "killed" | undefined;
+export declare function abortBackgroundAgentsForOwnerLane(core: DurableAgentCore, access: TaskAccess, opts?: {
+    skipSessionScoped?: boolean;
+    sessionScopedOnly?: boolean;
+}): number;
+export declare function resolveBackgroundAgentByNameLane(core: DurableAgentCore, name: string, access: TaskAccess, opts?: {
+    preferRunning?: boolean;
+}): {
+    status: "found";
+    handle: BackgroundAgentTaskHandle;
+} | {
+    status: "ambiguous";
+    message: string;
+} | {
+    status: "not_found";
+    suggestion?: string;
+};
+export declare function markRetainedContinuationLane(core: DurableAgentCore, id: string): void;
+export declare function reviveBackgroundAgentLane(core: DurableAgentCore, id: string, access: TaskAccess, abort?: AbortController): {
+    ok: true;
+    cycle: number;
+} | {
+    ok: false;
+    reason: "not_found" | "still_running";
+};
+export declare function settleRevivedAgentLane(core: DurableAgentCore, id: string, cycle: number, outcome: {
+    status: "completed" | "failed" | "killed";
+    result?: string;
+    resultFull?: string;
+    error?: string;
+}): "completed" | "failed" | "killed" | undefined;
+export declare function unmarkRetainedContinuationLane(core: DurableAgentCore, id: string): void;
+export declare function attachAgentNotifyLane(core: DurableAgentCore, id: string, notify: NonNullable<BackgroundAgentTaskHandle["notify"]>, cycle?: number): void;
+export declare function deliverToRunningAgentLane(core: DurableAgentCore, id: string, access: TaskAccess, notification: import("./task-notification.js").TaskNotificationPayload, opts?: {
+    priority?: import("./task-notification.js").SystemInjectionPriority;
+}): Promise<{
+    ok: true;
+    disposition: "queued" | "parked" | "pending";
+} | {
+    ok: false;
+    reason: "not_found" | "not_running" | "no_channel";
+}>;
+export declare function runningBackgroundAgentLabelsLane(core: DurableAgentCore, access: TaskAccess): string[];
+export declare function serveDurableAgentRowLane(row: BackgroundAgentRecord): UnifiedTaskResult;
+export declare function pollBackgroundAgentLane(handle: BackgroundAgentTaskHandle, deadline?: number, signal?: AbortSignal): Promise<UnifiedTaskResult>;
+export declare function stopBackgroundAgentLane(core: DurableAgentCore, handle: BackgroundAgentTaskHandle): Promise<UnifiedTaskResult>;