@kafca/agentdock 0.1.56 → 0.1.58

package/dist-electron/services/local-ai-core/src/scheduler/base-channel-schedule-adapter.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseChannelScheduleAdapter = void 0;
+const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
+const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
+const thread_resolution_js_1 = require("./thread-resolution.js");
+class BaseChannelScheduleAdapter {
+    options;
+    executor;
+    constructor(options) {
+        this.options = options;
+        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+        });
+    }
+    supports(job) {
+        return (0, scheduled_job_route_js_1.platformMatches)(job.platform, this.platformBase) && this.supportedRouteTypes.includes(job.route.type);
+    }
+    async execute(context) {
+        const { job } = context;
+        const executionPolicy = this.createPolicy(job, {
+            store: this.options.store,
+            workspaceRouter: this.options.getWorkspaceRouter(),
+            getChannelRuntime: this.options.getChannelRuntime,
+        }, (nextJob) => this.resolveThread(nextJob), (nextJob) => this.preferredAgentFor(nextJob));
+        const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
+        return {
+            threadId: execution.threadId,
+            runId: execution.runId,
+            replyText: execution.replyText,
+            deliveryMode: 'bridge-stream',
+            deliveryStatus: 'succeeded',
+            lastBridgeEventAt: new Date().toISOString(),
+        };
+    }
+    async resolveThread(job) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const route = job.route;
+        const channelId = route.channelId;
+        const participantId = route.participantId || '';
+        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
+        if (binding?.thread_id && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, binding.thread_id)) {
+            return binding.thread_id;
+        }
+        if (route.threadId && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, route.threadId)) {
+            return route.threadId;
+        }
+        const thread = await workspaceRouter.createThread(job.workspaceId, job.description || `Scheduled ${job.platform} task`);
+        const now = new Date().toISOString();
+        this.options.store.upsertPlatformThreadBinding({
+            workspace_id: job.workspaceId,
+            platform: job.platform,
+            chat_id: channelId,
+            platform_user_id: participantId,
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, job.platform);
+        if (authorized) {
+            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, job.platform);
+        }
+        return thread.id;
+    }
+    preferredAgentFor(job) {
+        const route = job.route;
+        const channelId = route.channelId;
+        if (!channelId)
+            return '';
+        const participantId = route.participantId || '';
+        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
+        return binding?.preferred_agent_type || '';
+    }
+}
+exports.BaseChannelScheduleAdapter = BaseChannelScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/lark-schedule-adapter.js

