@code-yeongyu/senpi 2026.11.15-2 → 2026.11.15-3

package/dist/core/tools/write-core.js

@@ -0,0 +1,108 @@
+import { Type } from "typebox";
+import { decodeUtf8, encodeUtf8 } from "./encoding.js";
+import { fsErrorCode } from "./fs-error-code.js";
+import { inProcessFileMutationQueue, lexicalCanonicalPath, posixDirname, resolvePosixToolPath, } from "./file-tool-host.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { createWriteDetails } from "./write-result.js";
+export const writeSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
+    content: Type.String({ description: "Content to write to the file" }),
+});
+export const writeToolSystemPromptContribution = {
+    snippet: "Create or overwrite files",
+    guidelines: ["write only for new files or full rewrites."],
+    fullGuidelines: ["Use write only for new files or complete rewrites."],
+};
+/**
+ * The default write operations over the shared operation layer. `files.write` creates the parent directory in the
+ * same call (`createParentDirs`), so `mkdir` has nothing left to do; the tool already holds the file's mutation slot.
+ */
+function machineWriteOperations(machine, signal) {
+    const ctx = machine.context(signal, "caller");
+    return {
+        writeFile: async (path, content) => {
+            await machine.ops.files.write({ path, bytes: encodeUtf8(content), createParentDirs: true }, ctx);
+        },
+        mkdir: async () => { },
+    };
+}
+/** The file's content before the write, read on the machine; it feeds the patch in the result details. */
+function machineWriteBaseline(machine) {
+    return async (absolutePath) => {
+        try {
+            const { bytes } = await machine.ops.files.read({ path: absolutePath }, machine.context(undefined, "caller"));
+            return { kind: "present", content: decodeUtf8(bytes) };
+        }
+        catch (error) {
+            if (error instanceof Error && fsErrorCode(error) === "ENOENT")
+                return { kind: "missing" };
+            if (error instanceof Error)
+                return { kind: "unavailable" };
+            throw error;
+        }
+    };
+}
+export function createCoreWriteToolDefinition(cwd, options) {
+    const machine = options.machine;
+    const readBaseline = options.operations ? undefined : (options.readBaseline ?? machineWriteBaseline(machine));
+    const filesystemPolicy = options.filesystemPolicy;
+    const resolvePath = options.resolvePath ?? resolvePosixToolPath;
+    const dirname = options.dirname ?? posixDirname;
+    const withMutationQueue = options.withMutationQueue ?? inProcessFileMutationQueue;
+    const canonicalizePath = options.canonicalizePath ?? lexicalCanonicalPath;
+    return {
+        name: "write",
+        label: "write",
+        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+        promptSnippet: writeToolSystemPromptContribution.snippet,
+        promptGuidelines: [...writeToolSystemPromptContribution.guidelines],
+        fullPromptGuidelines: [...writeToolSystemPromptContribution.fullGuidelines],
+        parameters: writeSchema,
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
+        async execute(_toolCallId, { path, content }, signal, _onUpdate, ctx) {
+            const admitted = machine.begin("files.write", { path, content }, signal);
+            if (admitted !== undefined)
+                await admitted;
+            const ops = options.operations ?? machineWriteOperations(machine, signal);
+            const absolutePath = resolvePath(path, ctx?.cwd || cwd);
+            const dir = dirname(absolutePath);
+            return withMutationQueue(absolutePath, async () => {
+                // Do not reject from an abort event listener here: that would release the
+                // mutation queue while an in-flight filesystem operation may still finish.
+                // Checking signal.aborted after each await observes the same aborts while
+                // keeping the queue locked until the current operation has settled.
+                const throwIfAborted = () => {
+                    if (signal?.aborted)
+                        throw new Error("Operation aborted");
+                };
+                throwIfAborted();
+                if (filesystemPolicy) {
+                    const decision = await filesystemPolicy({
+                        operation: "write",
+                        canonicalPath: await canonicalizePath(absolutePath),
+                        toolName: "write",
+                    });
+                    if (!decision.allow)
+                        throw new Error(decision.reason);
+                    throwIfAborted();
+                }
+                const baseline = readBaseline ? await readBaseline(absolutePath) : { kind: "unavailable" };
+                throwIfAborted();
+                // Create parent directories if needed.
+                await ops.mkdir(dir);
+                throwIfAborted();
+                // Write the file contents.
+                await ops.writeFile(absolutePath, content);
+                throwIfAborted();
+                return {
+                    content: [{ type: "text", text: `Successfully wrote to ${path}` }],
+                    details: createWriteDetails(path, content, baseline),
+                };
+            });
+        },
+    };
+}
+export function createCoreWriteTool(cwd, options) {
+    return wrapToolDefinition(createCoreWriteToolDefinition(cwd, options));
+}
+//# sourceMappingURL=write-core.js.map

