@geminixiang/mikan 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/agent.js

@@ -1,3 +1,7 @@
+/**
+ * Agent runner: prompt construction, path translation, run lifecycle, and createRunner.
+ * Single module — do not split helpers that only this file uses.
+ */
 import { DEFAULT_EVENT_BUDGET, defaultExtensionDirs, formatSkillsForPrompt, loadExtensions, loadSkillsFromDir, MikanAgentSession, MikanModels, } from "./harness/index.js";
 import { createHash } from "crypto";
 import { existsSync, readFileSync } from "fs";
@@ -7,18 +11,31 @@ import { resolveConversationSettings } from "./config.js";
 import { readEnv } from "./utils/env.js";
 import { ActorExecutionResolver } from "./execution-resolver.js";
 import * as log from "./log.js";
-import { reportUserFacingError } from "./observability/sentry.js";
 import { createExecutor, } from "./sandbox/index.js";
 import { createMountedRuntimePathContext } from "./sandbox/path-context.js";
-import { addLifecycleBreadcrumb, metricAttributes, updateActiveSpanAttribution, } from "./observability/sentry.js";
+import { addLifecycleBreadcrumb, metricAttributes, reportUserFacingError, updateActiveSpanAttribution, } from "./observability/sentry.js";
 import { AgentMemoryFileManager } from "./sessions/agent-memory-file-manager.js";
 import { extractSessionUuid, openManagedSession, } from "./sessions/store.js";
 import { HostEventStore } from "./tools/event.js";
 import { createMikanTools } from "./tools/index.js";
 import * as Sentry from "@sentry/node";
 import { formatLocalTimestamp } from "./utils/date.js";
-import { resolveConfiguredModel } from "./model-registry.js";
 import { emitAgentEvent } from "./agent-events.js";
