openbot 0.3.1 → 0.3.2

package/dist/app/server.js

@@ -236,9 +236,6 @@ export async function startServer(options = {}) {
     });
     app.listen(PORT, () => {
         console.log(`\x1b[32mOpenBot server listening at http://localhost:${PORT}\x1b[0m`);
-        console.log(`  - Health endpoint: GET /health`);
-        console.log(`  - Events endpoint: GET /api/events (SSE)`);
-        console.log(`  - Publish endpoint: POST /api/publish`);
-        console.log(`  - State endpoint: GET /api/state`);
+        console.log(`🌐 Visit \x1b[96m\x1b[1mhttps://openbot.one\x1b[0m to connect to this runtime and manage everything from there. ✨`);
     });
 }

package/dist/bus/services.js

@@ -1,6 +1,25 @@
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig } from '../app/config.js';
 import { storageService } from '../services/storage.js';
 import { pluginService } from '../services/plugins.js';
+const readTodos = (state) => {
+    const raw = state.threadDetails?.state?.todos;
+    return Array.isArray(raw) ? raw : [];
+};
+let todoCounter = 0;
+const newTodoId = (now, idx) => `todo_${now.toString(36)}_${(todoCounter++).toString(36)}_${idx}`;
+async function persistTodos(storage, state, todos) {
+    if (!state.threadId)
+        throw new Error('No active thread');
+    await storage.patchThreadState({
+        channelId: state.channelId,
+        threadId: state.threadId,
+        state: { todos },
+    });
+    state.threadDetails = await storage.getThreadDetails({
+        channelId: state.channelId,
+        threadId: state.threadId,
+    });
+}
 /**
  * Resolve a scope alias to a concrete scope string. Aliases let tools accept
  * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
@@ -114,7 +133,7 @@ export const busServicesPlugin = (options) => (builder) => {
     builder.on('action:create_thread', async function* (event, context) {
         const threadId = event.meta?.threadId;
         const channelId = context.state.channelId;
-        const { threadTitle, spec, initialState } = event.data;
+        const { threadTitle, initialState } = event.data;
         if (!threadId) {
             console.warn('[bus] Cannot create thread: meta.threadId is missing');
             return;
@@ -126,7 +145,6 @@ export const busServicesPlugin = (options) => (builder) => {
                     channelId,
                     threadId,
                     threadTitle,
-                    spec,
                     initialState: initialState || {},
                 });
                 context.state.threadDetails = await storage.getThreadDetails({
@@ -286,14 +304,6 @@ export const busServicesPlugin = (options) => (builder) => {
                 });
                 updatedFields.push('state');
             }
-            if (typeof event.data.spec === 'string') {
-                await storage.patchThreadSpec({
-                    channelId: context.state.channelId,
-                    threadId: context.state.threadId,
-                    spec: event.data.spec,
-                });
-                updatedFields.push('spec');
-            }
             context.state.threadDetails = await storage.getThreadDetails({
                 channelId: context.state.channelId,
                 threadId: context.state.threadId,
@@ -312,6 +322,92 @@ export const busServicesPlugin = (options) => (builder) => {
             };
         }
     });
+    builder.on('action:todo_write', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        try {
+            if (!context.state.threadId) {
+                throw new Error('todo_write requires an active thread');
+            }
+            const existing = readTodos(context.state);
+            const byId = new Map(existing.map((t) => [t.id, t]));
+            const now = Date.now();
+            const author = context.state.agentId || 'system';
+            const inputs = event.data.todos || [];
+            const next = inputs.map((raw, idx) => {
+                const prior = raw.id ? byId.get(raw.id) : undefined;
+                return {
+                    id: prior?.id || raw.id || newTodoId(now, idx),
+                    content: raw.content,
+                    status: raw.status || prior?.status || 'pending',
+                    assignee: raw.assignee ?? prior?.assignee,
+                    createdBy: prior?.createdBy || author,
+                    createdAt: prior?.createdAt || now,
+                    updatedAt: now,
+                    ...(prior?.result !== undefined ? { result: prior.result } : {}),
+                };
+            });
+            await persistTodos(storage, context.state, next);
+            yield {
+                type: 'action:todo_write:result',
+                data: { success: true, todos: next },
+                meta: resultMeta,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:todo_write:result',
+                data: {
+                    success: false,
+                    todos: readTodos(context.state),
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                meta: resultMeta,
+            };
+        }
+    });
+    builder.on('action:todo_update', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        const patch = event.data;
+        try {
+            if (!context.state.threadId) {
+                throw new Error('todo_update requires an active thread');
+            }
+            const existing = readTodos(context.state);
+            const idx = existing.findIndex((t) => t.id === patch.id);
+            if (idx === -1) {
+                throw new Error(`Todo "${patch.id}" not found`);
+            }
+            const now = Date.now();
+            const updated = {
+                ...existing[idx],
+                ...(patch.content !== undefined ? { content: patch.content } : {}),
+                ...(patch.status !== undefined ? { status: patch.status } : {}),
+                ...(patch.assignee !== undefined
+                    ? { assignee: patch.assignee === '' ? undefined : patch.assignee }
+                    : {}),
+                updatedAt: now,
+            };
+            const next = [...existing];
+            next[idx] = updated;
+            await persistTodos(storage, context.state, next);
+            yield {
+                type: 'action:todo_update:result',
+                data: { success: true, todo: updated, todos: next },
+                meta: resultMeta,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'action:todo_update:result',
+                data: {
+                    success: false,
+                    todos: readTodos(context.state),
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                meta: resultMeta,
+            };
+        }
+    });
     builder.on('action:storage:get-channels', async function* () {
         const channels = await storage.getChannels();
         yield { type: 'action:storage:get-channels-result', data: { channels } };

package/dist/harness/context.js

@@ -58,6 +58,7 @@ export function createDefaultContextEngine() {
     engine.registerProvider(new AgentDetailsProvider());
     engine.registerProvider(new ChannelDetailsProvider());
     engine.registerProvider(new ThreadDetailsProvider());
+    engine.registerProvider(new TodoProvider());
     engine.registerProvider(new MemoryProvider());
     engine.registerProvider(new RecentEventsProvider());
     engine.registerProcessor(new TokenBudgetProcessor());
@@ -70,11 +71,14 @@ class AgentDetailsProvider {
     async provide(state) {
         if (!state.agentDetails)
             return [];
+        const instructions = state.agentDetails.instructions?.trim();
+        if (!instructions)
+            return [];
         return [{
                 id: 'agent-details',
                 type: 'agent',
                 priority: 100,
-                content: `## AGENT NAME\n${state.agentDetails.name}\n\n## AGENT SPECIFICATION\n${state.agentDetails.instructions}`
+                content: `# ${state.agentDetails.name}\n\n${instructions}`,
             }];
     }
 }
@@ -85,11 +89,14 @@ class ChannelDetailsProvider {
     async provide(state) {
         if (!state.channelDetails)
             return [];
+        const spec = state.channelDetails.spec?.trim();
+        if (!spec)
+            return [];
         return [{
                 id: 'channel-details',
                 type: 'channel',
                 priority: 80,
-                content: `## CHANNEL NAME\n${state.channelDetails.name}\n\n## CHANNEL SPECIFICATION\n${state.channelDetails.spec}`
+                content: `# Channel you are in: ${state.channelDetails.name}\n\n Channel Specification: ${spec}`,
             }];
     }
 }
@@ -100,12 +107,65 @@ class ThreadDetailsProvider {
     async provide(state) {
         if (!state.threadDetails)
             return [];
-        return [{
+        // For now, this provider is a placeholder for future state-based assembly.
+        // It currently only surfaces the thread name to provide basic context.
+        return [
+            {
                 id: 'thread-details',
                 type: 'thread',
                 priority: 90,
-                content: `## THREAD NAME\n${state.threadDetails.name}\n\n## THREAD SPECIFICATION\n${state.threadDetails.spec}`
-            }];
+                content: `# Thread you are in: ${state.threadDetails.name}`,
+            },
+        ];
+    }
+}
+/**
+ * Surfaces the shared per-thread todo list. The list lives in
+ * `threadDetails.state.todos` and is owned by bus services — every agent in
+ * the thread reads from the same canonical source, which is how multi-agent
+ * autonomous flows stay coordinated.
+ */
+class TodoProvider {
+    constructor() {
+        this.name = 'todos';
+    }
+    async provide(state) {
+        const raw = state.threadDetails?.state?.todos;
+        const todos = Array.isArray(raw) ? raw : [];
+        if (todos.length === 0)
+            return [];
+        const DISPLAY_RESULT_CAP = 2500;
+        const marker = {
+            pending: '[ ]',
+            in_progress: '[~]',
+            done: '[x]',
+            cancelled: '[-]',
+        };
+        const formatted = todos
+            .map((t) => {
+            const assignee = t.assignee ? ` @${t.assignee}` : '';
+            let line = `- ${marker[t.status]} (${t.id})${assignee} ${t.content}`;
+            if (t.status === 'done' && t.result?.trim()) {
+                let snippet = t.result.trim();
+                if (snippet.length > DISPLAY_RESULT_CAP) {
+                    snippet = `${snippet.slice(0, DISPLAY_RESULT_CAP)}…[truncated]`;
+                }
+                line += `\n  Result: ${snippet}`;
+            }
+            return line;
+        })
+            .join('\n');
+        return [
+            {
+                id: 'todos',
+                type: 'todos',
+                priority: 92,
+                content: `## Shared todo plan (thread state)\n` +
+                    `Orchestrator authors with \`todo_write\`; assignees run one step at a time. ` +
+                    `When an item is \`done\`, its captured output appears below so every agent can see prior steps without relying on merged chat history.\n\n` +
+                    `${formatted}`,
+            },
+        ];
     }
 }
 /**
@@ -139,7 +199,7 @@ class MemoryProvider {
                     id: 'memory',
                     type: 'memory',
                     priority: 95,
-                    content: `## REMEMBERED FACTS\nThese are durable facts you previously stored with the \`remember\` tool. Trust them unless contradicted by the user. Use \`forget\` to remove ones that are stale.\n\n${formatted}`,
+                    content: `## Remembered facts\nTrust these unless the user contradicts them. Use \`forget\` to remove stale ones.\n\n${formatted}`,
                 },
             ];
         }

package/dist/harness/queue-processor.js

@@ -1,5 +1,6 @@
 import { ensureEventId } from '../app/utils.js';
 import { storageService } from '../services/storage.js';
+import { advanceAfterRun } from './todo-advance.js';
 export class QueueProcessor {
     constructor(options) {
         this.options = options;
@@ -26,33 +27,34 @@ export class QueueProcessor {
             await Promise.all(Array.from(groups.entries()).map(async ([agentId, items]) => {
                 // Run items for the SAME agent sequentially to preserve event order and state consistency.
                 for (const item of items) {
-                    const { event: currentEvent, delegationContext } = item;
-                    // Track delegation/handoff requests queued in this step to avoid accidental duplicates.
+                    const { event: currentEvent } = item;
+                    // Track handoff requests queued in this step to avoid accidental duplicates.
                     const queuedRequestKeys = new Set();
                     const queuedItems = [];
-                    const runOutputs = [];
+                    let lastAgentOutput;
                     const runOnEvent = async (chunk, state) => {
                         // 0. Filter out echoed input events to prevent duplication in the UI/storage
                         if (chunk.type === currentEvent.type && chunk.id === currentEvent.id) {
                             return false;
                         }
+                        if (chunk.type === 'agent:output') {
+                            const outMeta = chunk.meta;
+                            if (outMeta?.agentId === agentId) {
+                                const content = chunk.data?.content;
+                                if (typeof content === 'string' && content.trim()) {
+                                    lastAgentOutput = content.trim();
+                                }
+                            }
+                        }
                         // 1. Detect if a new thread was created and update the context for the rest of the loop
                         if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
                             this.currentThreadId = chunk.data.threadId || this.currentThreadId;
                         }
-                        // 2. Internal routing (handoff/delegation requests are internal — not forwarded)
-                        if (chunk.type === 'handoff:request' || chunk.type === 'delegation:request') {
-                            const isHandoff = chunk.type === 'handoff:request';
-                            const request = isHandoff
-                                ? chunk
-                                : chunk;
+                        // 2. Internal routing (handoff requests are internal — not forwarded)
+                        if (chunk.type === 'handoff:request') {
+                            const request = chunk;
                             const targetAgentId = request.data?.agentId;
-                            const toolCallId = typeof request.meta?.toolCallId === 'string'
-                                ? request.meta.toolCallId
-                                : undefined;
-                            const requestKey = isHandoff
-                                ? `handoff:${targetAgentId}:${request.data?.content ?? ''}`
-                                : `delegate:${toolCallId ?? 'missing'}:${targetAgentId}:${request.data?.content ?? ''}`;
+                            const requestKey = `handoff:${targetAgentId}`;
                             if (targetAgentId &&
                                 targetAgentId !== agentId &&
                                 !queuedRequestKeys.has(requestKey)) {
@@ -68,54 +70,10 @@ export class QueueProcessor {
                                         threadId: this.currentThreadId,
                                     },
                                 });
-                                if (isHandoff) {
-                                    queuedItems.push({ agentId: targetAgentId, event: targetEvent });
-                                }
-                                else {
-                                    if (!toolCallId) {
-                                        // Emit error output (this triggers run start if not already started)
-                                        await runOnEvent(ensureEventId({
-                                            type: 'agent:output',
-                                            data: {
-                                                content: 'Delegation request ignored: missing toolCallId. Please retry delegation.',
-                                            },
-                                            meta: {
-                                                agentId,
-                                                threadId: this.currentThreadId,
-                                            },
-                                        }), state);
-                                        return true;
-                                    }
-                                    const parentAgentId = typeof request.meta?.parentAgentId === 'string'
-                                        ? request.meta.parentAgentId
-                                        : agentId;
-                                    const delegationWidgetId = typeof request.meta?.delegationWidgetId === 'string'
-                                        ? request.meta.delegationWidgetId
-                                        : undefined;
-                                    queuedItems.push({
-                                        agentId: targetAgentId,
-                                        event: targetEvent,
-                                        delegationContext: {
-                                            parentAgentId,
-                                            toolCallId,
-                                            delegationWidgetId,
-                                        },
-                                    });
-                                }
+                                queuedItems.push({ agentId: targetAgentId, event: targetEvent });
                             }
                             return false;
                         }
-                        if (chunk.type === 'agent:output') {
-                            const content = chunk.data?.content;
-                            if (typeof content === 'string' && content.trim().length > 0) {
-                                runOutputs.push(content.trim());
-                            }
-                        }
-                        // For delegate mode, child agent execution is internal:
-                        // capture outputs for parent tool result, but don't stream child events to clients/storage.
-                        if (delegationContext) {
-                            return false;
-                        }
                         // If we get here, the event is accepted and should be emitted.
                         await this.options.onEvent(chunk, state);
                         return true;
@@ -133,7 +91,7 @@ export class QueueProcessor {
                             runId: this.options.runId,
                             agentId,
                             channelId: this.options.channelId,
-                            threadId: this.currentThreadId
+                            threadId: this.currentThreadId,
                         },
                     }, startState);
                     try {
@@ -160,60 +118,36 @@ export class QueueProcessor {
                                 runId: this.options.runId,
                                 agentId,
                                 channelId: this.options.channelId,
-                                threadId: this.currentThreadId
-                            },
-                        }, endState);
-                    }
-                    if (delegationContext) {
-                        const summary = runOutputs.length > 0
-                            ? runOutputs.join('\n\n').slice(0, 4000)
-                            : `Delegated agent "${agentId}" completed with no textual output.`;
-                        const delegateResultEvent = ensureEventId({
-                            type: 'action:delegate:result',
-                            data: {
-                                success: true,
-                                agentId,
-                                summary,
-                            },
-                            meta: {
-                                toolCallId: delegationContext.toolCallId,
-                                agentId: delegationContext.parentAgentId,
                                 threadId: this.currentThreadId,
                             },
-                        });
-                        if (delegationContext.delegationWidgetId) {
-                            await this.options.onEvent(ensureEventId({
-                                type: 'client:ui:widget',
-                                data: {
-                                    kind: 'message',
-                                    widgetId: delegationContext.delegationWidgetId,
-                                    title: `Delegation complete: ${agentId}`,
-                                    body: runOutputs.length > 0
-                                        ? 'Delegated task finished. Parent agent is preparing final response.'
-                                        : 'Delegated task finished with no textual output. Parent agent will continue.',
-                                    state: 'submitted',
-                                    metadata: {
-                                        type: 'delegation:status',
-                                        phase: 'completed',
-                                        delegatedAgentId: agentId,
-                                    },
-                                },
-                                meta: {
-                                    agentId: delegationContext.parentAgentId,
-                                    threadId: this.currentThreadId,
-                                },
-                            }), await storageService.getOpenBotState({
-                                runId: this.options.runId,
-                                agentId: delegationContext.parentAgentId,
+                        }, endState);
+                        // Autonomous todo advance: mark this agent's in_progress todo done
+                        // and dispatch the next assignee, if any. Single trigger point,
+                        // no reliance on the LLM remembering to call `todo_update`.
+                        try {
+                            const handoff = await advanceAfterRun({
+                                storage: storageService,
                                 channelId: this.options.channelId,
                                 threadId: this.currentThreadId,
-                                event: delegateResultEvent,
-                            }));
+                                endedAgentId: agentId,
+                                lastAgentOutput,
+                            });
+                            if (handoff) {
+                                const requestKey = `handoff:${handoff.agentId}`;
+                                if (!queuedRequestKeys.has(requestKey)) {
+                                    queuedRequestKeys.add(requestKey);
+                                    const targetEvent = ensureEventId({
+                                        type: 'agent:invoke',
+                                        data: { role: 'user', content: handoff.content },
+                                        meta: { threadId: this.currentThreadId },
+                                    });
+                                    queuedItems.push({ agentId: handoff.agentId, event: targetEvent });
+                                }
+                            }
+                        }
+                        catch (error) {
+                            console.warn('[queue] todo advance failed', error);
                         }
-                        nextQueue.push({
-                            agentId: delegationContext.parentAgentId,
-                            event: delegateResultEvent,
-                        });
                     }
                     nextQueue.push(...queuedItems);
                 }

package/dist/harness/runtime-factory.js

@@ -4,8 +4,8 @@ import { storageService } from '../services/storage.js';
 import { busServicesPlugin } from '../bus/services.js';
 /**
  * Enhances the agent's instructions with a list of other available agents the
- * orchestrator can hand off / delegate to. Agents that include the
- * `delegation` plugin will surface peers; agents without it can ignore this.
+ * orchestrator can hand off to. Agents that include the `delegation` plugin
+ * will surface peers; agents without it can ignore this.
  */
 export async function enhanceInstructions(state) {
     const { agentId, agentDetails } = state;
@@ -19,12 +19,16 @@ export async function enhanceInstructions(state) {
         const agentsList = otherAgents
             .map((a) => `- **${a.id}**${a.description ? `: ${a.description}` : ''}`)
             .join('\n');
-        const header = '### Available Agents for Handoff/Delegation:';
+        const header = '### Available Agents:';
         if (!agentDetails.instructions.includes(header)) {
-            agentDetails.instructions +=
-                `\n\n${header}\n${agentsList}\n\n` +
-                    'Use `handoff` to transfer control to another agent. ' +
-                    'Use `delegate` when you need a sub-result from another agent and want to continue after it returns.';
+            const hasHandoff = (agentDetails.pluginRefs || []).some((r) => r.id === 'delegation');
+            const hasTodo = (agentDetails.pluginRefs || []).some((r) => r.id === 'todo');
+            const usage = hasTodo
+                ? 'Use these ids as `assignee` when calling `todo_write` to plan multi-agent work.'
+                : hasHandoff
+                    ? 'Use `handoff` to transfer control to another agent in this thread.'
+                    : '';
+            agentDetails.instructions += `\n\n${header}\n${agentsList}${usage ? `\n\n${usage}` : ''}`;
         }
     }
     catch (error) {

package/dist/harness/todo-advance.js

@@ -0,0 +1,93 @@
+/** Stored on each todo and inlined into the next assignee's invoke payload. */
+const RESULT_MAX_CHARS = 12000;
+/**
+ * Shared helpers that drive the autonomous todo loop. The queue processor
+ * calls `advanceAfterRun` once per `agent:run:end`; that is the only place
+ * todos are completed and dispatched, which keeps the autonomous flow
+ * single-threaded and easy to reason about.
+ */
+export const readTodosFromState = (state) => {
+    const raw = state?.todos;
+    return Array.isArray(raw) ? raw : [];
+};
+export function truncateTodoResult(text, maxChars = RESULT_MAX_CHARS) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
+}
+/**
+ * Apply a single advance step:
+ *  1. If a todo is `in_progress` and `assignee` matches the agent whose run
+ *     just ended, mark it `done` and attach `result` from `lastOutput` when present.
+ *  2. Pick the next `pending` todo with an `assignee` and flip it to
+ *     `in_progress`. That assignee gets handed off to; `invoke content` includes
+ *     the previous step output when available so agents without short-term
+ *     history still see prior work.
+ *
+ * If a todo is already `in_progress` and the just-ended agent wasn't its
+ * assignee, leave it alone — someone else is working.
+ */
+export function advanceTodos(todos, endedAgentId, lastOutput) {
+    const now = Date.now();
+    const truncated = truncateTodoResult(lastOutput ?? '');
+    let completedOutput;
+    let working = todos.map((t) => {
+        if (t.status === 'in_progress' && t.assignee === endedAgentId) {
+            completedOutput = truncated;
+            return {
+                ...t,
+                status: 'done',
+                updatedAt: now,
+                ...(truncated !== undefined ? { result: truncated } : {}),
+            };
+        }
+        return t;
+    });
+    if (working.some((t) => t.status === 'in_progress')) {
+        return { todos: working, handoff: null };
+    }
+    const idx = working.findIndex((t) => t.status === 'pending' && t.assignee);
+    if (idx === -1)
+        return { todos: working, handoff: null };
+    const picked = working[idx];
+    working = working.map((t, i) => i === idx ? { ...t, status: 'in_progress', updatedAt: now } : t);
+    const invokeContent = completedOutput !== undefined && completedOutput !== ''
+        ? `${picked.content}\n\n--- Output from previous step ---\n${completedOutput}`
+        : picked.content;
+    return {
+        todos: working,
+        handoff: {
+            agentId: picked.assignee,
+            content: invokeContent,
+            todoId: picked.id,
+        },
+    };
+}
+export async function advanceAfterRun(options) {
+    const { storage, channelId, threadId, endedAgentId, lastAgentOutput } = options;
+    if (!threadId)
+        return null;
+    const details = await storage.getThreadDetails({ channelId, threadId });
+    const todos = readTodosFromState(details?.state);
+    if (todos.length === 0)
+        return null;
+    const { todos: nextList, handoff } = advanceTodos(todos, endedAgentId, lastAgentOutput);
+    const changed = nextList.length !== todos.length ||
+        nextList.some((t, i) => {
+            const u = todos[i];
+            if (!u)
+                return true;
+            return (t.status !== u.status ||
+                t.updatedAt !== u.updatedAt ||
+                t.result !== u.result ||
+                t.assignee !== u.assignee ||
+                t.content !== u.content);
+        });
+    if (changed) {
+        await storage.patchThreadState({ channelId, threadId, state: { todos: nextList } });
+    }
+    return handoff;
+}

package/dist/plugins/ai-sdk/index.js

@@ -1,5 +1,4 @@
 import { aiSdkRuntime } from './runtime.js';
-import { AI_SDK_SYSTEM_PROMPT } from './system-prompt.js';
 /**
  * `ai-sdk` — generic LLM runtime plugin built on the Vercel AI SDK.
  *
@@ -11,7 +10,6 @@ export const aiSdkPlugin = {
     id: 'ai-sdk',
     name: 'AI SDK Runtime',
     description: 'Generic LLM runtime built on the Vercel AI SDK. Consumes tools contributed by other plugins.',
-    defaultInstructions: AI_SDK_SYSTEM_PROMPT,
     configSchema: {
         type: 'object',
         properties: {
@@ -28,7 +26,6 @@ export const aiSdkPlugin = {
             : 'openai/gpt-4o-mini';
         return aiSdkRuntime({
             model,
-            system: agentDetails.instructions || AI_SDK_SYSTEM_PROMPT,
             storage,
             toolDefinitions: tools,
         });