package/dist/core/tools/write-result.d.ts

@@ -11,7 +11,6 @@ export type WriteBaseline = {
 } | {
     readonly kind: "unavailable";
 };
-export declare function readLocalWriteBaseline(absolutePath: string): Promise<WriteBaseline>;
 export declare function createWriteDetails(path: string, content: string, baseline: WriteBaseline): WriteToolDetails | undefined;
 export declare function formatWriteResult(result: {
     readonly content: readonly {

package/dist/core/tools/write-result.js

@@ -1,17 +1,4 @@
-import { readFile } from "fs/promises";
 import { createUnifiedPatch } from "./unified-diff.js";
-export async function readLocalWriteBaseline(absolutePath) {
-    try {
-        return { kind: "present", content: await readFile(absolutePath, "utf-8") };
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return { kind: "missing" };
-        if (error instanceof Error)
-            return { kind: "unavailable" };
-        throw error;
-    }
-}
 export function createWriteDetails(path, content, baseline) {
     switch (baseline.kind) {
         case "missing":

package/dist/core/tools/write.d.ts

@@ -1,37 +1,12 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { type Static, Type } from "typebox";
-import type { FilesystemPolicyChecker, ToolDefinition } from "../extensions/types.ts";
-import { type ToolMachine } from "./machine.ts";
-import { type WriteToolDetails } from "./write-result.ts";
-declare const writeSchema: Type.TObject<{
-    path: Type.TString;
-    content: Type.TString;
-}>;
-export declare const writeToolSystemPromptContribution: {
-    readonly snippet: "Create or overwrite files";
-    readonly guidelines: readonly ["write only for new files or full rewrites."];
-    readonly fullGuidelines: readonly ["Use write only for new files or complete rewrites."];
-};
-export type WriteToolInput = Static<typeof writeSchema>;
-/**
- * Pluggable operations for the write tool.
- * Override these to delegate file writing to remote systems (for example SSH).
- */
-export interface WriteOperations {
-    /** Write content to a file */
-    writeFile: (absolutePath: string, content: string) => Promise<void>;
-    /** Create directory recursively */
-    mkdir: (dir: string) => Promise<void>;
-}
-export interface WriteToolOptions {
-    /** Custom operations for file writing. Default: local filesystem */
-    operations?: WriteOperations;
-    /** Extension-registered filesystem policy checker. */
-    filesystemPolicy?: FilesystemPolicyChecker;
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type CoreWriteToolOptions, type writeSchema } from "./write-core.ts";
+import type { WriteToolDetails } from "./write-result.ts";
+export { type WriteOperations, type WriteToolInput, writeToolSystemPromptContribution } from "./write-core.ts";
+export interface WriteToolOptions extends Pick<CoreWriteToolOptions, "operations" | "filesystemPolicy"> {
     /** Operation layer and policy gate. Default: the process-wide local machine. */
-    machine?: ToolMachine;
+    machine?: CoreWriteToolOptions["machine"];
 }
 export declare function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition<typeof writeSchema, WriteToolDetails | undefined>;
 export declare function createWriteTool(cwd: string, options?: WriteToolOptions): AgentTool<typeof writeSchema>;
-export {};
 //# sourceMappingURL=write.d.ts.map

package/dist/core/tools/write.js

@@ -1,89 +1,37 @@
-import { dirname } from "path";
-import { Type } from "typebox";
+import { readFile } from "node:fs/promises";
+import { dirname } from "node:path";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { canonicalizeFilesystemPath } from "./filesystem-policy.js";
 import { defaultToolMachine } from "./machine.js";
 import { resolveToCwd } from "./path-utils.js";
 import { writeRenderers } from "./renderers/write.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-import { createWriteDetails, readLocalWriteBaseline } from "./write-result.js";
-const writeSchema = Type.Object({
-    path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
-    content: Type.String({ description: "Content to write to the file" }),
-});
-export const writeToolSystemPromptContribution = {
-    snippet: "Create or overwrite files",
-    guidelines: ["write only for new files or full rewrites."],
-    fullGuidelines: ["Use write only for new files or complete rewrites."],
-};
-/**
- * The default write operations over the shared operation layer. `files.write` creates the parent directory in the
- * same call (`createParentDirs`), so `mkdir` has nothing left to do; the tool already holds the file's mutation slot.
- */
-function machineWriteOperations(machine, signal) {
-    const ctx = machine.context(signal, "caller");
-    return {
-        writeFile: async (path, content) => {
-            await machine.ops.files.write({ path, bytes: Buffer.from(content, "utf-8"), createParentDirs: true }, ctx);
-        },
-        mkdir: async () => { },
-    };
+import { createCoreWriteToolDefinition } from "./write-core.js";
+export { writeToolSystemPromptContribution } from "./write-core.js";
+async function readLocalWriteBaseline(absolutePath) {
+    try {
+        return { kind: "present", content: await readFile(absolutePath, "utf-8") };
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return { kind: "missing" };
+        if (error instanceof Error)
+            return { kind: "unavailable" };
+        throw error;
+    }
 }
 export function createWriteToolDefinition(cwd, options) {
-    const machine = options?.machine ?? defaultToolMachine();
-    const readBaseline = options?.operations ? undefined : readLocalWriteBaseline;
-    const filesystemPolicy = options?.filesystemPolicy;
     return {
-        ...(options?.operations !== undefined || filesystemPolicy !== undefined ? { serverPinned: true } : {}),
-        name: "write",
-        label: "write",
-        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
-        promptSnippet: writeToolSystemPromptContribution.snippet,
-        promptGuidelines: [...writeToolSystemPromptContribution.guidelines],
-        fullPromptGuidelines: [...writeToolSystemPromptContribution.fullGuidelines],
-        parameters: writeSchema,
-        constrainedSampling: { type: "json_schema", strict: "prefer" },
-        async execute(_toolCallId, { path, content }, signal, _onUpdate, ctx) {
-            const admitted = machine.begin("files.write", { path, content }, signal);
-            if (admitted !== undefined)
-                await admitted;
-            const ops = options?.operations ?? machineWriteOperations(machine, signal);
-            const absolutePath = resolveToCwd(path, ctx?.cwd || cwd);
-            const dir = dirname(absolutePath);
-            return withFileMutationQueue(absolutePath, async () => {
-                // Do not reject from an abort event listener here: that would release the
-                // mutation queue while an in-flight filesystem operation may still finish.
-                // Checking signal.aborted after each await observes the same aborts while
-                // keeping the queue locked until the current operation has settled.
-                const throwIfAborted = () => {
-                    if (signal?.aborted)
-                        throw new Error("Operation aborted");
-                };
-                throwIfAborted();
-                if (filesystemPolicy) {
-                    const decision = await filesystemPolicy({
-                        operation: "write",
-                        canonicalPath: await canonicalizeFilesystemPath(absolutePath),
-                        toolName: "write",
-                    });
-                    if (!decision.allow)
-                        throw new Error(decision.reason);
-                    throwIfAborted();
-                }
-                const baseline = readBaseline ? await readBaseline(absolutePath) : { kind: "unavailable" };
-                throwIfAborted();
-                // Create parent directories if needed.
-                await ops.mkdir(dir);
-                throwIfAborted();
-                // Write the file contents.
-                await ops.writeFile(absolutePath, content);
-                throwIfAborted();
-                return {
-                    content: [{ type: "text", text: `Successfully wrote to ${path}` }],
-                    details: createWriteDetails(path, content, baseline),
-                };
-            });
-        },
+        ...(options?.operations !== undefined || options?.filesystemPolicy !== undefined ? { serverPinned: true } : {}),
+        ...createCoreWriteToolDefinition(cwd, {
+            ...options,
+            machine: options?.machine ?? defaultToolMachine(),
+            resolvePath: resolveToCwd,
+            dirname,
+            withMutationQueue: withFileMutationQueue,
+            canonicalizePath: canonicalizeFilesystemPath,
+            readBaseline: readLocalWriteBaseline,
+        }),
         ...writeRenderers,
     };
 }

package/dist/core/turn-origin.d.ts

@@ -16,7 +16,7 @@ export declare function inputTurnMark(input: {
     readonly connectionOrigin?: ConnectionOrigin;
     readonly source?: string;
 }): InputTurnMark;
-export declare function markInputTurnOrigin(message: object, mark: InputTurnMark): void;
+export declare function markInputTurnOrigin(message: object, mark: InputTurnMark, personStarted?: boolean): void;
 /** Carries `from`'s origin mark onto `to`, a copy of the same input: a copy without it would open or join a turn unmarked. */
 export declare function copyInputTurnMark(from: object, to: object): void;
 /** Whether a message carries an origin mark: a user message always opens a turn's origin, any other only when marked. */
@@ -30,10 +30,12 @@ export declare function recordIsDelegated(): boolean;
  * the turn it continues. The user message that opens a turn sets its origin, a steer keeps it.
  */
 export declare function noteRunStart(sessionManager: object): void;
-/** A retry or recovery run repeats the turn it continues, so it keeps that turn's origin until the continuation ends. */
+/** The next retry or recovery run repeats this turn; its start consumes the continuation mark. */
 export declare function noteTurnContinuation(sessionManager: object): void;
 export declare function endTurnContinuation(sessionManager: object): void;
 export declare function noteUserMessageStart(sessionManager: object, message: object): void;
+/** A person's admitted message owns this identity; only an explicit continuation preserves it across run starts. */
+export declare function currentPersonTurn(sessionManager: object): object | undefined;
 /** Whether the deciding turn counts as delegated-origin: a cross-account device started this turn or this run. */
 export declare function decidingTurnIsDelegated(sessionManager: object): boolean;
 //# sourceMappingURL=turn-origin.d.ts.map

package/dist/core/turn-origin.js

@@ -32,8 +32,8 @@ export function inputTurnMark(input) {
         return "delegated";
     return input.source === undefined || input.source === "interactive" ? "local" : "engine";
 }
-export function markInputTurnOrigin(message, mark) {
-    inputMarks.set(message, mark);
+export function markInputTurnOrigin(message, mark, personStarted = false) {
+    inputMarks.set(message, { origin: mark, personStarted });
 }
 /** Carries `from`'s origin mark onto `to`, a copy of the same input: a copy without it would open or join a turn unmarked. */
 export function copyInputTurnMark(from, to) {
@@ -58,11 +58,11 @@ export function recordIsDelegated() {
  * the turn it continues. The user message that opens a turn sets its origin, a steer keeps it.
  */
 export function noteRunStart(sessionManager) {
-    if (continuingTurns.has(sessionManager))
+    if (continuingTurns.delete(sessionManager))
         return;
-    currentOrigins.set(sessionManager, recordScope.closeAtRunStart() === true ? "delegated" : "engine");
+    currentOrigins.set(sessionManager, { origin: recordScope.closeAtRunStart() === true ? "delegated" : "engine" });
 }
-/** A retry or recovery run repeats the turn it continues, so it keeps that turn's origin until the continuation ends. */
+/** The next retry or recovery run repeats this turn; its start consumes the continuation mark. */
 export function noteTurnContinuation(sessionManager) {
     continuingTurns.add(sessionManager);
 }
@@ -71,12 +71,19 @@ export function endTurnContinuation(sessionManager) {
 }
 export function noteUserMessageStart(sessionManager, message) {
     const mark = inputMarks.get(message);
-    if (mark === "join")
+    if (mark?.origin === "join")
         return;
-    currentOrigins.set(sessionManager, mark ?? "engine");
+    currentOrigins.set(sessionManager, {
+        origin: mark?.origin ?? "engine",
+        personTurn: mark?.personStarted ? {} : undefined,
+    });
+}
+/** A person's admitted message owns this identity; only an explicit continuation preserves it across run starts. */
+export function currentPersonTurn(sessionManager) {
+    return currentOrigins.get(sessionManager)?.personTurn;
 }
 /** Whether the deciding turn counts as delegated-origin: a cross-account device started this turn or this run. */
 export function decidingTurnIsDelegated(sessionManager) {
-    return currentOrigins.get(sessionManager) === "delegated";
+    return currentOrigins.get(sessionManager)?.origin === "delegated";
 }
 //# sourceMappingURL=turn-origin.js.map

package/dist/modes/interactive/session-control-session-commands.js

@@ -24,7 +24,7 @@ export async function runSessionControlCommand(session, controls, command) {
             return success(id, type);
         }
         case "interrupt":
-            return success(id, type, await interruptRunningTurn(session, command.turnId, () => controls.interruptTurn()));
+            return success(id, type, await interruptRunningTurn(session, command.turnId, () => controls.interruptTurn(), command.background));
         default:
             return undefined;
     }

package/dist/modes/rpc/connection-handler.js

@@ -1166,7 +1166,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     const stopped = await interruptRunningTurn(session, undefined, () => {
                         ClientAdmissions.forSession(session).noteAbort(effectContext().by);
                         return session.stop();
-                    });
+                    }, command.background);
                     if (!stopped.interrupted)
                         await session.stop();
                     return success(id, "interrupt", stopped);
@@ -1174,7 +1174,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 return success(id, "interrupt", await interruptRunningTurn(session, command.turnId, () => {
                     ClientAdmissions.forSession(session).noteAbort(effectContext().by);
                     return session.abort();
-                }));
+                }, command.background));
             case "hold_input": {
                 const answer = runHoldInput(session, command, {
                     interactiveUser: hasRole(INTERACTIVE_USER_CAPABILITY),

package/dist/modes/rpc/effect-commands.d.ts

@@ -315,10 +315,7 @@ export declare function runSetThinkingLevel(ctx: EffectCommandContext, command:
     type: "response";
     command: "interrupt";
     success: true;
-    data: {
-        interrupted: boolean;
-        turnId?: string;
-    };
+    data: import("./session-control-actions-data.ts").InterruptOutcome;
 } | {
     id?: string;
     type: "response";

package/dist/modes/rpc/method-classes-schema-session.d.ts

@@ -177,6 +177,7 @@ export declare const SESSION_RECORD_SCHEMAS: {
     } & {
         readonly turnId: Type.TOptional<Type.TString>;
         readonly intent: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        readonly background: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
     }>;
     hold_input: Type.TObject<{
         id: Type.TOptional<Type.TString>;

package/dist/modes/rpc/method-classes-schema-session.js

@@ -65,7 +65,11 @@ const PROMPTING_SCHEMAS = {
         graceMs: OptNum,
         intent: Opt(literals("stop", "abort")),
     }),
-    interrupt: session("interrupt", { turnId: OptId, intent: Opt(literals("stop", "abort")) }),
+    interrupt: session("interrupt", {
+        turnId: OptId,
+        intent: Opt(literals("stop", "abort")),
+        background: Opt(literals("stop")),
+    }),
     hold_input: session("hold_input", {
         inputId: Id,
         revision: Num,

package/dist/modes/rpc/method-classes-schema.d.ts

@@ -650,6 +650,7 @@ export declare const RPC_INBOUND_SCHEMAS: {
     } & {
         readonly turnId: import("typebox").TOptional<import("typebox").TString>;
         readonly intent: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        readonly background: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
     }>;
     readonly hold_input: import("typebox").TObject<{
         id: import("typebox").TOptional<import("typebox").TString>;

package/dist/modes/rpc/pause-command-validation.js

@@ -12,6 +12,8 @@ export function validatePauseCommand(value) {
         if (value.intent !== "stop" && value.intent !== "abort")
             return 'intent must be "stop" or "abort".';
     }
+    if (value.type === "interrupt" && value.background !== undefined && value.background !== "stop")
+        return 'background must be "stop".';
     if (value.type === "resume_session") {
         if (value.expectedSeq !== undefined && !seq(value.expectedSeq))
             return "expectedSeq must be a non-negative integer.";

package/dist/modes/rpc/rpc-mutation-response-types.d.ts

@@ -8,6 +8,7 @@ import type { ServiceTier } from "../../core/extensions/builtin/service-tier.ts"
 import type { SessionControlAdmission } from "../../core/extensions/types.ts";
 import type { PermissionModeReply } from "../../core/permission-mode.ts";
 import type { ApiKeyVerification } from "../../core/verify-api-key.ts";
+import type { InterruptOutcome } from "./session-control-actions-data.ts";
 import type { ClientMessageAdmission } from "./client-admission-record.ts";
 import type { RpcProjectFile } from "./project-file-commands.ts";
 import type { RpcProjectSettings, RpcProjectTrust } from "./project-workspace-commands.ts";
@@ -99,10 +100,7 @@ export type RpcMutationResponse = {
     type: "response";
     command: "interrupt";
     success: true;
-    data: {
-        interrupted: boolean;
-        turnId?: string;
-    };
+    data: InterruptOutcome;
 } | {
     id?: string;
     type: "response";

package/dist/modes/rpc/rpc-session-command-types.d.ts

@@ -111,6 +111,7 @@ export type RpcSessionCommand = {
     type: "interrupt";
     turnId?: string;
     intent?: "stop" | "abort";
+    background?: "stop";
 }
 /** Human input held for a paused session, delivered when it resumes; idempotent by inputId (senpi#3811). */
  | {

package/dist/modes/rpc/session-control-actions-data.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSession } from "../../core/agent-session.ts";
+import type { RunBackgroundStopOutcome } from "../../core/run-background-jobs.ts";
 export declare function availableModelsData(session: AgentSession): Promise<{
     models: readonly object[];
 }>;
@@ -7,11 +8,14 @@ export declare function unsupportedThinkingLevel(level: unknown): string;
 export interface InterruptOutcome {
     readonly interrupted: boolean;
     readonly turnId?: string;
+    /** Present when the caller asked `background: "stop"`: the interrupted turn's background jobs it stopped. */
+    readonly background?: RunBackgroundStopOutcome;
 }
 /**
- * `interrupt { turnId? }`: stops the running turn and only that. An idle session answers
+ * `interrupt { turnId?, background? }`: stops the running turn and only that. An idle session answers
  * `interrupted: false`; so does a `turnId` naming a turn that is no longer the running one, which
- * then answers the running turn's id. `stop` resolves once the turn has stopped.
+ * then answers the running turn's id. `stop` resolves once the turn has stopped; with `background:
+ * "stop"` the background jobs that turn started are stopped after it, and the answer names them.
  */
-export declare function interruptRunningTurn(session: AgentSession, requestedTurnId: unknown, stop: () => Promise<void>): Promise<InterruptOutcome>;
+export declare function interruptRunningTurn(session: AgentSession, requestedTurnId: unknown, stop: () => Promise<void>, background?: unknown): Promise<InterruptOutcome>;
 //# sourceMappingURL=session-control-actions-data.d.ts.map

package/dist/modes/rpc/session-control-actions-data.js

@@ -30,18 +30,24 @@ export async function availableModelsData(session) {
 export function unsupportedThinkingLevel(level) {
     return `Thinking level ${String(level)} is not supported by the active model.`;
 }
+const NOTHING_STOPPED = { stopped: [], failed: [] };
 /**
- * `interrupt { turnId? }`: stops the running turn and only that. An idle session answers
+ * `interrupt { turnId?, background? }`: stops the running turn and only that. An idle session answers
  * `interrupted: false`; so does a `turnId` naming a turn that is no longer the running one, which
- * then answers the running turn's id. `stop` resolves once the turn has stopped.
+ * then answers the running turn's id. `stop` resolves once the turn has stopped; with `background:
+ * "stop"` the background jobs that turn started are stopped after it, and the answer names them.
  */
-export async function interruptRunningTurn(session, requestedTurnId, stop) {
+export async function interruptRunningTurn(session, requestedTurnId, stop, background) {
+    const stopsBackground = background === "stop";
+    const nothing = stopsBackground ? { background: NOTHING_STOPPED } : {};
     if (!session.isStreaming && session.retryAttempt === 0)
-        return { interrupted: false };
+        return { interrupted: false, ...nothing };
     const turnId = String(session.externalAdmission.turnEpoch);
     if (typeof requestedTurnId === "string" && requestedTurnId !== turnId)
-        return { interrupted: false, turnId };
+        return { interrupted: false, turnId, ...nothing };
     await stop();
-    return { interrupted: true, turnId };
+    if (!stopsBackground)
+        return { interrupted: true, turnId };
+    return { interrupted: true, turnId, background: await session.stopRunBackgroundJobs(turnId) };
 }
 //# sourceMappingURL=session-control-actions-data.js.map

package/dist/tools-core.d.ts

@@ -0,0 +1,14 @@
+export type { ExecRequest as MachineExecRequest, ExecResult as MachineExecResult, ExecShell as MachineExecShell, MachineOps, OpContext, } from "../vendor/senpi-machine-ops/index.js";
+export { type CoreBashToolOptions, createCoreBashTool, createCoreBashToolDefinition } from "./core/tools/bash-core.ts";
+export type { BashToolDetails, BashToolInput, BashToolOutput } from "./core/tools/bash-schema.ts";
+export { type CoreCodingToolsOptions, createCoreCodingTools } from "./core/tools/coding-tools-core.ts";
+export { type CoreEditToolOptions, createCoreEditTool, createCoreEditToolDefinition, type EditOperations, type EditToolDetails, type EditToolInput, } from "./core/tools/edit-core.ts";
+export type { FileMutationQueue, ToolPathCanonicalizer, ToolPathResolver } from "./core/tools/file-tool-host.ts";
+export { createMachineOutputSpill } from "./core/tools/machine-output-spill.ts";
+export type { FullOutput, OutputSpill, OutputSpillFactory } from "./core/tools/output-accumulator-core.ts";
+export { type CoreReadToolOptions, createCoreReadTool, createCoreReadToolDefinition, type ReadImageProcessor, type ReadOperations, type ReadToolDetails, type ReadToolInput, } from "./core/tools/read-core.ts";
+export { type BashOperations, createShellOperations, machineShellExecHost, type ShellExecHost, } from "./core/tools/shell-operations.ts";
+export { createToolMachine, type ToolMachine, type ToolPathPolicy } from "./core/tools/tool-machine.ts";
+export { type CoreWriteToolOptions, createCoreWriteTool, createCoreWriteToolDefinition, type WriteOperations, type WriteToolInput, } from "./core/tools/write-core.ts";
+export type { WriteToolDetails } from "./core/tools/write-result.ts";
+//# sourceMappingURL=tools-core.d.ts.map

package/dist/tools-core.js

@@ -0,0 +1,9 @@
+export { createCoreBashTool, createCoreBashToolDefinition } from "./core/tools/bash-core.js";
+export { createCoreCodingTools } from "./core/tools/coding-tools-core.js";
+export { createCoreEditTool, createCoreEditToolDefinition, } from "./core/tools/edit-core.js";
+export { createMachineOutputSpill } from "./core/tools/machine-output-spill.js";
+export { createCoreReadTool, createCoreReadToolDefinition, } from "./core/tools/read-core.js";
+export { createShellOperations, machineShellExecHost, } from "./core/tools/shell-operations.js";
+export { createToolMachine } from "./core/tools/tool-machine.js";
+export { createCoreWriteTool, createCoreWriteToolDefinition, } from "./core/tools/write-core.js";
+//# sourceMappingURL=tools-core.js.map

package/dist/utils/image-mime.d.ts

@@ -0,0 +1,4 @@
+/** Bytes from the start of a file that decide its image type. */
+export declare const IMAGE_TYPE_SNIFF_BYTES = 4100;
+export declare function detectSupportedImageMimeType(buffer: Uint8Array): string | null;
+//# sourceMappingURL=image-mime.d.ts.map