+export function getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot) {
+    if (sandboxConfig.type === "image") {
+        return createMountedRuntimePathContext(hostWorkspaceRoot, "/workspace");
+    }
+    return createExecutor(sandboxConfig).getPathContext(hostWorkspaceRoot);
+}
+export function translateRuntimePathToHost(runtimePath, pathContext) {
+    return pathContext.runtimeToHostPath?.(runtimePath) ?? runtimePath;
+}
+export function translateAttachPathToHost(filePath, pathContext) {
+    const runtimePath = posix.isAbsolute(filePath)
+        ? filePath
+        : posix.join(pathContext.runtimeWorkspaceRoot, filePath);
+    return translateRuntimePathToHost(runtimePath, pathContext);
+}
 const IMAGE_MIME_TYPES = {
     jpg: "image/jpeg",
     jpeg: "image/jpeg",
@@ -29,12 +46,52 @@ const IMAGE_MIME_TYPES = {
 function getImageMimeType(filename) {
     return IMAGE_MIME_TYPES[filename.toLowerCase().split(".").pop() || ""];
 }
-function buildThreadSessionName(message) {
-    const text = message?.text?.trim();
-    if (!text)
-        return undefined;
-    const userLabel = message?.userName || message?.user || "unknown";
-    return `[${userLabel}]: ${text}`;
+function formatTimestampedUserMessage(message) {
+    const timestamp = formatLocalTimestamp(new Date());
+    const threadContext = message.threadTs ? ` [in-thread:${message.threadTs}]` : "";
+    return `[${timestamp}] [${message.userName || "unknown"}]${threadContext}: ${message.text}`;
+}
+function collectMessageAttachments(message, workspacePath, pathContext) {
+    const imageAttachments = [];
+    const nonImagePaths = [];
+    for (const attachment of message.attachments || []) {
+        const runtimePath = `${workspacePath}/${attachment.localPath}`;
+        const hostPath = pathContext?.runtimeToHostPath?.(runtimePath) ?? runtimePath;
+        const mimeType = getImageMimeType(attachment.localPath);
+        if (mimeType && existsSync(hostPath)) {
+            try {
+                imageAttachments.push({
+                    type: "image",
+                    mimeType,
+                    data: readFileSync(hostPath).toString("base64"),
+                });
+            }
+            catch {
+                nonImagePaths.push(runtimePath);
+            }
+        }
+        else {
+            nonImagePaths.push(runtimePath);
+        }
+    }
+    return { imageAttachments, nonImagePaths };
+}
+export function buildPromptPayload(message, workspacePath, pathContext) {
+    let userMessage = formatTimestampedUserMessage(message);
+    const { imageAttachments, nonImagePaths } = collectMessageAttachments(message, workspacePath, pathContext);
+    if (nonImagePaths.length > 0) {
+        userMessage += `\n\n<slack_attachments>\n${nonImagePaths.join("\n")}\n</slack_attachments>`;
+    }
+    return { userMessage, imageAttachments };
+}
+async function writePromptDebugContext(conversationDir, systemPrompt, session, userMessage, imageAttachmentCount) {
+    const debugContext = {
+        systemPrompt,
+        messages: session.messages,
+        newUserMessage: userMessage,
+        imageAttachmentCount,
+    };
+    await writeFile(join(conversationDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
 }
 async function getMemory(conversationDir) {
     const parts = [];
@@ -329,82 +386,21 @@ Do not add this to \`[SILENT]\` responses.`);
     }
     return parts.join("\n\n");
 }
-export function getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot) {
-    if (sandboxConfig.type === "image") {
-        return createMountedRuntimePathContext(hostWorkspaceRoot, "/workspace");
-    }
-    return createExecutor(sandboxConfig).getPathContext(hostWorkspaceRoot);
-}
-function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
-    const executionResolver = vaultManager && sandboxConfig.type !== "host"
-        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspaceDir)
-        : undefined;
-    // activeExecutor is replaced at the start of each run() call when executionResolver
-    // is present, so the stable `executor` wrapper always delegates to the latest resolved value.
-    let activeExecutor = executionResolver !== undefined
-        ? createExecutor({ type: "host" })
-        : createExecutor(sandboxConfig);
-    const executor = {
-        exec(command, options) {
-            return activeExecutor.exec(command, options);
-        },
-        getWorkspacePath(hostPath) {
-            return activeExecutor.getWorkspacePath(hostPath);
-        },
-        getSandboxConfig() {
-            return activeExecutor.getSandboxConfig();
-        },
-        getPathContext(hostWorkspaceRoot) {
-            return activeExecutor.getPathContext(hostWorkspaceRoot);
-        },
-    };
-    return {
-        executionResolver,
-        executor,
-        getPathContext: () => executor.getPathContext(hostWorkspacePath),
-        async resolveExecutorForRun(context) {
-            if (!executionResolver)
-                return;
-            activeExecutor = await executionResolver.resolve(context);
-        },
-    };
-}
-/**
- * Extension host services over mikan's runtime infrastructure: schedules
- * become event files under `<workspaceDir>/events` (picked up live by
- * EventsWatcher), secrets come from `vaults/extensions/<slug>/env`, and
- * notify posts through the platform bots when main.ts provides a notifier.
- */
-function buildExtensionHostServices(params) {
-    const { workspaceDir, vaultManager, platformNotifier, platformReactor } = params;
-    const eventStore = HostEventStore.fromWorkspaceDir(workspaceDir);
-    return {
-        stateDir: readEnv("STATE_DIR"),
-        scheduleStore: {
-            write: async (filename, payload) => {
-                // Event files tolerate a missing platform (single-platform default),
-                // so the harness payload is a valid event payload as written.
-                await eventStore.write(filename, payload);
-            },
-            delete: async (filename) => (await eventStore.delete(filename)).deleted,
-            list: async () => (await eventStore.list()).map((entry) => ({
-                filename: entry.filename,
-                payload: entry.payload,
-            })),
-        },
-        ...(platformNotifier ? { postMessage: platformNotifier } : {}),
-        ...(platformReactor ? { addReaction: platformReactor } : {}),
-        ...(vaultManager
-            ? {
-                resolveSecrets: (slug) => vaultManager.resolve(`extensions/${slug}`)?.env ?? {},
-            }
-            : {}),
-    };
+export function appendTriggerAttribution(text, triggerAttribution, sessionLink) {
+    if (!triggerAttribution)
+        return text;
+    const trimmed = text.trimEnd();
+    const legacySuffix = `_Triggered by ${triggerAttribution}_`;
+    // Slack mrkdwn italics cannot span a URL — a `_..._` wrapping a link renders
+    // the underscores literally. Keep the session link outside the italic span.
+    const suffix = sessionLink ? `${legacySuffix} · session: ${sessionLink}` : legacySuffix;
+    if (trimmed.endsWith(suffix))
+        return text;
+    const body = trimmed.endsWith(legacySuffix)
+        ? trimmed.slice(0, -legacySuffix.length).trimEnd()
+        : trimmed;
+    return `${body}\n\n${suffix}`;
 }
-/**
- * Local (workspace/conversation) skills override extension skills on name
- * collision: an admin's on-disk skill always beats an extension's.
- */
 function mergeExtensionSkills(local, extension) {
     if (extension.length === 0)
         return local;
@@ -415,42 +411,6 @@ function mergeExtensionSkills(local, extension) {
         byName.set(skill.name, skill);
     return [...byName.values()];
 }
-async function createConfiguredAgentSession(params) {
-    const { conversationId, workspaceDir, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, platformReactor, } = params;
-    // Host-only dirs under the state dir: extension code runs in the mikan
-    // process, so it must never load from workspace paths — those are mounted
-    // into sandbox containers and agent-writable (sandbox escape otherwise).
-    const extensionsResult = await loadExtensions({
-        dirs: defaultExtensionDirs(conversationId, readEnv("STATE_DIR")),
-        context: { conversationId, workspaceDir, model, thinkingLevel },
-        services: buildExtensionHostServices({
-            workspaceDir,
-            vaultManager,
-            platformNotifier,
-            platformReactor,
-        }),
-    });
-    for (const err of extensionsResult.errors) {
-        log.logWarning(`[${conversationId}] Extension load error: ${err.path}`, err.error);
-    }
-    if (extensionsResult.extensions.length > 0) {
-        log.logInfo(`[${conversationId}] Loaded ${extensionsResult.extensions.length} extension(s): ${extensionsResult.extensions.map((extension) => extension.name).join(", ")}`);
-    }
-    const session = new MikanAgentSession({
-        systemPrompt,
-        model,
-        thinkingLevel,
-        tools,
-        models,
-        sessionStore,
-        extensions: extensionsResult.registry,
-    });
-    const reloaded = session.reloadFromSession();
-    if (reloaded > 0) {
-        log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from session context`);
-    }
-    return { session, extensionSkills: extensionsResult.skills };
-}
 function createEmptyUsageTotals() {
     return {
         input: 0,
@@ -521,53 +481,6 @@ function createRunQueue(responder, runState) {
         wait: () => queueChain,
     };
 }
-function formatTimestampedUserMessage(message) {
-    const timestamp = formatLocalTimestamp(new Date());
-    const threadContext = message.threadTs ? ` [in-thread:${message.threadTs}]` : "";
-    return `[${timestamp}] [${message.userName || "unknown"}]${threadContext}: ${message.text}`;
-}
-function collectMessageAttachments(message, workspacePath, pathContext) {
-    const imageAttachments = [];
-    const nonImagePaths = [];
-    for (const attachment of message.attachments || []) {
-        const runtimePath = `${workspacePath}/${attachment.localPath}`;
-        const hostPath = pathContext?.runtimeToHostPath?.(runtimePath) ?? runtimePath;
-        const mimeType = getImageMimeType(attachment.localPath);
-        if (mimeType && existsSync(hostPath)) {
-            try {
-                imageAttachments.push({
-                    type: "image",
-                    mimeType,
-                    data: readFileSync(hostPath).toString("base64"),
-                });
-            }
-            catch {
-                nonImagePaths.push(runtimePath);
-            }
-        }
-        else {
-            nonImagePaths.push(runtimePath);
-        }
-    }
-    return { imageAttachments, nonImagePaths };
-}
-export function buildPromptPayload(message, workspacePath, pathContext) {
-    let userMessage = formatTimestampedUserMessage(message);
-    const { imageAttachments, nonImagePaths } = collectMessageAttachments(message, workspacePath, pathContext);
-    if (nonImagePaths.length > 0) {
-        userMessage += `\n\n<slack_attachments>\n${nonImagePaths.join("\n")}\n</slack_attachments>`;
-    }
-    return { userMessage, imageAttachments };
-}
-async function writePromptDebugContext(conversationDir, systemPrompt, session, userMessage, imageAttachmentCount) {
-    const debugContext = {
-        systemPrompt,
-        messages: session.messages,
-        newUserMessage: userMessage,
-        imageAttachmentCount,
-    };
-    await writeFile(join(conversationDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
-}
 function getFinalAssistantText(session) {
     const lastAssistant = session.messages.findLast((message) => message.role === "assistant");
     return (lastAssistant?.content
@@ -575,21 +488,6 @@ function getFinalAssistantText(session) {
         .map((content) => content.text)
         .join("\n") || "");
 }
-export function appendTriggerAttribution(text, triggerAttribution, sessionLink) {
-    if (!triggerAttribution)
-        return text;
-    const trimmed = text.trimEnd();
-    const legacySuffix = `_Triggered by ${triggerAttribution}_`;
-    // Slack mrkdwn italics cannot span a URL — a `_..._` wrapping a link renders
-    // the underscores literally. Keep the session link outside the italic span.
-    const suffix = sessionLink ? `${legacySuffix} · session: ${sessionLink}` : legacySuffix;
-    if (trimmed.endsWith(suffix))
-        return text;
-    const body = trimmed.endsWith(legacySuffix)
-        ? trimmed.slice(0, -legacySuffix.length).trimEnd()
-        : trimmed;
-    return `${body}\n\n${suffix}`;
-}
 function isEventTriggerAttribution(triggerAttribution) {
     return triggerAttribution?.startsWith("[event:") === true;
 }
@@ -745,6 +643,136 @@ async function reportUsageSummary(ctx) {
         await waitForQueue();
     }
 }
+function extractToolResultText(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    if (result &&
+        typeof result === "object" &&
+        "content" in result &&
+        Array.isArray(result.content)) {
+        const content = result.content;
+        const textParts = [];
+        for (const part of content) {
+            if (part.type === "text" && part.text) {
+                textParts.push(part.text);
+            }
+        }
+        if (textParts.length > 0) {
+            return textParts.join("\n");
+        }
+    }
+    return JSON.stringify(result);
+}
+function buildThreadSessionName(message) {
+    const text = message?.text?.trim();
+    if (!text)
+        return undefined;
+    const userLabel = message?.userName || message?.user || "unknown";
+    return `[${userLabel}]: ${text}`;
+}
+function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
+    const executionResolver = vaultManager && sandboxConfig.type !== "host"
+        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspaceDir)
+        : undefined;
+    // activeExecutor is replaced at the start of each run() call when executionResolver
+    // is present, so the stable `executor` wrapper always delegates to the latest resolved value.
+    let activeExecutor = executionResolver !== undefined
+        ? createExecutor({ type: "host" })
+        : createExecutor(sandboxConfig);
+    const executor = {
+        exec(command, options) {
+            return activeExecutor.exec(command, options);
+        },
+        getWorkspacePath(hostPath) {
+            return activeExecutor.getWorkspacePath(hostPath);
+        },
+        getSandboxConfig() {
+            return activeExecutor.getSandboxConfig();
+        },
+        getPathContext(hostWorkspaceRoot) {
+            return activeExecutor.getPathContext(hostWorkspaceRoot);
+        },
+    };
+    return {
+        executionResolver,
+        executor,
+        getPathContext: () => executor.getPathContext(hostWorkspacePath),
+        async resolveExecutorForRun(context) {
+            if (!executionResolver)
+                return;
+            activeExecutor = await executionResolver.resolve(context);
+        },
+    };
+}
+/**
+ * Extension host services over mikan's runtime infrastructure: schedules
+ * become event files under `<workspaceDir>/events` (picked up live by
+ * EventsWatcher), secrets come from `vaults/extensions/<slug>/env`, and
+ * notify posts through the platform bots when main.ts provides a notifier.
+ */
+function buildExtensionHostServices(params) {
+    const { workspaceDir, vaultManager, platformNotifier, platformReactor } = params;
+    const eventStore = HostEventStore.fromWorkspaceDir(workspaceDir);
+    return {
+        stateDir: readEnv("STATE_DIR"),
+        scheduleStore: {
+            write: async (filename, payload) => {
+                // Event files tolerate a missing platform (single-platform default),
+                // so the harness payload is a valid event payload as written.
+                await eventStore.write(filename, payload);
+            },
+            delete: async (filename) => (await eventStore.delete(filename)).deleted,
+            list: async () => (await eventStore.list()).map((entry) => ({
+                filename: entry.filename,
+                payload: entry.payload,
+            })),
+        },
+        ...(platformNotifier ? { postMessage: platformNotifier } : {}),
+        ...(platformReactor ? { addReaction: platformReactor } : {}),
+        ...(vaultManager
+            ? {
+                resolveSecrets: (slug) => vaultManager.resolve(`extensions/${slug}`)?.env ?? {},
+            }
+            : {}),
+    };
+}
+async function createConfiguredAgentSession(params) {
+    const { conversationId, workspaceDir, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, platformReactor, } = params;
+    // Host-only dirs under the state dir: extension code runs in the mikan
+    // process, so it must never load from workspace paths — those are mounted
+    // into sandbox containers and agent-writable (sandbox escape otherwise).
+    const extensionsResult = await loadExtensions({
+        dirs: defaultExtensionDirs(conversationId, readEnv("STATE_DIR")),
+        context: { conversationId, workspaceDir, model, thinkingLevel },
+        services: buildExtensionHostServices({
+            workspaceDir,
+            vaultManager,
+            platformNotifier,
+            platformReactor,
+        }),
+    });
+    for (const err of extensionsResult.errors) {
+        log.logWarning(`[${conversationId}] Extension load error: ${err.path}`, err.error);
+    }
+    if (extensionsResult.extensions.length > 0) {
+        log.logInfo(`[${conversationId}] Loaded ${extensionsResult.extensions.length} extension(s): ${extensionsResult.extensions.map((extension) => extension.name).join(", ")}`);
+    }
+    const session = new MikanAgentSession({
+        systemPrompt,
+        model,
+        thinkingLevel,
+        tools,
+        models,
+        sessionStore,
+        extensions: extensionsResult.registry,
+    });
+    const reloaded = session.reloadFromSession();
+    if (reloaded > 0) {
+        log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from session context`);
+    }
+    return { session, extensionSkills: extensionsResult.skills };
+}
 function reloadSessionMessages(session, conversationId) {
     const reloaded = session.reloadFromSession();
     if (reloaded > 0) {
@@ -752,7 +780,7 @@ function reloadSessionMessages(session, conversationId) {
     }
 }
 async function prepareRunContext(params) {
-    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, setReactFunction, } = params;
+    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, setReactFunction, bindPlatformToolPacks, } = params;
     let pathContext = params.pathContext;
     const sessionConversation = message.sessionKey.split(":")[0];
     await mkdir(join(conversationDir, "scratch"), { recursive: true });
@@ -761,6 +789,7 @@ async function prepareRunContext(params) {
             platform: platform.name,
             userId: message.userId,
             conversationId,
+            trustModel: platform.trustModel,
         });
         pathContext = getPathContext();
     }
