happy2 0.0.5 → 0.0.11

package/packages/happy2-server/dist/modules/agents/service.js

@@ -1,15 +1,71 @@
+import { rigEventMarkTrimmed } from "../agent/rigEventMarkTrimmed.js";
+import { rigEventGetCheckpoint } from "../agent/rigEventGetCheckpoint.js";
+import { rigEventCheckpoint } from "../agent/rigEventCheckpoint.js";
+import { agentUsernameIsAvailable } from "../agent/agentUsernameIsAvailable.js";
+import { agentTurnTakeNext } from "../agent/agentTurnTakeNext.js";
+import { agentTurnStreamReply } from "../agent/agentTurnStreamReply.js";
+import { agentTurnRenewLease } from "../agent/agentTurnRenewLease.js";
+import { agentTurnReleaseLeases } from "../agent/agentTurnReleaseLeases.js";
+import { agentTurnHasRunnable } from "../agent/agentTurnHasRunnable.js";
+import { agentTurnGetRunning } from "../agent/agentTurnGetRunning.js";
+import { agentTurnFail } from "../agent/agentTurnFail.js";
+import { agentTurnComplete } from "../agent/agentTurnComplete.js";
+import { agentTurnCheckpoint } from "../agent/agentTurnCheckpoint.js";
+import { agentSecretRecordRegistration } from "../agent/agentSecretRecordRegistration.js";
+import { agentSecretDetachFromChannel } from "../agent/agentSecretDetachFromChannel.js";
+import { agentSecretDetachFromAgent } from "../agent/agentSecretDetachFromAgent.js";
+import { agentSecretBindingList } from "../agent/agentSecretBindingList.js";
+import { agentSecretAuthorizeManagement } from "../agent/agentSecretAuthorizeManagement.js";
+import { agentSecretAttachToChannel } from "../agent/agentSecretAttachToChannel.js";
+import { agentSecretAttachToAgent } from "../agent/agentSecretAttachToAgent.js";
+import { agentSecretAssignmentList } from "../agent/agentSecretAssignmentList.js";
+import { agentSecretAssignmentDelete } from "../agent/agentSecretAssignmentDelete.js";
+import { agentRunAttach } from "../agent/agentRunAttach.js";
+import { agentImageTakeBuild } from "../agent/agentImageTakeBuild.js";
+import { agentImageSetDefault } from "../agent/agentImageSetDefault.js";
+import { agentImageRequestBuild } from "../agent/agentImageRequestBuild.js";
+import { agentImageRenewBuildLease } from "../agent/agentImageRenewBuildLease.js";
+import { agentImageReleaseBuildLeases } from "../agent/agentImageReleaseBuildLeases.js";
+import { agentImageRecordBuildOutput } from "../agent/agentImageRecordBuildOutput.js";
+import { agentImageListRequestedBuildIds } from "../agent/agentImageListRequestedBuildIds.js";
+import { agentImageList } from "../agent/agentImageList.js";
+import { agentImageGetReadyDefault } from "../agent/agentImageGetReadyDefault.js";
+import { agentImageGetChangeContext } from "../agent/agentImageGetChangeContext.js";
+import { agentImageGet } from "../agent/agentImageGet.js";
+import { agentImageEnsureDefinitions } from "../agent/agentImageEnsureDefinitions.js";
+import { agentImageCreate } from "../agent/agentImageCreate.js";
+import { agentImageCommitChange } from "../agent/agentImageCommitChange.js";
+import { agentEffortUpdate } from "../agent/agentEffortUpdate.js";
+import { agentEffortInitialize } from "../agent/agentEffortInitialize.js";
+import { agentEffortGetContext } from "../agent/agentEffortGetContext.js";
+import { agentEffortBindingList } from "../agent/agentEffortBindingList.js";
+import { agentCreate } from "../agent/agentCreate.js";
+import { agentConversationCreate } from "../agent/agentConversationCreate.js";
+import { agentDefaultRepair } from "../agent/agentDefaultRepair.js";
+import { agentChatListUnfinishedIds } from "../agent/agentChatListUnfinishedIds.js";
+import { agentChatGetContext } from "../agent/agentChatGetContext.js";
+import { agentChatBind } from "../agent/agentChatBind.js";
+import {} from "../drizzle.js";
+import { chatGetAccess } from "../chat/chatGetAccess.js";
 import { createId } from "@paralleldrive/cuid2";
 import { createHash } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { CollaborationError, } from "../collaboration/types.js";
+import { CollaborationError, } from "../chat/types.js";
 import { realtimeTopics } from "../realtime/index.js";
 import { isRetryableRigError, RigDaemonClient, } from "./daemon.js";
 import { BUILTIN_AGENT_IMAGES } from "./builtin-images.js";
+import { pluginFunctionResultAcquire } from "../plugin/pluginFunctionResultAcquire.js";
+import { pluginFunctionResultComplete } from "../plugin/pluginFunctionResultComplete.js";
+import { setupBaseImageCompleteBuild, setupBaseImageFailBuild, setupBaseImageGetStatus, setupBaseImageRetryBuild, setupBaseImageSelect, } from "../setup/index.js";
 const IGNORED_EVENT_CHECKPOINT_INTERVAL = 100;
 const EVENT_RETRY_INTERVAL_MS = 100;
+const PLUGIN_FUNCTION_LEASE_MS = 45_000;
+const PLUGIN_FUNCTION_WAIT_INTERVAL_MS = 1_000;
 const TYPING_TTL_MS = 30_000;
 const TYPING_RENEW_INTERVAL_MS = 20_000;
+const AGENT_ACTIVITY_TTL_MS = 10_000;
+const AGENT_ACTIVITY_RENEW_INTERVAL_MS = 3_000;
 const TRIM_EVENT_INTERVAL = 1_000;
 const TRIM_TIME_INTERVAL_MS = 24 * 60 * 60_000;
 const IMAGE_BUILD_LEASE_RENEW_INTERVAL_MS = 20_000;