@@ -1,87 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LarkScheduleAdapter = void 0;
-const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
-const lark_execution_policies_js_1 = require("./lark-execution-policies.js");
-const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
-class LarkScheduleAdapter {
-    options;
-    executor;
+const channel_execution_policy_js_1 = require("./channel-execution-policy.js");
+const base_channel_schedule_adapter_js_1 = require("./base-channel-schedule-adapter.js");
+class LarkScheduleAdapter extends base_channel_schedule_adapter_js_1.BaseChannelScheduleAdapter {
+    platformBase = 'lark';
+    supportedRouteTypes = ['channel.chat', 'lark_chat'];
     deliveryTargets = ['lark'];
-    constructor(options) {
-        this.options = options;
-        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
-            store: options.store,
-            getWorkspaceRouter: options.getWorkspaceRouter,
+    createPolicy(job, options, resolveSameThread, preferredAgentType) {
+        const label = this.platformBase.charAt(0).toUpperCase() + this.platformBase.slice(1);
+        return (0, channel_execution_policy_js_1.createChannelExecutionPolicy)(job, options, {
+            platformBase: this.platformBase,
+            resolveSameThread,
+            sideThreadTitle: (nextJob) => `[Scheduled:${label}] ${nextJob.description || nextJob.id}`,
+            legacySideThreadTitles: (nextJob) => [`[Scheduled] ${nextJob.description || nextJob.id}`],
+            preferredAgentType,
         });
     }
-    supports(job) {
-        return (0, scheduled_job_route_js_1.platformMatches)(job.platform, 'lark') && (job.route.type === 'channel.chat' || job.route.type === 'lark_chat');
-    }
-    async execute(context) {
-        const { job } = context;
-        const executionPolicy = (0, lark_execution_policies_js_1.createLarkExecutionPolicy)(job, {
-            store: this.options.store,
-            workspaceRouter: this.options.getWorkspaceRouter(),
-            getChannelRuntime: this.options.getChannelRuntime,
-        }, (nextJob) => this.resolveThread(nextJob), (nextJob) => this.preferredAgentFor(nextJob));
-        const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
-        return {
-            threadId: execution.threadId,
-            runId: execution.runId,
-            replyText: execution.replyText,
-            deliveryMode: 'bridge-stream',
-            deliveryStatus: 'succeeded',
-            lastBridgeEventAt: new Date().toISOString(),
-        };
-    }
-    async resolveThread(job) {
-        const workspaceRouter = this.options.getWorkspaceRouter();
-        const route = job.route;
-        const channelId = route.channelId;
-        const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
-        if (binding?.thread_id && await this.threadExists(binding.thread_id)) {
-            return binding.thread_id;
-        }
-        if (route.threadId && await this.threadExists(route.threadId)) {
-            return route.threadId;
-        }
-        const thread = await workspaceRouter.createThread(job.workspaceId, job.description || `Scheduled ${job.platform} task`);
-        const now = new Date().toISOString();
-        this.options.store.upsertPlatformThreadBinding({
-            workspace_id: job.workspaceId,
-            platform: job.platform,
-            chat_id: channelId,
-            platform_user_id: participantId,
-            thread_id: thread.id,
-            last_platform_message_id: null,
-            created_at: now,
-            updated_at: now,
-        });
-        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, job.platform);
-        if (authorized) {
-            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, job.platform);
-        }
-        return thread.id;
-    }
-    async threadExists(threadId) {
-        try {
-            await this.options.getWorkspaceRouter().getThread(threadId);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    preferredAgentFor(job) {
-        const route = job.route;
-        const channelId = route.channelId;
-        if (!channelId)
-            return '';
-        const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
-        return binding?.preferred_agent_type || '';
-    }
 }
 exports.LarkScheduleAdapter = LarkScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/local-schedule-adapter.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalScheduleAdapter = void 0;
 const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
+const thread_resolution_js_1 = require("./thread-resolution.js");
 class LocalScheduleAdapter {
     options;
     executor;
@@ -40,7 +41,7 @@ class LocalScheduleAdapter {
     }
     async resolveThread(job) {
         const workspaceRouter = this.options.getWorkspaceRouter();
-        if (job.route.threadId && await this.threadExists(job.route.threadId)) {
+        if (job.route.threadId && await (0, thread_resolution_js_1.threadExists)(workspaceRouter, job.route.threadId)) {
             return job.route.threadId;
         }
         const title = `[Scheduled] ${job.description || job.id}`;
@@ -52,14 +53,5 @@ class LocalScheduleAdapter {
         const created = await workspaceRouter.createThread(job.workspaceId, title);
         return created.id;
     }
-    async threadExists(threadId) {
-        try {
-            await this.options.getWorkspaceRouter().getThread(threadId);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
 }
 exports.LocalScheduleAdapter = LocalScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/run-polling.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForRunCompletion = waitForRunCompletion;
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+const RUN_POLL_INTERVAL_MS = 300;
+async function waitForRunCompletion(store, runId, timeoutMs, label) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const run = store.getRun(runId);
+        if (run && TERMINAL_RUN_STATES.has(run.status)) {
+            if (run.status !== 'completed') {
+                throw new Error(`${label} run finished with status ${run.status}`);
+            }
+            return run;
+        }
+        await new Promise((resolve) => setTimeout(resolve, RUN_POLL_INTERVAL_MS));
+    }
+    throw new Error(`Timed out waiting for ${label.toLowerCase()} run ${runId}`);
+}

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-conversation-executor.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduledConversationExecutor = void 0;
 const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
-const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+const run_polling_js_1 = require("./run-polling.js");
 const SCHEDULED_RUN_PERMISSION_MODE = 'bypassPermissions';
 class ScheduledConversationExecutor {
     options;
@@ -16,9 +16,9 @@ class ScheduledConversationExecutor {
             const workspaceRouter = this.options.getWorkspaceRouter();
             const sendResult = await workspaceRouter.sendThreadMessage(target.threadId, prompt, {
                 permissionMode: SCHEDULED_RUN_PERMISSION_MODE,
-                runtimeEnv: this.buildScheduledRuntimeEnv(target),
+                runtimeEnv: (0, scheduled_job_route_js_1.buildPlatformRuntimeEnv)(target.platform, target.route),
             });
-            await this.waitForRun(sendResult.runId, timeoutMs);
+            await (0, run_polling_js_1.waitForRunCompletion)(this.options.store, sendResult.runId, timeoutMs, 'Scheduled');
             const thread = await workspaceRouter.getThread(target.threadId);
             const replyText = [...thread.messages]
                 .reverse()
@@ -34,39 +34,5 @@ class ScheduledConversationExecutor {
             await policy.afterExecute?.(target, job);
         }
     }
-    buildScheduledRuntimeEnv(target) {
-        const route = target.route;
-        const basePlatform = (0, scheduled_job_route_js_1.getChannelPlatformBase)(target.platform);
-        const env = {};
-        if (basePlatform && basePlatform !== 'local') {
-            env.LOCAL_AI_PLATFORM = basePlatform;
-            env.LOCAL_AI_ROUTE_TYPE = (0, scheduled_job_route_js_1.routeTypeForPlatform)(target.platform);
-        }
-        const instanceId = route.instanceId || (0, scheduled_job_route_js_1.getChannelPlatformInstanceId)(target.platform);
-        if (instanceId) {
-            env.LOCAL_AI_PLATFORM_INSTANCE_ID = instanceId;
-        }
-        if (route.channelId) {
-            env.LOCAL_AI_CHAT_ID = route.channelId;
-        }
-        if (route.participantId) {
-            env.LOCAL_AI_PLATFORM_USER_ID = route.participantId;
-        }
-        return env;
-    }
-    async waitForRun(runId, timeoutMs) {
-        const startedAt = Date.now();
-        while (Date.now() - startedAt < timeoutMs) {
-            const run = this.options.store.getRun(runId);
-            if (run && TERMINAL_RUN_STATES.has(run.status)) {
-                if (run.status !== 'completed') {
-                    throw new Error(`Scheduled run finished with status ${run.status}`);
-                }
-                return run;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 300));
-        }
-        throw new Error(`Timed out waiting for scheduled run ${runId}`);
-    }
 }
 exports.ScheduledConversationExecutor = ScheduledConversationExecutor;

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-job-route.js

@@ -6,6 +6,7 @@ exports.getChannelPlatformInstanceId = getChannelPlatformInstanceId;
 exports.platformMatches = platformMatches;
 exports.routeWithPlatformInstance = routeWithPlatformInstance;
 exports.routeTypeForPlatform = routeTypeForPlatform;
+exports.buildPlatformRuntimeEnv = buildPlatformRuntimeEnv;
 exports.routeFromPlatformThreadBinding = routeFromPlatformThreadBinding;
 exports.scheduledJobMatchesPlatformBinding = scheduledJobMatchesPlatformBinding;
 exports.scheduledJobMatchesCliContext = scheduledJobMatchesCliContext;
@@ -32,6 +33,25 @@ function routeTypeForPlatform(platform) {
     const base = getChannelPlatformBase(platform);
     return base === 'lark' || base === 'weixin' ? 'channel.chat' : base;
 }
+function buildPlatformRuntimeEnv(platform, route) {
+    const basePlatform = getChannelPlatformBase(platform);
+    const env = {};
+    if (basePlatform && basePlatform !== 'local') {
+        env.LOCAL_AI_PLATFORM = basePlatform;
+        env.LOCAL_AI_ROUTE_TYPE = routeTypeForPlatform(platform);
+    }
+    const instanceId = route.instanceId || getChannelPlatformInstanceId(platform);
+    if (instanceId) {
+        env.LOCAL_AI_PLATFORM_INSTANCE_ID = instanceId;
+    }
+    if (route.channelId) {
+        env.LOCAL_AI_CHAT_ID = route.channelId;
+    }
+    if (route.participantId) {
+        env.LOCAL_AI_PLATFORM_USER_ID = route.participantId;
+    }
+    return env;
+}
 function routeFromPlatformThreadBinding(binding) {
     return {
         type: routeTypeForPlatform(binding.platform),

package/dist-electron/services/local-ai-core/src/scheduler/scheduler-service.js

@@ -16,10 +16,18 @@ class SchedulerService extends node_events_1.EventEmitter {
         this.options = options;
         this.runLifecycle = new scheduler_run_lifecycle_js_1.SchedulerRunLifecycle({
             store: options.store,
-            emitRun: (run) => this.emit('run', run),
-            emitJob: (job) => this.emit('job', job),
+            emitRun: (run) => this.emitRun(run),
+            emitJob: (job) => this.emitJob(job),
         });
     }
+    emitJob(job) {
+        this.emit('job', job);
+        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+    }
+    emitRun(run) {
+        this.emit('run', run);
+        this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: run });
+    }
     async start() {
         await this.tick();
         this.timer = setInterval(() => {
@@ -41,14 +49,12 @@ class SchedulerService extends node_events_1.EventEmitter {
     }
     createJob(input) {
         const job = this.options.store.createScheduledJob(input);
-        this.emit('job', job);
-        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+        this.emitJob(job);
         return job;
     }
     updateJob(jobId, input) {
         const job = this.options.store.updateScheduledJob(this.resolveRequiredJobId(jobId), input);
-        this.emit('job', job);
-        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+        this.emitJob(job);
         return job;
     }
     deleteJob(jobId) {
@@ -115,39 +121,21 @@ class SchedulerService extends node_events_1.EventEmitter {
     }
     async executeJob(job, triggeredAt, manual) {
         if (this.runningJobs.has(job.id)) {
-            const skipped = this.runLifecycle.markSkipped(job, triggeredAt, 'Skipped because the previous run is still active.');
-            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: skipped });
-            return skipped;
+            return this.runLifecycle.markSkipped(job, triggeredAt, 'Skipped because the previous run is still active.');
         }
         this.runningJobs.add(job.id);
         const run = this.runLifecycle.markQueued(job, triggeredAt);
-        this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: run });
         try {
             const executor = this.options.executors.find((candidate) => candidate.supports(job));
             if (!executor) {
                 throw new Error(`No scheduler executor is available for delivery target "${job.platform}"`);
             }
             this.runLifecycle.markRunning(run.id);
-            const running = this.options.store.getScheduledJobRun(run.id);
-            if (running) {
-                this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: running });
-            }
             const result = await executor.execute({ job, triggeredAt });
-            const succeeded = this.runLifecycle.markSucceeded(job, run.id, result, !manual && job.triggerType === 'once');
-            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: succeeded });
-            const nextJob = this.options.store.getScheduledJob(job.id);
-            if (nextJob) {
-                this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: nextJob });
-            }
-            return succeeded;
+            return this.runLifecycle.markSucceeded(job, run.id, result, !manual && job.triggerType === 'once');
         }
         catch (error) {
             const failed = this.runLifecycle.markFailed(job.id, run.id, error instanceof Error ? error.message : String(error));
-            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: failed });
-            const nextJob = this.options.store.getScheduledJob(job.id);
-            if (nextJob) {
-                this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: nextJob });
-            }
             this.options.log?.(`scheduler job failed ${job.id}: ${failed.error || 'unknown error'}`);
             this.maybeAutoDisableAfterFailure(job.id);
             return failed;