@@ -794,17 +823,9 @@ async function prepareRunContext(params) {
     // (interactive turns on platforms with reaction support); otherwise unset
     // so the tool reports it is unavailable rather than silently no-op'ing.
     setReactFunction(responder.react ? async (emoji) => responder.react(emoji) : null);
-    // github_* tools are available only in GitHub conversations with wired
-    // ops; everywhere else they report themselves unavailable.
-    const { platformGithubOps, setGithubPrFunction, setGithubChecksFunction } = params;
-    const githubOps = platform.name === "github" ? platformGithubOps : undefined;
-    setGithubPrFunction(githubOps ? (request) => githubOps.pushAndCreatePr(conversationId, request) : null);
-    setGithubChecksFunction(githubOps
-        ? {
-            getChecks: (branch) => githubOps.getChecks(conversationId, branch),
-            getJobLog: (jobId) => githubOps.getJobLog(conversationId, jobId),
-        }
-        : null);
+    // Platform capability packs (e.g. GitHub PR/CI) enable themselves per run;
+    // core does not branch on platform name here.
+    bindPlatformToolPacks({ conversationId, platformName: platform.name });
     resetRunState(runState, responder, sessionConversation, message.userName, sessionUuid, triggerAttribution);
     const runQueue = createRunQueue(responder, runState);
     runState.queue = runQueue.queue;
@@ -1092,27 +1113,6 @@ function attachSessionEventHandlers(params) {
         }
     });
 }