@@ -24,53 +80,78 @@ const AGENT_CONTAINER_SECURITY = {
     readonlyRootFilesystem: true,
     sharedMemoryBytes: 1024 * 1024 * 1024,
     tmpfs: [
-        { target: "/tmp", mode: 0o1777 },
-        { target: "/run", mode: 0o755 },
-        { target: "/var/tmp", mode: 0o1777 },
-        { target: "/var/run", mode: 0o755 },
+        {
+            target: "/tmp",
+            mode: 0o1777,
+        },
+        {
+            target: "/run",
+            mode: 0o755,
+        },
+        {
+            target: "/var/tmp",
+            mode: 0o1777,
+        },
+        {
+            target: "/var/run",
+            mode: 0o755,
+        },
     ],
 };
 export class AgentService {
-    repository;
+    executor;
     pubsub;
     daemon;
-    docker;
+    sandboxRuntime;
     defaultCwd;
+    pluginFunctions;
     onError;
     workerId = createId();
     bindingCreations = new Map();
     imageBuilds = new Map();
+    imageBuildRetries = new Map();
+    imageMutations = new Map();
     pendingImageBuilds = new Set();
+    agentConfigurationMutations = new Map();
     secretMutations = new Map();
     activeImageBuilds = 0;
     drains = new Map();
     turnStreams = new Map();
     typingRenewals = new Map();
+    agentActivities = new Map();
     shutdown = new AbortController();
     queueTask;
     stopping = false;
-    constructor(repository, pubsub, daemon, docker, defaultCwd, onError = () => undefined) {
-        this.repository = repository;
+    constructor(executor, pubsub, daemon, sandboxRuntime, defaultCwd, pluginFunctions, onError = () => undefined) {
+        this.executor = executor;
         this.pubsub = pubsub;
         this.daemon = daemon;
-        this.docker = docker;
+        this.sandboxRuntime = sandboxRuntime;
         this.defaultCwd = defaultCwd;
+        this.pluginFunctions = pluginFunctions;
         this.onError = onError;
     }
     async createAgent(input) {
-        if (!(await this.repository.agentUsernameAvailable(input.username)))
+        if (!(await agentUsernameIsAvailable(this.executor, input.username)))
             throw new CollaborationError("conflict", "Agent username is already taken");
-        const image = await this.repository.getReadyDefaultAgentImage();
+        const image = await agentImageGetReadyDefault(this.executor);
         if (!image)
             throw new CollaborationError("conflict", "A ready default agent image must be configured before creating agents");
         const agentUserId = createId();
-        const sandbox = sandboxDirectories(this.defaultCwd, agentUserId, input.actorUserId);
+        const sandbox = sandboxDirectories(this.defaultCwd, agentUserId, "users", input.actorUserId);
         await Promise.all([
-            mkdir(sandbox.home, { recursive: true, mode: 0o700 }),
-            mkdir(sandbox.workspace, { recursive: true, mode: 0o700 }),
+            mkdir(sandbox.home, {
+                recursive: true,
+                mode: 0o700,
+            }),
+            mkdir(sandbox.workspace, {
+                recursive: true,
+                mode: 0o700,
+            }),
         ]);
         const containerName = agentContainerName();
-        await this.docker.createContainer({
+        const runtime = await this.sandboxRuntime();
+        await runtime.createSandbox({
             agentUserId,
             containerName,
             homeDirectory: sandbox.home,
@@ -80,10 +161,11 @@ export class AgentService {
             workspaceDirectory: sandbox.workspace,
         }, this.shutdown.signal);
         try {
-            const session = await this.daemon.createSession(sandbox.workspace, containerName, this.shutdown.signal);
-            return await this.repository.createAgent({
+            const session = await this.daemon.createSession(sandbox.workspace, containerName, undefined, this.shutdown.signal);
+            return await agentCreate(this.executor, {
                 ...input,
                 agentUserId,
+                agentEffort: session.effort,
                 containerName,
                 cwd: sandbox.workspace,
                 imageId: image.id,
@@ -91,12 +173,15 @@ export class AgentService {
             });
         }
         catch (error) {
-            await this.docker.removeContainer(containerName);
+            await runtime.removeSandbox(containerName);
             throw error;
         }
     }
+    async createAgentConversation(input) {
+        return agentConversationCreate(this.executor, input);
+    }
     async start() {
-        await this.repository.ensureAgentImageDefinitions(BUILTIN_AGENT_IMAGES.map((definition) => {
+        await agentImageEnsureDefinitions(this.executor, BUILTIN_AGENT_IMAGES.map((definition) => {
             const definitionHash = agentImageDefinitionHash(definition.dockerfile, definition.buildContext);
             return {
                 ...definition,
@@ -104,39 +189,103 @@ export class AgentService {
                 dockerTag: agentImageTag(definitionHash),
             };
         }));
-        for (const imageId of await this.repository.listRequestedAgentImageBuildIds())
+        const defaultAgentRepaired = await agentDefaultRepair(this.executor);
+        if (defaultAgentRepaired)
+            await this.publishAgentHint(defaultAgentRepaired);
+        for (const imageId of await agentImageListRequestedBuildIds(this.executor))
             this.queueImageBuild(imageId);
         await this.daemon.ensureGlobalEventQueue(this.shutdown.signal);
+        await this.reconcileFunctionPermissions();
+        await this.reconcileAgentEfforts();
         await this.reconcileSecretBindings();
         this.queueTask = this.trackGlobalEvents().catch((error) => {
             if (!this.shutdown.signal.aborted)
                 this.onError(error);
         });
-        const chatIds = await this.repository.listUnfinishedAgentChatIds();
+        const chatIds = await agentChatListUnfinishedIds(this.executor);
         for (const chatId of chatIds)
             this.startDrain(chatId);
     }
-    async prepareTurn(input) {
-        const context = await this.repository.getDirectAgentChatContext(input.actorUserId, input.chatId);
-        if (!context)
-            return undefined;
-        const binding = await this.ensureAgentBinding(input.actorUserId, input.chatId);
-        return binding
-            ? { agentUserId: context.agentUserId, sessionId: binding.sessionId }
-            : undefined;
+    async prepareTurns(input) {
+        const access = await chatGetAccess(this.executor, input.actorUserId, input.chatId, true);
+        if (!access)
+            throw new CollaborationError("not_found", "Chat was not found");
+        const requested = [...new Set(input.agentUserIds)];
+        let agentUserIds;
+        if (access.kind === "dm") {
+            const direct = await agentChatGetContext(this.executor, input.actorUserId, input.chatId);
+            if (!direct)
+                throw new CollaborationError("invalid", "This direct message has no executable agent");
+            if (requested.some((agentUserId) => agentUserId !== direct.agentUserId))
+                throw new CollaborationError("invalid", "A direct message can only address its member agent");
+            agentUserIds = [direct.agentUserId];
+        }
+        else {
+            agentUserIds = [
+                ...(access.defaultAgentUserId ? [access.defaultAgentUserId] : []),
+                ...requested,
+            ].filter((agentUserId, index, all) => all.indexOf(agentUserId) === index);
+            if (!agentUserIds.length)
+                throw new CollaborationError("conflict", "The channel needs a default agent before sending to agents");
+        }
+        const contexts = await Promise.all(agentUserIds.map((agentUserId) => agentChatGetContext(this.executor, input.actorUserId, input.chatId, agentUserId)));
+        if (contexts.some((context) => !context))
+            throw new CollaborationError("invalid", "Every addressed agent must be a ready executable chat member");
+        const turns = [];
+        for (const context of contexts) {
+            const binding = await this.ensureAgentBinding(input.actorUserId, input.chatId, context.agentUserId);
+            if (!binding)
+                throw new CollaborationError("conflict", "Agent conversation is not ready");
+            turns.push({
+                agentUserId: context.agentUserId,
+                sessionId: binding.sessionId,
+            });
+        }
+        return turns;
     }
     startTurn(chatId) {
         this.startDrain(chatId);
     }
+    async getAgentEffort(input) {
+        const context = await agentEffortGetContext(this.executor, input.actorUserId, input.agentUserId);
+        return this.agentEffortConfiguration(context);
+    }
+    async changeAgentEffort(input) {
+        return this.serializeAgentConfiguration(input.agentUserId, async () => {
+            const context = await agentEffortGetContext(this.executor, input.actorUserId, input.agentUserId, true);
+            const configuration = await this.agentEffortConfiguration(context);
+            if (!configuration.options.includes(input.effort))
+                throw new CollaborationError("invalid", `Effort must be one of: ${configuration.options.join(", ")}`);
+            const result = await agentEffortUpdate(this.executor, input);
+            try {
+                await Promise.all(context.sessionIds.map((sessionId) => this.reconcileSessionEffort(sessionId, input.effort)));
+            }
+            finally {
+                if (result.hint)
+                    await this.publishAgentHint(result.hint);
+            }
+            return {
+                agent: result.user,
+                agentUserId: input.agentUserId,
+                effort: input.effort,
+                options: configuration.options,
+                ...(result.hint
+                    ? {
+                        sync: result.hint,
+                    }
+                    : {}),
+            };
+        });
+    }
     listAgentImages(actorUserId) {
-        return this.repository.listAgentImages(actorUserId);
+        return agentImageList(this.executor, actorUserId);
     }
     getAgentImage(actorUserId, imageId) {
-        return this.repository.getAgentImage(actorUserId, imageId);
+        return agentImageGet(this.executor, actorUserId, imageId);
     }
     async createAgentImage(input) {
         const definitionHash = agentImageDefinitionHash(input.dockerfile);
-        const result = await this.repository.createAgentImage({
+        const result = await agentImageCreate(this.executor, {
             ...input,
             definitionHash,
             dockerTag: agentImageTag(definitionHash),
@@ -146,18 +295,129 @@ export class AgentService {
         return result.image;
     }
     async requestAgentImageBuild(input) {
-        const result = await this.repository.requestAgentImageBuild(input);
+        const result = await agentImageRequestBuild(this.executor, input);
         await this.publishAgentImageHint(result.hint);
         this.queueImageBuild(result.image.id);
         return result.image;
     }
     async setDefaultAgentImage(input) {
-        const result = await this.repository.setDefaultAgentImage(input);
+        const result = await agentImageSetDefault(this.executor, input);
         await this.publishAgentImageHint(result.hint);
         return result.image;
     }
+    getSetupBaseImages(actorUserId) {
+        return setupBaseImageGetStatus(this.executor, actorUserId);
+    }
+    async selectSetupBaseImage(input) {
+        const selection = input.selection.kind === "builtin"
+            ? input.selection
+            : (() => {
+                const definitionHash = agentImageDefinitionHash(input.selection.dockerfile);
+                return {
+                    ...input.selection,
+                    definitionHash,
+                    dockerTag: agentImageTag(definitionHash),
+                };
+            })();
+        const result = await setupBaseImageSelect(this.executor, input.actorUserId, selection);
+        if (result.hint)
+            await this.publishAgentImageHint(result.hint);
+        if (result.queueBuild)
+            this.queueImageBuild(result.imageId);
+        return result;
+    }
+    async retrySetupBaseImage(actorUserId) {
+        const result = await setupBaseImageRetryBuild(this.executor, actorUserId);
+        await this.publishAgentImageHint(result.hint);
+        this.queueImageBuild(result.imageId);
+        return result;
+    }
+    async changeAgentImage(input) {
+        const previous = this.imageMutations.get(input.agentUserId) ?? Promise.resolve();
+        const mutation = previous
+            .catch(() => undefined)
+            .then(() => this.changeAgentImageMutation(input));
+        this.imageMutations.set(input.agentUserId, mutation);
+        try {
+            return await mutation;
+        }
+        finally {
+            if (this.imageMutations.get(input.agentUserId) === mutation)
+                this.imageMutations.delete(input.agentUserId);
+        }
+    }
+    async changeAgentImageMutation(input) {
+        const context = await agentImageGetChangeContext(this.executor, input);
+        if (context.currentImageId === context.image.id)
+            return {
+                user: context.user,
+            };
+        const replacements = [];
+        let committed = false;
+        const runtime = await this.sandboxRuntime();
+        try {
+            for (const binding of context.bindings) {
+                const containerName = agentContainerName();
+                await runtime.createSandbox({
+                    agentUserId: input.agentUserId,
+                    containerName,
+                    homeDirectory: join(binding.cwd, "..", "home"),
+                    imageId: context.image.id,
+                    imageTag: context.image.dockerTag,
+                    security: AGENT_CONTAINER_SECURITY,
+                    workspaceDirectory: binding.cwd,
+                }, this.shutdown.signal);
+                try {
+                    const session = await this.daemon.createSession(binding.cwd, containerName, context.user.agentEffort, this.shutdown.signal);
+                    replacements.push({
+                        chatId: binding.chatId,
+                        containerName,
+                        cwd: binding.cwd,
+                        previousContainerName: binding.containerName,
+                        previousSessionId: binding.sessionId,
+                        sessionId: session.id,
+                    });
+                }
+                catch (error) {
+                    await runtime.removeSandbox(containerName);
+                    throw error;
+                }
+            }
+            const result = await agentImageCommitChange(this.executor, {
+                ...input,
+                expectedImageId: context.currentImageId,
+                replacements,
+            });
+            if (!result.sync) {
+                await Promise.all(replacements.map(({ containerName }) => runtime.removeSandbox(containerName)));
+                return {
+                    user: result.user,
+                };
+            }
+            committed = true;
+            await Promise.allSettled(replacements.map(({ previousContainerName }) => runtime.removeSandbox(previousContainerName))).then((results) => {
+                for (const result of results)
+                    if (result.status === "rejected")
+                        this.onError(result.reason);
+            });
+            await this.reconcileSecretBindings({
+                agentUserId: input.agentUserId,
+            }).catch(this.onError);
+            await this.publishAgentHint(result.sync);
+            return result;
+        }
+        catch (error) {
+            if (!committed)
+                await Promise.allSettled(replacements.map(({ containerName }) => runtime.removeSandbox(containerName))).then((results) => {
+                    for (const result of results)
+                        if (result.status === "rejected")
+                            this.onError(result.reason);
+                });
+            throw error;
+        }
+    }
     async listAgentSecrets(actorUserId) {
-        const assignments = await this.repository.listAgentSecretAssignments(actorUserId);
+        const assignments = await agentSecretAssignmentList(this.executor, actorUserId);
         const assignmentById = new Map(assignments.map((assignment) => [assignment.secretId, assignment]));
         const secrets = await this.daemon.listSecrets(this.shutdown.signal);
         return {
@@ -175,18 +435,18 @@ export class AgentService {
         return this.serializeAgentSecret(input.id, () => this.createAgentSecretMutation(input));
     }
     async createAgentSecretMutation(input) {
-        await this.repository.authorizeAgentSecretManagement(input.actorUserId);
+        await agentSecretAuthorizeManagement(this.executor, input.actorUserId);
         const secret = await this.daemon.registerSecret({
             id: input.id,
             description: input.description,
             environment: input.environment,
         }, this.shutdown.signal);
-        const sync = await this.repository.recordAgentSecretRegistration({
+        const sync = await agentSecretRecordRegistration(this.executor, {
             actorUserId: input.actorUserId,
             secretId: input.id,
         });
         await this.publishAgentHint(sync);
-        const assignments = await this.repository.listAgentSecretAssignments(input.actorUserId);
+        const assignments = await agentSecretAssignmentList(this.executor, input.actorUserId);
         const assignment = assignments.find((candidate) => candidate.secretId === secret.id);
         return {
             secret: {
@@ -201,8 +461,8 @@ export class AgentService {
         return this.serializeAgentSecret(input.secretId, () => this.deleteAgentSecretMutation(input));
     }
     async deleteAgentSecretMutation(input) {
-        await this.repository.authorizeAgentSecretManagement(input.actorUserId);
-        const sync = await this.repository.deleteAgentSecretAssignments(input);
+        await agentSecretAuthorizeManagement(this.executor, input.actorUserId);
+        const sync = await agentSecretAssignmentDelete(this.executor, input);
         let removed;
         try {
             removed = await this.daemon.unregisterSecret(input.secretId, this.shutdown.signal);
@@ -212,20 +472,29 @@ export class AgentService {
             throw error;
         }
         await this.publishAgentHint(sync);
-        return { removed, sync };
+        return {
+            removed,
+            sync,
+        };
     }
     async attachAgentSecretToAgent(input) {
         return this.serializeAgentSecret(input.secretId, () => this.attachAgentSecretToAgentMutation(input));
     }
     async attachAgentSecretToAgentMutation(input) {
         await this.requireAgentSecret(input.actorUserId, input.secretId);
-        const sync = await this.repository.attachAgentSecretToAgent(input);
-        await this.reconcileSecretBindings({ agentUserId: input.agentUserId });
+        const sync = await agentSecretAttachToAgent(this.executor, input);
+        await this.reconcileSecretBindings({
+            agentUserId: input.agentUserId,
+        });
         if (sync)
             await this.publishAgentHint(sync);
         return {
             secret: await this.agentSecret(input.actorUserId, input.secretId),
-            ...(sync ? { sync } : {}),
+            ...(sync
+                ? {
+                    sync,
+                }
+                : {}),
         };
     }
     async detachAgentSecretFromAgent(input) {
@@ -233,13 +502,19 @@ export class AgentService {
     }
     async detachAgentSecretFromAgentMutation(input) {
         await this.requireAgentSecret(input.actorUserId, input.secretId);
-        const sync = await this.repository.detachAgentSecretFromAgent(input);
-        await this.reconcileSecretBindings({ agentUserId: input.agentUserId });
+        const sync = await agentSecretDetachFromAgent(this.executor, input);
+        await this.reconcileSecretBindings({
+            agentUserId: input.agentUserId,
+        });
         if (sync)
             await this.publishAgentHint(sync);
         return {
             secret: await this.agentSecret(input.actorUserId, input.secretId),
-            ...(sync ? { sync } : {}),
+            ...(sync
+                ? {
+                    sync,
+                }
+                : {}),
         };
     }
     async attachAgentSecretToChannel(input) {
@@ -247,13 +522,19 @@ export class AgentService {
     }
     async attachAgentSecretToChannelMutation(input) {
         await this.requireAgentSecret(input.actorUserId, input.secretId);
-        const sync = await this.repository.attachAgentSecretToChannel(input);
-        await this.reconcileSecretBindings({ chatId: input.channelId });
+        const sync = await agentSecretAttachToChannel(this.executor, input);
+        await this.reconcileSecretBindings({
+            chatId: input.channelId,
+        });
         if (sync)
             await this.publishAgentHint(sync);
         return {
             secret: await this.agentSecret(input.actorUserId, input.secretId),
-            ...(sync ? { sync } : {}),
+            ...(sync
+                ? {
+                    sync,
+                }
+                : {}),
         };
     }
     async detachAgentSecretFromChannel(input) {
@@ -261,15 +542,33 @@ export class AgentService {
     }
     async detachAgentSecretFromChannelMutation(input) {
         await this.requireAgentSecret(input.actorUserId, input.secretId);
-        const sync = await this.repository.detachAgentSecretFromChannel(input);
-        await this.reconcileSecretBindings({ chatId: input.channelId });
+        const sync = await agentSecretDetachFromChannel(this.executor, input);
+        await this.reconcileSecretBindings({
+            chatId: input.channelId,
+        });
         if (sync)
             await this.publishAgentHint(sync);
         return {
             secret: await this.agentSecret(input.actorUserId, input.secretId),
-            ...(sync ? { sync } : {}),
+            ...(sync
+                ? {
+                    sync,
+                }
+                : {}),
         };
     }
+    async serializeAgentConfiguration(agentUserId, action) {
+        const previous = this.agentConfigurationMutations.get(agentUserId) ?? Promise.resolve();
+        const mutation = previous.catch(() => undefined).then(action);
+        this.agentConfigurationMutations.set(agentUserId, mutation);
+        try {
+            return await mutation;
+        }
+        finally {
+            if (this.agentConfigurationMutations.get(agentUserId) === mutation)
+                this.agentConfigurationMutations.delete(agentUserId);
+        }
+    }
     async serializeAgentSecret(secretId, action) {
         const previous = this.secretMutations.get(secretId) ?? Promise.resolve();
         const mutation = previous.catch(() => undefined).then(action);
@@ -282,13 +581,15 @@ export class AgentService {
                 this.secretMutations.delete(secretId);
         }
     }
-    async ensureAgentBinding(actorUserId, chatId) {
+    async ensureAgentBinding(actorUserId, chatId, agentUserId) {
         if (this.stopping)
             return undefined;
-        const context = await this.repository.getDirectAgentChatContext(actorUserId, chatId);
+        const context = await agentChatGetContext(this.executor, actorUserId, chatId, agentUserId);
         if (!context)
             return undefined;
         if (context.binding) {
+            if (context.agentEffort)
+                await this.reconcileSessionEffort(context.binding.sessionId, context.agentEffort);
             await this.reconcileSecretBindings({
                 agentUserId: context.agentUserId,
                 chatId,
@@ -299,46 +600,61 @@ export class AgentService {
         const pending = this.bindingCreations.get(key);
         if (pending)
             return pending;
-        const creation = (async () => {
-            const sandbox = sandboxDirectories(this.defaultCwd, context.agentUserId, context.privateUserId);
+        const creation = this.serializeAgentConfiguration(context.agentUserId, async () => {
+            const latest = await agentChatGetContext(this.executor, actorUserId, chatId, agentUserId);
+            if (!latest)
+                throw new CollaborationError("not_found", "Agent conversation was not found");
+            if (latest.binding) {
+                if (latest.agentEffort)
+                    await this.reconcileSessionEffort(latest.binding.sessionId, latest.agentEffort);
+                return latest.binding;
+            }
+            const sandbox = sandboxDirectories(this.defaultCwd, latest.agentUserId, latest.sandboxScope.kind, latest.sandboxScope.id, latest.sandboxScope.conversationId);
             await Promise.all([
-                mkdir(sandbox.home, { recursive: true, mode: 0o700 }),
-                mkdir(sandbox.workspace, { recursive: true, mode: 0o700 }),
+                mkdir(sandbox.home, {
+                    recursive: true,
+                    mode: 0o700,
+                }),
+                mkdir(sandbox.workspace, {
+                    recursive: true,
+                    mode: 0o700,
+                }),
             ]);
             const containerName = agentContainerName();
-            await this.docker.createContainer({
-                agentUserId: context.agentUserId,
+            const runtime = await this.sandboxRuntime();
+            await runtime.createSandbox({
+                agentUserId: latest.agentUserId,
                 containerName,
                 homeDirectory: sandbox.home,
-                imageId: context.image.id,
-                imageTag: context.image.dockerTag,
+                imageId: latest.image.id,
+                imageTag: latest.image.dockerTag,
                 security: AGENT_CONTAINER_SECURITY,
                 workspaceDirectory: sandbox.workspace,
             }, this.shutdown.signal);
             try {
-                const session = await this.daemon.createSession(sandbox.workspace, containerName, this.shutdown.signal);
-                const binding = await this.repository.bindAgentChat({
+                const session = await this.daemon.createSession(sandbox.workspace, containerName, latest.agentEffort, this.shutdown.signal);
+                const binding = await agentChatBind(this.executor, {
                     actorUserId,
-                    agentUserId: context.agentUserId,
+                    agentUserId: latest.agentUserId,
                     chatId,
                     containerName,
                     cwd: sandbox.workspace,
-                    imageId: context.image.id,
+                    imageId: latest.image.id,
                     sessionId: session.id,
                 });
                 if (binding.containerName !== containerName)
-                    await this.docker.removeContainer(containerName);
+                    await runtime.removeSandbox(containerName);
                 await this.reconcileSecretBindings({
-                    agentUserId: context.agentUserId,
+                    agentUserId: latest.agentUserId,
                     chatId,
                 });
                 return binding;
             }
             catch (error) {
-                await this.docker.removeContainer(containerName);
+                await runtime.removeSandbox(containerName);
                 throw error;
             }
-        })();
+        });
         this.bindingCreations.set(key, creation);
         try {
             return await creation;
@@ -351,6 +667,9 @@ export class AgentService {
         this.stopping = true;
         this.shutdown.abort();
         this.pendingImageBuilds.clear();
+        for (const timer of this.imageBuildRetries.values())
+            clearTimeout(timer);
+        this.imageBuildRetries.clear();
         for (const stream of this.turnStreams.values()) {
             stream.controller.abort();
             stream.output.close();
@@ -358,9 +677,13 @@ export class AgentService {
         for (const renewal of this.typingRenewals.values())
             clearInterval(renewal.timer);
         this.typingRenewals.clear();
+        for (const activity of this.agentActivities.values())
+            clearInterval(activity.timer);
+        this.agentActivities.clear();
         await Promise.race([
             Promise.allSettled([
                 ...this.bindingCreations.values(),
+                ...this.imageMutations.values(),
                 ...this.drains.values(),
                 ...this.imageBuilds.values(),
                 ...Array.from(this.turnStreams.values(), (stream) => stream.task),
@@ -369,8 +692,8 @@ export class AgentService {
             shutdownDeadline(),
         ]);
         await Promise.all([
-            this.repository.releaseAgentTurnLeases(this.workerId),
-            this.repository.releaseAgentImageBuildLeases(this.workerId),
+            agentTurnReleaseLeases(this.executor, this.workerId),
+            agentImageReleaseBuildLeases(this.executor, this.workerId),
         ]);
     }
     queueImageBuild(imageId) {
@@ -400,18 +723,26 @@ export class AgentService {
         this.imageBuilds.set(imageId, task);
     }
     async buildImage(imageId) {
-        const claimed = await this.repository.takeAgentImageBuild(imageId, this.workerId);
+        const claimed = await agentImageTakeBuild(this.executor, imageId, this.workerId);
         if (!claimed)
             return;
+        if ("retryAt" in claimed) {
+            this.scheduleImageBuildRetry(imageId, claimed.retryAt);
+            return;
+        }
         const build = claimed.build;
         await this.publishAgentImageHint(claimed.hint);
         const output = new AgentImageBuildOutput(async ({ lastBuildLogLine, logChunk, progress }) => {
-            const hint = await this.repository.recordAgentImageBuildOutput({
+            const hint = await agentImageRecordBuildOutput(this.executor, {
                 imageId,
                 logChunk,
                 progress,
                 workerId: this.workerId,
-                ...(lastBuildLogLine === undefined ? {} : { lastBuildLogLine }),
+                ...(lastBuildLogLine === undefined
+                    ? {}
+                    : {
+                        lastBuildLogLine,
+                    }),
             });
             if (hint)
                 await this.publishAgentImageHint(hint);
@@ -423,8 +754,7 @@ export class AgentService {
             if (renewalRunning || this.shutdown.signal.aborted)
                 return;
             renewalRunning = true;
-            void this.repository
-                .renewAgentImageBuildLease(imageId, this.workerId)
+            void agentImageRenewBuildLease(this.executor, imageId, this.workerId)
                 .catch(this.onError)
                 .finally(() => {
                 renewalRunning = false;
@@ -432,8 +762,13 @@ export class AgentService {
         }, IMAGE_BUILD_LEASE_RENEW_INTERVAL_MS);
         renewal.unref();
         try {
-            const result = await this.docker.buildImage({
-                ...(build.buildContext ? { buildContext: build.buildContext } : {}),
+            const runtime = await this.sandboxRuntime();
+            const result = await runtime.buildImage({
+                ...(build.buildContext
+                    ? {
+                        buildContext: build.buildContext,
+                    }
+                    : {}),
                 dockerfile: build.dockerfile,
                 tag: build.dockerTag,
             }, {
@@ -441,13 +776,14 @@ export class AgentService {
                 signal: this.shutdown.signal,
             });
             await output.finish();
-            const completed = await this.repository.completeAgentImageBuild({
+            const completed = await setupBaseImageCompleteBuild(this.executor, {
                 dockerImageId: result.imageId,
                 imageId,
                 workerId: this.workerId,
             });
-            if (completed)
+            if (completed) {
                 await this.publishAgentImageHint(completed);
+            }
             else if (!this.shutdown.signal.aborted)
                 throw new Error(`Agent image ${imageId} build lease was lost before completion.`);
         }
@@ -462,7 +798,7 @@ export class AgentService {
                 progress: output.currentProgress,
             });
             await output.finish().catch(this.onError);
-            const failed = await this.repository.failAgentImageBuild({
+            const failed = await setupBaseImageFailBuild(this.executor, {
                 error: message,
                 imageId,
                 workerId: this.workerId,
@@ -475,19 +811,79 @@ export class AgentService {
             output.close();
         }
     }
+    scheduleImageBuildRetry(imageId, retryAt) {
+        if (this.stopping || this.imageBuildRetries.has(imageId))
+            return;
+        const delay = Math.max(Date.parse(retryAt) - Date.now(), 0) + 10;
+        const timer = setTimeout(() => {
+            this.imageBuildRetries.delete(imageId);
+            this.queueImageBuild(imageId);
+        }, delay);
+        timer.unref();
+        this.imageBuildRetries.set(imageId, timer);
+    }
     async publishAgentImageHint(hint) {
         await this.publishAgentHint(hint);
     }
     async publishAgentHint(hint) {
         try {
-            await this.pubsub.publish(realtimeTopics.server, { type: "sync", ...hint });
+            await this.pubsub.publish(realtimeTopics.server, {
+                type: "sync",
+                ...hint,
+            });
         }
         catch (error) {
             this.onError(error);
         }
     }
+    async agentEffortConfiguration(context) {
+        if (!context.sessionIds.length)
+            throw new CollaborationError("conflict", "Agent has no active Rig session");
+        const configurations = await Promise.all(context.sessionIds.map((sessionId) => this.daemon.effortConfiguration(sessionId, this.shutdown.signal)));
+        const options = configurations[0].options.filter((option) => configurations.every((configuration) => configuration.options.includes(option)));
+        const effort = context.effort ?? configurations[0].effort;
+        return {
+            agentUserId: context.agentUserId,
+            effort,
+            options,
+        };
+    }
+    async reconcileAgentEfforts() {
+        const bindings = await agentEffortBindingList(this.executor);
+        const byAgent = new Map();
+        for (const binding of bindings) {
+            const group = byAgent.get(binding.agentUserId) ?? [];
+            group.push(binding);
+            byAgent.set(binding.agentUserId, group);
+        }
+        for (const [agentUserId, agentBindings] of byAgent) {
+            const configured = agentBindings.find((binding) => binding.effort)?.effort;
+            const effort = configured ??
+                (await this.daemon.effortConfiguration(agentBindings[0].sessionId, this.shutdown.signal)).effort;
+            if (!configured) {
+                const hint = await agentEffortInitialize(this.executor, agentUserId, effort);
+                if (hint)
+                    await this.publishAgentHint(hint);
+            }
+            await Promise.all(agentBindings.map((binding) => this.reconcileSessionEffort(binding.sessionId, effort)));
+        }
+    }
+    async reconcileFunctionPermissions() {
+        const sessionIds = [
+            ...new Set((await agentEffortBindingList(this.executor)).map(({ sessionId }) => sessionId)),
+        ];
+        await Promise.all(sessionIds.map((sessionId) => this.daemon.ensureFunctionPermission(sessionId, this.shutdown.signal)));
+    }
+    async reconcileSessionEffort(sessionId, effort) {
+        const current = await this.daemon.effortConfiguration(sessionId, this.shutdown.signal);
+        if (current.effort === effort)
+            return;
+        if (!current.options.includes(effort))
+            throw new CollaborationError("conflict", `Rig session does not support the agent's '${effort}' effort setting`);
+        await this.daemon.changeEffort(sessionId, effort, this.shutdown.signal);
+    }
     async requireAgentSecret(actorUserId, secretId) {
-        await this.repository.authorizeAgentSecretManagement(actorUserId);
+        await agentSecretAuthorizeManagement(this.executor, actorUserId);
         const secrets = await this.daemon.listSecrets(this.shutdown.signal);
         if (!secrets.some((secret) => secret.id === secretId))
             throw new CollaborationError("not_found", "Agent secret was not found");
@@ -500,11 +896,11 @@ export class AgentService {
         return secret;
     }
     async reconcileSecretBindings(input = {}) {
-        const bindings = await this.repository.listAgentSecretBindings(input);
+        const bindings = await agentSecretBindingList(this.executor, input);
         await Promise.all(bindings.map((binding) => this.daemon.reconcileSessionSecrets(binding.sessionId, async () => {
             const [secrets, latestBindings] = await Promise.all([
                 this.daemon.listSecrets(this.shutdown.signal),
-                this.repository.listAgentSecretBindings({
+                agentSecretBindingList(this.executor, {
                     agentUserId: binding.agentUserId,
                     chatId: binding.chatId,
                 }),
@@ -519,7 +915,7 @@ export class AgentService {
         }, this.shutdown.signal)));
     }
     async trackGlobalEvents() {
-        let checkpoint = await this.repository.getRigEventCheckpoint();
+        let checkpoint = await rigEventGetCheckpoint(this.executor);
         let reportedFailure = false;
         while (!this.stopping) {
             try {
@@ -527,7 +923,7 @@ export class AgentService {
                 await this.daemon.watchGlobalEvents(checkpoint.cursor, async (entry) => {
                     if (isRelevantRigEvent(entry.event)) {
                         await this.applyGlobalEvent(entry);
-                        checkpoint = await this.repository.checkpointRigEvent(entry.cursor, ignoredSinceCheckpoint + 1);
+                        checkpoint = await rigEventCheckpoint(this.executor, entry.cursor, ignoredSinceCheckpoint + 1);
                         ignoredSinceCheckpoint = 0;
                         checkpoint = await this.trimGlobalEventsIfDue(checkpoint);
                         return;
@@ -535,7 +931,7 @@ export class AgentService {
                     ignoredSinceCheckpoint += 1;
                     if (ignoredSinceCheckpoint < IGNORED_EVENT_CHECKPOINT_INTERVAL)
                         return;
-                    checkpoint = await this.repository.checkpointRigEvent(entry.cursor, ignoredSinceCheckpoint);
+                    checkpoint = await rigEventCheckpoint(this.executor, entry.cursor, ignoredSinceCheckpoint);
                     ignoredSinceCheckpoint = 0;
                     checkpoint = await this.trimGlobalEventsIfDue(checkpoint);
                 }, this.shutdown.signal);
@@ -559,15 +955,21 @@ export class AgentService {
         if (!trimDueByCount && !trimDueByTime)
             return checkpoint;
         await this.daemon.trimGlobalEvents(checkpoint.cursor, this.shutdown.signal);
-        return this.repository.markRigEventsTrimmed(checkpoint.cursor);
+        return rigEventMarkTrimmed(this.executor, checkpoint.cursor);
     }
     async applyGlobalEvent(entry) {
         const event = entry.event;
+        if (event.type === "external_tool_call_requested" && event.data.call) {
+            const call = event.data.call;
+            const result = await this.executePluginFunctionCall(event.sessionId, call.id, call.definition.name, call.arguments);
+            await this.daemon.resolveExternalToolCall(event.sessionId, call.id, result, this.shutdown.signal);
+            return;
+        }
         const runId = event.data.runId;
         if (event.type === "message_submitted" && runId) {
             const text = messageText(event.data.message);
             if (text)
-                await this.repository.attachAgentRun({
+                await agentRunAttach(this.executor, {
                     runId,
                     sessionId: event.sessionId,
                     text,
@@ -576,13 +978,13 @@ export class AgentService {
         }
         if (!runId || (event.type !== "run_finished" && event.type !== "run_error"))
             return;
-        let turn = await this.repository.getRunningAgentTurn(event.sessionId, runId);
+        let turn = await agentTurnGetRunning(this.executor, event.sessionId, runId);
         if (!turn)
             return;
         if (turn.runId === undefined || turn.baselineMessageCount === undefined) {
             const baselineMessageCount = turn.baselineMessageCount ??
                 (await this.daemon.submittedTurnBaseline(turn.sessionId, turn.text, this.shutdown.signal));
-            const checkpointed = await this.repository.checkpointAgentTurn({
+            const checkpointed = await agentTurnCheckpoint(this.executor, {
                 agentUserId: turn.agentUserId,
                 baselineMessageCount,
                 runId,
@@ -591,7 +993,11 @@ export class AgentService {
             });
             if (!checkpointed)
                 return;
-            turn = { ...turn, baselineMessageCount, runId };
+            turn = {
+                ...turn,
+                baselineMessageCount,
+                runId,
+            };
         }
         if (event.type === "run_error") {
             await this.failTurn(turn, event.data.errorMessage ?? "Rig run failed.");
@@ -608,6 +1014,41 @@ export class AgentService {
         }
         throw new Error(`Rig run ${runId} finished before its session snapshot was complete.`);
     }
+    async executePluginFunctionCall(sessionId, callId, functionName, args) {
+        const leaseToken = createId();
+        for (;;) {
+            this.shutdown.signal.throwIfAborted();
+            const now = Date.now();
+            const claim = await pluginFunctionResultAcquire(this.executor, {
+                callId,
+                leaseExpiresAt: now + PLUGIN_FUNCTION_LEASE_MS,
+                leaseToken,
+                now,
+                sessionId,
+            });
+            if (claim.kind === "replay")
+                return claim.result;
+            if (claim.kind === "in_progress") {
+                await delay(Math.min(Math.max(claim.retryAt - now, EVENT_RETRY_INTERVAL_MS), PLUGIN_FUNCTION_WAIT_INTERVAL_MS), this.shutdown.signal);
+                continue;
+            }
+            const result = this.pluginFunctions
+                ? await this.pluginFunctions.callFunction(functionName, args, this.shutdown.signal)
+                : {
+                    status: "failed",
+                    error: {
+                        code: "plugin_functions_unavailable",
+                        message: "Plugin functions are unavailable on this server",
+                    },
+                };
+            return pluginFunctionResultComplete(this.executor, {
+                callId,
+                leaseToken,
+                result,
+                sessionId,
+            });
+        }
+    }
     startDrain(chatId) {
         if (this.stopping || this.drains.has(chatId))
             return;
@@ -618,7 +1059,7 @@ export class AgentService {
             if (this.stopping)
                 return;
             try {
-                if (await this.repository.hasRunnableAgentTurn(chatId))
+                if (await agentTurnHasRunnable(this.executor, chatId))
                     this.startDrain(chatId);
             }
             catch (error) {
@@ -631,15 +1072,14 @@ export class AgentService {
         for (;;) {
             if (this.stopping)
                 return;
-            const input = await this.repository
-                .takeNextAgentTurn(chatId, this.workerId)
-                .catch((error) => {
+            const input = await agentTurnTakeNext(this.executor, chatId, this.workerId).catch((error) => {
                 this.onError(error);
                 return undefined;
             });
             if (!input)
                 return;
             try {
+                await this.startAgentActivity(input);
                 await this.startTyping(input);
                 const submission = await this.ensureTurnSubmitted(input);
                 const inspection = submission.inspection;
@@ -680,7 +1120,7 @@ export class AgentService {
                 baselineMessageCount = checkpoint.messageCount;
                 lastSessionEventId = checkpoint.lastEventId;
             }
-            const checkpointed = await this.repository.checkpointAgentTurn({
+            const checkpointed = await agentTurnCheckpoint(this.executor, {
                 agentUserId: input.agentUserId,
                 baselineMessageCount,
                 lastSessionEventId,
@@ -695,13 +1135,22 @@ export class AgentService {
         if (runId || existing.kind !== "not_submitted")
             return {
                 inspection: existing,
-                ...(lastSessionEventId === undefined ? {} : { lastSessionEventId }),
-                ...(runId === undefined ? {} : { runId }),
+                ...(lastSessionEventId === undefined
+                    ? {}
+                    : {
+                        lastSessionEventId,
+                    }),
+                ...(runId === undefined
+                    ? {}
+                    : {
+                        runId,
+                    }),
             };
+        const externalTools = (await this.pluginFunctions?.listFunctions(this.shutdown.signal)) ?? [];
         for (;;) {
             let submitted;
             try {
-                submitted = await this.daemon.submitTurn(input.sessionId, input.text, this.shutdown.signal);
+                submitted = await this.daemon.submitTurn(input.sessionId, input.text, externalTools, this.shutdown.signal);
             }
             catch (error) {
                 if (this.shutdown.signal.aborted)
@@ -710,8 +1159,16 @@ export class AgentService {
                 if (recovered.kind !== "not_submitted")
                     return {
                         inspection: recovered,
-                        ...(lastSessionEventId === undefined ? {} : { lastSessionEventId }),
-                        ...(runId === undefined ? {} : { runId }),
+                        ...(lastSessionEventId === undefined
+                            ? {}
+                            : {
+                                lastSessionEventId,
+                            }),
+                        ...(runId === undefined
+                            ? {}
+                            : {
+                                runId,
+                            }),
                     };
                 if (!isRetryableRigError(error))
                     throw error;
@@ -720,7 +1177,7 @@ export class AgentService {
             }
             runId = submitted.runId;
             lastSessionEventId = submitted.eventId;
-            const checkpointed = await this.repository.checkpointAgentTurn({
+            const checkpointed = await agentTurnCheckpoint(this.executor, {
                 agentUserId: input.agentUserId,
                 baselineMessageCount,
                 lastSessionEventId,
@@ -731,7 +1188,9 @@ export class AgentService {
             if (!checkpointed)
                 throw new AgentTurnStreamStopped(`Agent turn ${input.userMessageId} lease was lost after submission.`);
             return {
-                inspection: { kind: "running" },
+                inspection: {
+                    kind: "running",
+                },
                 lastSessionEventId,
                 runId,
             };
@@ -753,7 +1212,7 @@ export class AgentService {
             }
         };
         const output = new AgentReplyStreamOutput(submission.lastSessionEventId, async (update) => {
-            const result = await this.repository.streamAgentTurnReply({
+            const result = await agentTurnStreamReply(this.executor, {
                 agentUserId: input.agentUserId,
                 actorUserId: input.actorUserId,
                 eventId: update.eventId,
@@ -791,11 +1250,16 @@ export class AgentService {
                 }
                 catch (error) {
                     this.clearTypingRenewal(input.chatId, input.userMessageId);
+                    this.clearAgentActivity(input.userMessageId);
                     this.onError(error);
                 }
             }
         });
-        this.turnStreams.set(input.userMessageId, { controller, output, task });
+        this.turnStreams.set(input.userMessageId, {
+            controller,
+            output,
+            task,
+        });
     }
     async consumeTurnStream(input, submission, output, signal) {
         let committedText = input.streamCommittedText;
@@ -812,7 +1276,7 @@ export class AgentService {
                         const submittedText = messageText(event.data.message);
                         if (event.data.runId && submittedText === input.text) {
                             runId = event.data.runId;
-                            await this.repository.attachAgentRun({
+                            await agentRunAttach(this.executor, {
                                 runId,
                                 sessionId: input.sessionId,
                                 text: input.text,
@@ -821,6 +1285,7 @@ export class AgentService {
                         }
                     }
                     if (runId && event.data.runId === runId) {
+                        await this.updateAgentActivity(input, event);
                         if (event.type === "agent_event") {
                             const nextPartial = agentLoopText(event);
                             if (nextPartial !== undefined) {
@@ -865,7 +1330,10 @@ export class AgentService {
         await stream.task;
     }
     async publishAgentReplyHint(chatId, hint) {
-        const event = { type: "sync", ...hint };
+        const event = {
+            type: "sync",
+            ...hint,
+        };
         try {
             await Promise.all([
                 this.pubsub.publish(realtimeTopics.server, event),
@@ -890,7 +1358,7 @@ export class AgentService {
     }
     async completeTurn(input, text) {
         await this.stopTurnStream(input);
-        const result = await this.repository.completeAgentTurn({
+        const result = await agentTurnComplete(this.executor, {
             agentUserId: input.agentUserId,
             actorUserId: input.actorUserId,
             sessionId: input.sessionId,
@@ -900,15 +1368,17 @@ export class AgentService {
         });
         if (!result) {
             this.clearTypingRenewal(input.chatId, input.userMessageId);
+            this.clearAgentActivity(input.userMessageId);
             return;
         }
         await this.publishAgentReplyHint(input.chatId, result.hint);
+        await this.stopAgentActivity(input);
         await this.stopTyping(input);
         this.startDrain(input.chatId);
     }
     async failTurn(input, error) {
         await this.stopTurnStream(input);
-        const result = await this.repository.failAgentTurn({
+        const result = await agentTurnFail(this.executor, {
             agentUserId: input.agentUserId,
             actorUserId: input.actorUserId,
             error,
@@ -918,12 +1388,103 @@ export class AgentService {
         });
         if (!result) {
             this.clearTypingRenewal(input.chatId, input.userMessageId);
+            this.clearAgentActivity(input.userMessageId);
             return;
         }
         await this.publishAgentReplyHint(input.chatId, result.hint);
+        await this.stopAgentActivity(input);
         await this.stopTyping(input);
         this.startDrain(input.chatId);
     }
+    async startAgentActivity(input) {
+        if (this.agentActivities.has(input.userMessageId))
+            return;
+        let activity;
+        const timer = setInterval(() => {
+            if (this.agentActivities.get(input.userMessageId) !== activity)
+                return;
+            void this.publishAgentActivity(input, activity, true).catch(this.onError);
+        }, AGENT_ACTIVITY_RENEW_INTERVAL_MS);
+        timer.unref();
+        activity = {
+            lastOccurredAt: 0,
+            phase: "thinking",
+            startedAt: sqliteTimestamp(input.startedAt),
+            timer,
+            tokenCounts: new Map(),
+            userMessageId: input.userMessageId,
+        };
+        this.agentActivities.set(input.userMessageId, activity);
+        try {
+            await this.publishAgentActivity(input, activity, true);
+        }
+        catch (error) {
+            this.onError(error);
+        }
+    }
+    async updateAgentActivity(input, event) {
+        const activity = this.agentActivities.get(input.userMessageId);
+        if (!activity)
+            return;
+        if (event.type === "run_started" &&
+            Number.isSafeInteger(event.createdAt) &&
+            event.createdAt >= 0)
+            activity.startedAt = Math.min(activity.startedAt, event.createdAt);
+        const phase = agentActivityPhase(event);
+        const phaseChanged = phase !== undefined && phase !== activity.phase;
+        if (phase !== undefined)
+            activity.phase = phase;
+        const usage = agentEventTokenCount(event);
+        if (usage)
+            activity.tokenCounts.set(usage.messageId, usage.tokenCount);
+        if (!phaseChanged)
+            return;
+        try {
+            await this.publishAgentActivity(input, activity, true);
+        }
+        catch (error) {
+            this.onError(error);
+        }
+    }
+    async stopAgentActivity(input) {
+        const activity = this.agentActivities.get(input.userMessageId);
+        this.clearAgentActivity(input.userMessageId);
+        if (!activity)
+            return;
+        try {
+            await this.publishAgentActivity(input, activity, false);
+        }
+        catch (error) {
+            this.onError(error);
+        }
+    }
+    clearAgentActivity(userMessageId) {
+        const activity = this.agentActivities.get(userMessageId);
+        if (activity)
+            clearInterval(activity.timer);
+        this.agentActivities.delete(userMessageId);
+    }
+    publishAgentActivity(input, activity, active) {
+        const occurredAt = Math.max(Date.now(), activity.lastOccurredAt + 1);
+        activity.lastOccurredAt = occurredAt;
+        const tokenCount = [...activity.tokenCounts.values()].reduce((total, count) => total + count, 0);
+        return this.pubsub.publish(realtimeTopics.chat(input.chatId), {
+            type: "agent.activity",
+            chatId: input.chatId,
+            agentUserId: input.agentUserId,
+            turnId: input.userMessageId,
+            active,
+            phase: activity.phase,
+            tokenCount,
+            startedAt: activity.startedAt,
+            occurredAt,
+            ...(active
+                ? {
+                    expiresAt: occurredAt + AGENT_ACTIVITY_TTL_MS,
+                }
+                : {}),
+        });
+    }
     async startTyping(input) {
         if (this.typingRenewals.has(input.chatId))
             return;
@@ -935,8 +1496,7 @@ export class AgentService {
         }
         let renewal;
         const timer = setInterval(() => {
-            void this.repository
-                .renewAgentTurnLease({
+            void agentTurnRenewLease(this.executor, {
                 agentUserId: input.agentUserId,
                 userMessageId: input.userMessageId,
                 workerId: input.workerId,
@@ -946,6 +1506,7 @@ export class AgentService {
                     return;
                 if (!renewed) {
                     this.clearTypingRenewal(input.chatId, input.userMessageId);
+                    this.clearAgentActivity(input.userMessageId);
                     this.turnStreams.get(input.userMessageId)?.controller.abort();
                     return;
                 }
@@ -954,7 +1515,10 @@ export class AgentService {
                 .catch(this.onError);
         }, TYPING_RENEW_INTERVAL_MS);
         timer.unref();
-        renewal = { timer, userMessageId: input.userMessageId };
+        renewal = {
+            timer,
+            userMessageId: input.userMessageId,
+        };
         this.typingRenewals.set(input.chatId, renewal);
     }
     async stopTyping(input) {
@@ -982,7 +1546,11 @@ export class AgentService {
             userId: input.agentUserId,
             active,
             occurredAt,
-            ...(active ? { expiresAt: occurredAt + TYPING_TTL_MS } : {}),
+            ...(active
+                ? {
+                    expiresAt: occurredAt + TYPING_TTL_MS,
+                }
+                : {}),
         });
     }
 }
@@ -1065,7 +1633,11 @@ class AgentReplyStreamOutput {
         const expectedEventId = this.persistedEventId;
         const task = this.persist({
             ...update,
-            ...(expectedEventId === undefined ? {} : { expectedEventId }),
+            ...(expectedEventId === undefined
+                ? {}
+                : {
+                    expectedEventId,
+                }),
         })
             .then(() => {
             this.persistedEventId = update.eventId;
@@ -1169,7 +1741,9 @@ class AgentImageBuildOutput {
             progress: this.progress,
             ...(this.lastBuildLogLine === undefined
                 ? {}
-                : { lastBuildLogLine: this.lastBuildLogLine }),
+                : {
+                    lastBuildLogLine: this.lastBuildLogLine,
+                }),
         };
         this.buffer = "";
         this.dirty = false;
@@ -1199,6 +1773,8 @@ class AgentImageBuildOutput {
     }
 }
 function isRelevantRigEvent(event) {
+    if (event.type === "external_tool_call_requested" && event.data.call)
+        return true;
     if (!event.data.runId)
         return false;
     return (event.type === "message_submitted" ||
@@ -1224,6 +1800,42 @@ function agentLoopText(event) {
         return undefined;
     return textBlocks.map((block) => block.text ?? "").join("");
 }
+function agentActivityPhase(event) {
+    if (event.type === "run_started")
+        return "thinking";
+    if (event.type === "agent_message")
+        return messageText(event.data.message) ? "typing" : "thinking";
+    if (event.type !== "agent_event")
+        return undefined;
+    const type = event.data.event?.type;
+    if (type?.startsWith("text_"))
+        return "typing";
+    if (type?.startsWith("thinking_") ||
+        type?.startsWith("toolcall_") ||
+        type?.startsWith("tool_") ||
+        type === "inference_iteration_start" ||
+        type === "inference_retry" ||
+        type === "context_compacted" ||
+        type === "permission_review")
+        return "thinking";
+    return undefined;
+}
+function agentEventTokenCount(event) {
+    const message = event.type === "agent_message"
+        ? event.data.message
+        : event.type === "agent_event"
+            ? (event.data.event?.partial ?? event.data.event?.message ?? event.data.event?.error)
+            : undefined;
+    if (!message)
+        return undefined;
+    const tokenCount = message.usage?.totalTokens;
+    if (typeof tokenCount !== "number" || !Number.isSafeInteger(tokenCount) || tokenCount < 0)
+        return undefined;
+    return {
+        messageId: message.id ?? "active-inference",
+        tokenCount,
+    };
+}
 function appendAgentText(committedText, nextText) {
     if (!nextText)
         return committedText;
@@ -1247,14 +1859,34 @@ function agentImageTag(definitionHash) {
 function agentContainerName() {
     return `happy2-agent-${createId()}`;
 }
-function sandboxDirectories(root, agentUserId, privateUserId) {
-    const sandbox = join(root, "agents", agentUserId, "users", privateUserId);
-    return { home: join(sandbox, "home"), workspace: join(sandbox, "workspace") };
+function sandboxDirectories(root, agentUserId, scopeKind, scopeId, conversationId) {
+    const scope = join(root, "agents", agentUserId, scopeKind, scopeId);
+    const sandbox = conversationId ? join(scope, "conversations", conversationId) : scope;
+    return {
+        home: join(sandbox, "home"),
+        workspace: join(sandbox, "workspace"),
+    };
 }
 function agentImageBuildError(error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = deepestErrorMessage(error);
     return message.slice(0, 16_000) || "Agent image build failed";
 }
+function deepestErrorMessage(error, seen = new Set()) {
+    if (error === null || error === undefined)
+        return "";
+    if (typeof error !== "object")
+        return String(error);
+    if (seen.has(error))
+        return "";
+    seen.add(error);
+    const candidate = error;
+    if (candidate.cause !== undefined) {
+        const cause = deepestErrorMessage(candidate.cause, seen);
+        if (cause)
+            return cause;
+    }
+    return typeof candidate.message === "string" ? candidate.message : "";
+}
 function agentTurnStreamError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.slice(0, 16_000) || "Agent reply stream failed";
@@ -1277,7 +1909,9 @@ function delay(milliseconds, signal) {
             signal.removeEventListener("abort", abort);
             resolve();
         }, milliseconds);
-        signal.addEventListener("abort", abort, { once: true });
+        signal.addEventListener("abort", abort, {
+            once: true,
+        });
     });
 }
 //# sourceMappingURL=service.js.map