@@ -173,8 +161,7 @@ class SchedulerService extends node_events_1.EventEmitter {
         this.options.store.updateScheduledJobStatus(jobId, { enabled: false });
         const disabled = this.options.store.getScheduledJob(jobId);
         if (disabled) {
-            this.emit('job', disabled);
-            this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: disabled });
+            this.emitJob(disabled);
         }
         this.options.log?.(`scheduler auto-disabled job ${jobId} after ${consecutiveFailures} consecutive failures`);
     }

package/dist-electron/services/local-ai-core/src/scheduler/thread-resolution.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.threadExists = threadExists;
+async function threadExists(router, threadId) {
+    try {
+        await router.getThread(threadId);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist-electron/services/local-ai-core/src/scheduler/weixin-schedule-adapter.js

@@ -1,87 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WeixinScheduleAdapter = void 0;
-const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
-const weixin_execution_policies_js_1 = require("./weixin-execution-policies.js");
-const scheduled_job_route_js_1 = require("./scheduled-job-route.js");
-class WeixinScheduleAdapter {
-    options;
-    executor;
+const channel_execution_policy_js_1 = require("./channel-execution-policy.js");
+const base_channel_schedule_adapter_js_1 = require("./base-channel-schedule-adapter.js");
+class WeixinScheduleAdapter extends base_channel_schedule_adapter_js_1.BaseChannelScheduleAdapter {
+    platformBase = 'weixin';
+    supportedRouteTypes = ['channel.chat', 'weixin_chat'];
     deliveryTargets = ['weixin'];
-    constructor(options) {
-        this.options = options;
-        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
-            store: options.store,
-            getWorkspaceRouter: options.getWorkspaceRouter,
+    createPolicy(job, options, resolveSameThread, preferredAgentType) {
+        const label = this.platformBase.charAt(0).toUpperCase() + this.platformBase.slice(1);
+        return (0, channel_execution_policy_js_1.createChannelExecutionPolicy)(job, options, {
+            platformBase: this.platformBase,
+            resolveSameThread,
+            sideThreadTitle: (nextJob) => `[Scheduled:${label}] ${nextJob.description || nextJob.id}`,
+            legacySideThreadTitles: (nextJob) => [`[Scheduled] ${nextJob.description || nextJob.id}`],
+            preferredAgentType,
         });
     }
-    supports(job) {
-        return (0, scheduled_job_route_js_1.platformMatches)(job.platform, 'weixin') && (job.route.type === 'channel.chat' || job.route.type === 'weixin_chat');
-    }
-    async execute(context) {
-        const { job } = context;
-        const executionPolicy = (0, weixin_execution_policies_js_1.createWeixinExecutionPolicy)(job, {
-            store: this.options.store,
-            workspaceRouter: this.options.getWorkspaceRouter(),
-            getChannelRuntime: this.options.getChannelRuntime,
-        }, (nextJob) => this.resolveThread(nextJob), (nextJob) => this.preferredAgentFor(nextJob));
-        const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
-        return {
-            threadId: execution.threadId,
-            runId: execution.runId,
-            replyText: execution.replyText,
-            deliveryMode: 'bridge-stream',
-            deliveryStatus: 'succeeded',
-            lastBridgeEventAt: new Date().toISOString(),
-        };
-    }
-    async resolveThread(job) {
-        const workspaceRouter = this.options.getWorkspaceRouter();
-        const route = job.route;
-        const channelId = route.channelId;
-        const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
-        if (binding?.thread_id && await this.threadExists(binding.thread_id)) {
-            return binding.thread_id;
-        }
-        if (route.threadId && await this.threadExists(route.threadId)) {
-            return route.threadId;
-        }
-        const thread = await workspaceRouter.createThread(job.workspaceId, job.description || `Scheduled ${job.platform} task`);
-        const now = new Date().toISOString();
-        this.options.store.upsertPlatformThreadBinding({
-            workspace_id: job.workspaceId,
-            platform: 'weixin',
-            chat_id: channelId,
-            platform_user_id: participantId,
-            thread_id: thread.id,
-            last_platform_message_id: null,
-            created_at: now,
-            updated_at: now,
-        });
-        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, job.platform);
-        if (authorized) {
-            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, job.platform);
-        }
-        return thread.id;
-    }
-    async threadExists(threadId) {
-        try {
-            await this.options.getWorkspaceRouter().getThread(threadId);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    preferredAgentFor(job) {
-        const route = job.route;
-        const channelId = route.channelId;
-        if (!channelId)
-            return '';
-        const participantId = route.participantId || '';
-        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, job.platform);
-        return binding?.preferred_agent_type || '';
-    }
 }
 exports.WeixinScheduleAdapter = WeixinScheduleAdapter;

package/dist-electron/services/local-ai-core/src/thread/agent-message-policy.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeAgentMessage = composeAgentMessage;
+const SCHEDULER_INSTRUCTION = [
+    '[Scheduler Tools]',
+    'If the user asks to create, view, edit, delete, or manually run a scheduled task for this conversation, use the Bash tool to run the local scheduler CLI.',
+    'Use these commands:',
+    'lac scheduler add --cron "<5-field cron>" --message "<exact message to send>" --desc "<short label>" [--execution-mode same-thread|side-thread]',
+    'lac scheduler list',
+    'lac scheduler list --thread',
+    'lac scheduler info <short-job-id>',
+    'lac scheduler edit <short-job-id> [--cron "<5-field cron>"] [--message "<exact message>"] [--desc "<short label>"] [--enabled true|false] [--execution-mode same-thread|side-thread]',
+    'lac scheduler del <short-job-id>',
+    'lac scheduler run <short-job-id>',
+    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
+    'Prefer relying on those variables instead of inventing your own route or creating session-only cron jobs.',
+    'By default, `lac scheduler list` shows all scheduled tasks in the current workspace. Use `lac scheduler list --thread` to show only the current conversation thread.',
+    'Use the short job id shown by `lac scheduler list`; do not add a `job:` prefix or expand it to a full UUID.',
+    'Use `--execution-mode same-thread` to reuse the current thread, or `--execution-mode side-thread` to run in a dedicated scheduled thread.',
+    'Only use the scheduler CLI when the user explicitly asks for scheduled automation.',
+    '[/Scheduler Tools]',
+].join('\n');
+const MONITOR_INSTRUCTION = [
+    '[Monitor Tools]',
+    'If the user asks to create, view, edit, delete, or manually run an event monitor for this conversation, use the Bash tool to run the local monitor CLI.',
+    'Use these commands:',
+    'lac monitor add --title "<short title>" --source stock.quote --symbol "<ticker>" --condition "<metric operator value>" --message "<exact analysis prompt>" [--cooldown 15m] [--execution-mode same-thread|side-thread]',
+    'lac monitor list',
+    'lac monitor list --thread',
+    'lac monitor info <short-monitor-id>',
+    'lac monitor edit <short-monitor-id> [--title "<title>"] [--condition "<expr>"] [--message "<exact prompt>"] [--enabled true|false] [--cooldown 15m] [--execution-mode same-thread|side-thread]',
+    'lac monitor del <short-monitor-id>',
+    'lac monitor run <short-monitor-id>',
+    'Supported stock metrics include latestPrice, change_percent, changePercent, and abs_change_percent. Example condition: "abs_change_percent >= 3".',
+    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
+    'Prefer relying on those variables instead of inventing your own route.',
+    'Use --execution-mode side-thread by default so monitor analysis does not interrupt the current conversation.',
+    'Only use the monitor CLI when the user explicitly asks for event monitoring automation.',
+    '[/Monitor Tools]',
+].join('\n');
+const CHANNEL_INSTRUCTION = [
+    '[Channel Tools]',
+    'If the user asks you to send a local file back through the current channel conversation, use the Bash tool to run the local channel CLI.',
+    'Use this command:',
+    'lac channel send-file --path "<absolute-or-workdir-relative-file-path>" [--target "<channel-chat-or-user-id>"]',
+    'By default, the file is sent to the current platform conversation from LOCAL_AI_CHAT_ID.',
+    'Use --target only when the user explicitly names a different channel chat or user id.',
+    'The CLI accepts absolute paths. Check that the file exists before sending when practical.',
+    'Only use the channel CLI when the user explicitly asks to send a file through the channel.',
+    '[/Channel Tools]',
+].join('\n');
+function composeAgentMessage(content, knowledgeBases = []) {
+    if (content.trim().startsWith('/')) {
+        return content;
+    }
+    const knowledgeBlock = knowledgeBases.length
+        ? [
+            '[Selected Knowledge Bases]',
+            ...knowledgeBases.map((base) => `- id: ${base.id} | name: ${base.name}`),
+            '[/Selected Knowledge Bases]',
+        ].join('\n')
+        : '';
+    return [
+        SCHEDULER_INSTRUCTION,
+        '',
+        MONITOR_INSTRUCTION,
+        '',
+        CHANNEL_INSTRUCTION,
+        ...(knowledgeBlock ? ['', knowledgeBlock] : []),
+        '',
+        '[User Message]',
+        content,
+        '[/User Message]',
+    ].join('\n');
+}