-function extractToolResultText(result) {
-    if (typeof result === "string") {
-        return result;
-    }
-    if (result &&
-        typeof result === "object" &&
-        "content" in result &&
-        Array.isArray(result.content)) {
-        const content = result.content;
-        const textParts = [];
-        for (const part of content) {
-            if (part.type === "text" && part.text) {
-                textParts.push(part.text);
-            }
-        }
-        if (textParts.length > 0) {
-            return textParts.join("\n");
-        }
-    }
-    return JSON.stringify(result);
-}
 /**
  * Create a new PiAgentWrapper for a channel.
  * Sets up the session and subscribes to events once.
@@ -1120,18 +1120,18 @@ function extractToolResultText(result) {
  * Runner caching is handled by the caller (channelStates in main.ts).
  * This is a stateless factory function.
  */
-export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, sessionView, platformNotifier, platformReactor, platformGithubOps) {
+export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, sessionView, platformNotifier, platformReactor, platformToolPackFactories) {
     const agentConfig = resolveConversationSettings(conversationDir);
     const workspaceBase = join(conversationDir, "..");
     const { executionResolver, executor, getPathContext, resolveExecutorForRun } = createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, workspaceBase);
     let pathContext = getUnresolvedSandboxPathContext(sandboxConfig, workspaceBase);
     // Create tools (per-runner, with per-runner upload function setter)
-    const { tools, setUploadFunction, setReactFunction, setGithubPrFunction, setGithubChecksFunction, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, provisioner });
+    const { tools, setUploadFunction, setReactFunction, bindPlatformToolPacks, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, provisioner }, platformToolPackFactories ?? []);
     const modelRegistry = MikanModels.create();
     if (modelRegistry.getError()) {
         log.logWarning("models.json load error", modelRegistry.getError());
     }
-    const model = resolveConfiguredModel(modelRegistry, agentConfig.provider, agentConfig.model);
+    const model = modelRegistry.resolve(agentConfig.provider, agentConfig.model);
     // Initial system prompt (will be updated each run with fresh memory/channels/users/skills)
     const memory = await getMemory(conversationDir);
     const skills = loadMikanSkills(conversationDir, pathContext.runtimeWorkspaceRoot);
@@ -1140,6 +1140,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         formattingGuide: "",
         channels: [],
         users: [],
+        trustModel: "membership",
     };
     const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, conversationId, "shared", undefined, memory, sandboxConfig, emptyPlatform, skills);
     // Create session manager and settings manager. Top-level/private sessions
@@ -1198,9 +1199,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 setSandboxContext,
                 setUploadFunction,
                 setReactFunction,
-                setGithubPrFunction,
-                setGithubChecksFunction,
-                platformGithubOps,
+                bindPlatformToolPacks,
                 pathContext,
             });
             pathContext = prepared.pathContext;
@@ -1293,13 +1292,4 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         },
     };
 }
-export function translateRuntimePathToHost(runtimePath, pathContext) {
-    return pathContext.runtimeToHostPath?.(runtimePath) ?? runtimePath;
-}
-export function translateAttachPathToHost(filePath, pathContext) {
-    const runtimePath = posix.isAbsolute(filePath)
-        ? filePath
-        : posix.join(pathContext.runtimeWorkspaceRoot, filePath);
-    return translateRuntimePathToHost(runtimePath, pathContext);
-}
 //# sourceMappingURL=agent.js.map