@ziggs-ai/agent-sdk 0.1.3 → 0.1.5

package/src/adapters/OpenAIAdapter.js

@@ -1,73 +0,0 @@
-import OpenAI from "openai";
-
-export class OpenAIAdapter {
-  constructor({key, model = "gpt-4o-mini"}) {
-    this.client = new OpenAI({apiKey: key});
-    this.model = model;
-  }
-
-  /**
-   * Single-turn chat. `prompt` is a string; wraps it as a user message.
-   * Kept for backward compatibility.
-   */
-  async chat(prompt, tools = [], temperature = 0.2, systemHints = [], options = {}) {
-    const messages = [
-      { role: "system", content: "Respond with valid JSON." },
-      ...systemHints,
-      { role: "user", content: prompt }
-    ];
-    return this.chatMessages(messages, tools, options);
-  }
-
-  /**
-   * Low-level chat that accepts a full messages array.
-   * Returns { content, tool_calls, message } where message is the raw assistant message.
-   */
-  async chatMessages(messages, tools = [], options = {}) {
-    const openAITools = tools.length > 0
-      ? tools.map(t => {
-          const schema = t.schema || t;
-          const fn = schema.function || schema;
-          const usageWhen = t.usage?.when ? ` Use when: ${t.usage.when}` : '';
-          return {
-            type: 'function',
-            function: {
-              ...fn,
-              description: (fn.description || '') + usageWhen
-            }
-          };
-        })
-      : undefined;
-
-    try {
-      const res = await this.client.chat.completions.create({
-        model: this.model,
-        messages,
-        max_completion_tokens: 3000,
-        response_format: openAITools ? undefined : (options.response_format ?? { type: 'json_object' }),
-        ...(openAITools && { tools: openAITools }),
-        ...options,
-        usage: undefined,  // strip internal field if accidentally passed
-      });
-
-      const msg = res.choices[0].message;
-      return {
-        content: msg.content?.trim() ?? null,
-        tool_calls: msg.tool_calls?.length ? msg.tool_calls : null,
-        message: msg,
-        usage: res.usage,
-      };
-    } catch (error) {
-      console.error(`❌ [OpenAIAdapter] LLM API call failed: ${error.message}`, {
-        model: this.model,
-        error: error.message,
-        errorType: error.constructor?.name || 'Error',
-        status: error.status || error.statusCode || 'unknown',
-        code: error.code || 'unknown',
-        ...(error.response && { response: error.response }),
-        stack: error.stack
-      });
-      throw error;
-    }
-  }
-}

package/src/agent/Agent.js

@@ -1,121 +0,0 @@
-import { runTurn } from '../cognition/runTurn.js';
-import { OutboxBuffer } from './OutboxBuffer.js';
-import { EventQueue } from './EventQueue.js';
-import { WorkflowRuntime } from '../workflow/WorkflowRuntime.js';
-import { normalizeIncomingEvent } from '../ingress/normalizeIncoming.js';
-
-/**
- * Orchestrates one workflow instance per lane (ownAgentId:chatId).
- * Each lane gets an AgentMachine; thinking states invoke `runTurn`.
- */
-export class Agent {
-  constructor(options = {}) {
-    const {
-      llm, toolManager, contextReader, contextWriter,
-      taskService, messageSender, promptBuilder, operatorKey, agentId,
-    } = options;
-
-    if (!llm) throw new Error('Agent: llm is required');
-    if (!operatorKey) throw new Error('Agent: operatorKey is required');
-    if (!agentId) throw new Error('Agent: agentId is required');
-    if (!contextReader) throw new Error('Agent: contextReader is required');
-    if (!promptBuilder) throw new Error('Agent: promptBuilder is required');
-
-    this.ownAgentId = agentId;
-    this.messageBuffer = new OutboxBuffer();
-    this._laneMeta = new Map();
-    this.definition = options.workflow;
-    if (!this.definition?.states) throw new Error('Agent: workflow definition with states is required');
-
-    this._services = {
-      llm, toolManager, contextReader, contextWriter,
-      taskService, messageSender, messageBuffer: this.messageBuffer,
-      promptBuilder, operatorKey, agentId: this.ownAgentId,
-    };
-
-    this.runtime = new WorkflowRuntime({
-      definition: this.definition,
-      executionCore: runTurn,
-      services: this._services,
-      onSnapshot: (laneKey, snapshot) => this._onWorkflowChange(laneKey, snapshot),
-    });
-
-    this.eventQueue = new EventQueue((event, laneKey) => this._processEvent(event, laneKey));
-  }
-
-  async handleMessage(text, metadata = {}) {
-    const ownAgentId = this._resolveOwnAgentId(metadata);
-    const normalized = normalizeIncomingEvent({ text, metadata, ownAgentId });
-    if (!normalized.shouldProcess) {
-      console.log(`[Agent] Skip reason=${normalized.reason || 'not_relevant'} ownAgentId=${ownAgentId || 'unknown'}`);
-      return;
-    }
-    const chatId = normalized.chatId;
-    if (!chatId) { console.warn('[Agent] No chatId, skipping'); return; }
-
-    const laneKey = this._buildLaneKey(ownAgentId, chatId);
-    this._laneMeta.set(laneKey, { chatId, ownAgentId });
-    return this.eventQueue.enqueue(normalized.event, laneKey);
-  }
-
-  async _processEvent(event, laneKey) {
-    const meta = this._laneMeta.get(laneKey) || this._parseLaneKey(laneKey);
-    const chatId = meta?.chatId || null;
-    const ownAgentId = meta?.ownAgentId || this.ownAgentId || null;
-    if (!chatId) return;
-
-    await this.runtime.sendAndWaitForPark({
-      laneKey,
-      event: { type: 'INCOMING_EVENT', event, chatId, laneKey, ownAgentId },
-      timeoutMs: 120_000,
-      machineInput: { chatId, laneKey, ownAgentId },
-    });
-  }
-
-  _onWorkflowChange(laneKey, snapshot) {
-    if (!snapshot.context) return;
-    const machine = this.runtime.actors.get(laneKey);
-    if (!machine) return;
-
-    const prev = machine._prevSnapshot;
-    machine._prevSnapshot = snapshot;
-    if (!prev) return;
-
-    const wasActive = !this._isParkedSnapshot(prev);
-    const nowParked = this._isParkedSnapshot(snapshot);
-
-    if (wasActive && nowParked) {
-      console.log(`[workflow] parked laneKey=${laneKey} state=${JSON.stringify(snapshot.value)}`);
-      this._trackMessages(snapshot);
-    }
-  }
-
-  _isParkedSnapshot(snapshot) {
-    const sd = this.definition.states[snapshot.value];
-    return !(sd?.prompt && sd?.actions);
-  }
-
-  _trackMessages(snapshot) {
-    const ctx = snapshot.context;
-    if (!ctx?.chatId || !ctx.messageSent) return;
-    const r = ctx.lastActionResult;
-    if (r?.type === 'message_sent') {
-      this.messageBuffer.track(r.chatId || ctx.chatId, { text: r.message, receiverId: r.receiverId });
-    }
-  }
-
-  _resolveOwnAgentId(metadata = {}) {
-    return this.ownAgentId || metadata.self?.id || metadata.agent?.id || metadata.ziggsAgentId || null;
-  }
-
-  _buildLaneKey(ownAgentId, chatId) {
-    return `${ownAgentId || 'unknown-agent'}:${chatId}`;
-  }
-
-  _parseLaneKey(laneKey) {
-    if (!laneKey || typeof laneKey !== 'string') return null;
-    const idx = laneKey.lastIndexOf(':');
-    if (idx === -1) return { ownAgentId: null, chatId: laneKey };
-    return { ownAgentId: laneKey.slice(0, idx) || null, chatId: laneKey.slice(idx + 1) || null };
-  }
-}

package/src/agent/EventQueue.js

@@ -1,68 +0,0 @@
-/**
- * Serializes and coalesces events per lane to prevent duplicate LLM turns.
- */
-
-export class EventQueue {
-  constructor(processEventFn) {
-    this._processEvent = processEventFn;
-    /** @type {Map<string, { events: object[], processing: boolean }>} */
-    this._state = new Map();
-  }
-
-  enqueue(event, laneKey) {
-    if (!laneKey) {
-      console.warn('[EventQueue] enqueue called without laneKey, skipping');
-      return Promise.resolve();
-    }
-
-    let state = this._state.get(laneKey);
-    if (!state) {
-      state = { events: [], processing: false };
-      this._state.set(laneKey, state);
-    }
-
-    return new Promise((resolve) => {
-      state.events.push({ event, resolve });
-      console.log(`[EventQueue] enqueue laneKey=${laneKey}, queueLen=${state.events.length}, processing=${state.processing}`);
-      this._processIfNeeded(laneKey);
-    });
-  }
-
-  _processIfNeeded(laneKey) {
-    const state = this._state.get(laneKey);
-    if (!state || state.processing || state.events.length === 0) {
-      return;
-    }
-
-    state.processing = true;
-    this._processLoop(laneKey);
-  }
-
-  async _processLoop(laneKey) {
-    const state = this._state.get(laneKey);
-    if (!state) return;
-
-    while (state.events.length > 0) {
-      const batch = state.events.splice(0, state.events.length);
-      const events = batch.map(e => e.event);
-      const resolvers = batch.map(e => e.resolve);
-
-      const coalesced = events.length === 1
-        ? events[0]
-        : { type: 'batch', events };
-
-      try {
-        await this._processEvent(coalesced, laneKey);
-      } catch (error) {
-        console.error(`[EventQueue] processEvent error for laneKey=${laneKey}:`, error.message);
-        console.error(error.stack);
-      }
-
-      // Resolve all waiters for this batch (success or failure)
-      for (const r of resolvers) r();
-    }
-
-    state.processing = false;
-    console.log(`[EventQueue] processLoop done laneKey=${laneKey}`);
-  }
-}

package/src/agent/OutboxBuffer.js

@@ -1,62 +0,0 @@
-/**
- * Tracks outbound messages locally until server history syncs, then merges into read context.
- */
-
-export class OutboxBuffer {
-  constructor() {
-    this._pending = new Map();
-  }
-
-  track(chatId, { text, receiverId }) {
-    if (!this._pending.has(chatId)) {
-      this._pending.set(chatId, []);
-    }
-    this._pending.get(chatId).push({
-      text,
-      receiverId,
-      timestamp: Date.now()
-    });
-    console.log(`[OutboxBuffer] track: chatId=${chatId}, pending=${this._pending.get(chatId).length}, text="${text.slice(0, 60)}..."`);
-  }
-
-  merge(chatId, history, agentId) {
-    const pending = this._pending.get(chatId);
-    console.log(`[OutboxBuffer] merge: chatId=${chatId}, pending=${pending?.length || 0}, historyLen=${history.length}, agentId=${agentId}`);
-    if (!pending || pending.length === 0) return;
-
-    const matchedIndices = new Set();
-    const remaining = [];
-
-    for (const msg of pending) {
-      const matchIdx = history.findIndex((entry, idx) =>
-        !matchedIndices.has(idx) &&
-        entry.text === msg.text &&
-        entry.sender?.id === agentId
-      );
-
-      if (matchIdx !== -1) {
-        matchedIndices.add(matchIdx);
-      } else {
-        remaining.push(msg);
-      }
-    }
-
-    for (const msg of remaining) {
-      history.push({
-        entryType: 'message',
-        text: msg.text,
-        sender: { id: agentId, type: 'agent' },
-        receiver: { id: msg.receiverId },
-        timestamp: msg.timestamp
-      });
-    }
-
-    console.log(`[OutboxBuffer] merge result: matched=${pending.length - remaining.length}, appended=${remaining.length}, newHistoryLen=${history.length}`);
-
-    if (remaining.length === 0) {
-      this._pending.delete(chatId);
-    } else {
-      this._pending.set(chatId, remaining);
-    }
-  }
-}

package/src/cognition/PromptBuilder.js

@@ -1,312 +0,0 @@
-import { HistoryFormatter, TaskFormatter } from '../formatters/index.js';
-import { resolveActionTool } from './resolveActionTool.js';
-
-/**
- * Builds agent prompts from state/action definitions (`buildFromState`).
- *
- * Prompt structure:
- *   <agent>
- *     <self>identity + state prompt</self>
- *     <world>event + history + tasks + recipients</world>
- *     <decision_schema>actions with prompts</decision_schema>
- *   </agent>
- */
-export class PromptBuilder {
-  constructor(options = {}) {
-    this.description = options.description || 'A capable agent ready to assist';
-    this.specialization = options.specialization || null;
-    this.maxHistoryEntries = options.maxHistoryEntries ?? 50;
-    this.historyFormatter = options.historyFormatter || new HistoryFormatter();
-    this.taskFormatter = options.taskFormatter || new TaskFormatter();
-  }
-
-  buildFromState({
-    statePrompt, actions, serverContext, incomingEvent, definition, chatId,
-    stateId, machineContext,
-  }) {
-    const ctx = serverContext?.context || serverContext || {};
-    const agentId = this._getMyAgentId(ctx);
-    const senderMeta = this._getSenderMeta(incomingEvent, ctx);
-    const allTasks = ctx.activeTasks || [];
-    const otherAgents = (ctx.agents || []).filter(a => !a.isYou);
-    const users = ctx.users || [];
-    const desc = definition?.description || this.description;
-
-    const prompt = `<agent>
-
-${this._renderSelfFromState(desc, statePrompt, serverContext?.tools)}
-
-${this._renderWorld(incomingEvent, ctx, agentId, senderMeta, allTasks, otherAgents, users, stateId, machineContext)}
-
-${this._renderDecisionSchemaFromActions(actions, senderMeta, ctx)}
-
-</agent>`;
-
-    return prompt;
-  }
-
-  _renderSelfFromState(description, statePrompt, tools) {
-    const lines = ['<self>'];
-    lines.push(`<identity>\nYou are an Autonomous Agent.\n${description}\n</identity>`);
-
-    lines.push('\n<state>');
-    if (statePrompt.role) lines.push(`Role: ${statePrompt.role}`);
-    if (statePrompt.goal) lines.push(`Goal: ${statePrompt.goal}`);
-    if (statePrompt.context) lines.push(`Context: ${statePrompt.context}`);
-    if (statePrompt.constraints) lines.push(`Constraints: ${statePrompt.constraints}`);
-    lines.push('</state>');
-
-    if (tools?.length) {
-      lines.push('\n<tools>');
-      for (const tool of tools) {
-        const fn = tool.schema?.function || tool.schema;
-        const name = fn?.name;
-        const desc = fn?.description;
-        if (name) lines.push(`- ${name}${desc ? ': ' + desc : ''}`);
-      }
-      lines.push('</tools>');
-    }
-
-    lines.push('</self>');
-    return lines.join('\n');
-  }
-
-  _renderWorld(event, ctx, agentId, senderMeta, allTasks, otherAgents, users, stateId, machineContext) {
-    const lines = ['<world>'];
-
-    const machineBlock = this._renderMachineContext(stateId, machineContext);
-    if (machineBlock) {
-      lines.push(machineBlock);
-      lines.push('');
-    }
-
-    lines.push(this._renderEvent(event, senderMeta));
-    lines.push('');
-    lines.push(this._renderHistory(ctx.history, agentId));
-    lines.push('');
-    lines.push(this._renderTasks(allTasks, agentId));
-
-    if (users.length > 0 || otherAgents.length > 0) {
-      lines.push('');
-      lines.push(this._renderRecipients(users, otherAgents));
-    }
-
-    lines.push(`\n<context>\n  currentTime: ${new Date().toISOString()}\n</context>`);
-    lines.push('</world>');
-    return lines.join('\n');
-  }
-
-  _renderMachineContext(stateId, machineContext) {
-    const picked = pickAllowedMachineFields(stateId, machineContext);
-    if (!picked) return '';
-    const json = JSON.stringify(picked, null, 2);
-    return `<machine_context>\n${json}\n</machine_context>`;
-  }
-
-  _renderEvent(event, senderMeta) {
-    if (!event) return '<event type="none">No incoming event.</event>';
-
-    if (event.type === 'batch' && Array.isArray(event.events) && event.events.length > 0) {
-      const parts = event.events.map((e, i) => {
-        const sub = { ...senderMeta, senderId: e.senderId ?? senderMeta.senderId, senderType: e.senderType ?? senderMeta.senderType };
-        return (i > 0 ? '\n---\n' : '') + this._renderEvent(e, sub);
-      });
-      return `<event type="batch" count="${event.events.length}">\n${parts.join('')}\n</event>`;
-    }
-
-    const eventType = event.type || 'message';
-    const from = `${senderMeta.senderId} (${(senderMeta.senderType || 'unknown').toLowerCase()})`;
-
-    if (eventType === 'task_result' && event.result?.taskId) {
-      return this._renderTaskResultEvent(event.result, from);
-    }
-    if (eventType === 'tool_result') {
-      const r = typeof event.result === 'object' ? JSON.stringify(event.result, null, 2) : String(event.result);
-      return `<event type="${eventType}" from="${from}">\nTool: ${event.tool}\nResult:\n${r}\n</event>`;
-    }
-    if (eventType === 'tool_error') {
-      return `<event type="${eventType}" from="${from}">\nTool Error: ${event.tool}\nMessage: ${event.error}\n</event>`;
-    }
-    if (eventType === 'message_sent') {
-      return `<event type="${eventType}" from="${from}">\nYour message was delivered. Do not repeat it.\n</event>`;
-    }
-
-    const content = event.text || event.result || event.content;
-    if (!content) return `<event type="${eventType}" from="${from}">(Empty)</event>`;
-    const str = typeof content === 'object' ? JSON.stringify(content) : content;
-    const display = str.length > 1000 ? str.slice(0, 1000) + '...' : str;
-    return `<event type="${eventType}" from="${from}">\n${display}\n</event>`;
-  }
-
-  _renderTaskResultEvent(task, from) {
-    const lines = [];
-    if (task.agentIdIsYou) { lines.push('YOUR TASK'); lines.push(''); }
-    lines.push(`Task: ${task.description}`);
-    lines.push(`ID: ${task.taskId}`);
-    lines.push(`State: ${task.state}`);
-    lines.push(`Owner: ${task.agentId}${task.agentIdIsYou ? ' (You)' : ''}`);
-    lines.push(`Executor: ${task.executorId}${task.executorIdIsYou ? ' (You)' : ''}`);
-    if (task.proposal) {
-      lines.push(`Proposal: ${task.proposal.status} (to ${task.proposal.proposedTo}${task.proposedToIsYou ? ' - You' : ''})`);
-    }
-    if (task.parentTaskId) lines.push(`Parent: ${task.parentTaskId}`);
-
-    if (task.contract?.specialistAgentId) {
-      lines.push(`contract.specialistAgentId: ${task.contract.specialistAgentId}`);
-    }
-    if (Array.isArray(task.contract?.specialistAgentIds) && task.contract.specialistAgentIds.length > 0) {
-      lines.push(`contract.specialistAgentIds: ${task.contract.specialistAgentIds.join(', ')}`);
-    }
-
-    if (task.state === 'proposal' && task.proposal?.status === 'pending' && (task.proposedToIsYou || task.proposal?.proposedTo === 'everyone')) {
-      lines.push('');
-      lines.push(`Action: Use task_respond_proposal with taskId="${task.taskId}" and action approve or reject.`);
-    }
-
-    return `<event type="task_result" from="${from}"${task.agentIdIsYou ? ' own_task="true"' : ''}>\n${lines.join('\n')}\n</event>`;
-  }
-
-  _renderHistory(history, agentId) {
-    let entries = history || [];
-    let truncNote = '';
-    if (entries.length > this.maxHistoryEntries) {
-      truncNote = `[Showing last ${this.maxHistoryEntries} of ${entries.length} entries]\n\n`;
-      entries = entries.slice(-this.maxHistoryEntries);
-    }
-    const formatted = this.historyFormatter.format(entries, agentId, {});
-    return `<history>\n${truncNote}${formatted}\n</history>`;
-  }
-
-  _renderTasks(tasks, agentId) {
-    const formatted = this.taskFormatter.format(tasks || [], agentId);
-    return `<tasks>\n${formatted}\n</tasks>`;
-  }
-
-  _renderRecipients(users, otherAgents) {
-    const lines = ['<recipients>'];
-    if (users.length > 0) {
-      lines.push('<users>');
-      users.forEach(u => lines.push(`  - ${u.userName || u.userId} (${u.userId})`));
-      lines.push('</users>');
-    }
-    if (otherAgents.length > 0) {
-      lines.push('<agents>');
-      otherAgents.forEach(a => {
-        const desc = a.description ? `: ${a.description.slice(0, 80)}` : '';
-        const caps = a.capabilities && Object.keys(a.capabilities).length > 0
-          ? ` [capabilities: ${JSON.stringify(a.capabilities)}]`
-          : '';
-        lines.push(`  - ${a.name || a.agentId} (${a.agentId})${desc}${caps}`);
-      });
-      lines.push('</agents>');
-    }
-    if (users.length === 0 && otherAgents.length === 0) {
-      lines.push('No other recipients available.');
-    }
-    lines.push('</recipients>');
-    return lines.join('\n');
-  }
-
-  _renderDecisionSchemaFromActions(actions, senderMeta, ctx) {
-    const lines = ['<decision_schema>'];
-    lines.push('Return ONE JSON object. ALWAYS include "thought" as the FIRST field — briefly explain your reasoning before choosing an action.');
-    lines.push('Set "action" to exactly one of the action names below.\n');
-
-    const replyTo = senderMeta.defaultReplyReceiverId || '<receiverId>';
-    const pendingProposals = (ctx.activeTasks || []).filter(
-      t => t.state === 'proposal' && t.proposal?.status === 'pending' && (t.proposedToIsYou || t.proposal?.proposedTo === 'everyone')
-    );
-
-    if (pendingProposals.length > 0) {
-      lines.push(`PRIORITY: You have ${pendingProposals.length} pending proposal(s) directed at you. Respond BEFORE other actions.`);
-      lines.push(`{"thought": "...", "action": "<action_bound_to_task_respond_proposal>", "args": {"taskId": "<id>", "action": "approve|reject"}}\n`);
-    }
-
-    for (const [name, actionDef] of Object.entries(actions)) {
-      lines.push(`─── "${name}" ───`);
-      if (actionDef.prompt?.when) lines.push(`Use when: ${actionDef.prompt.when}`);
-      if (actionDef.prompt?.instruction) lines.push(`Instruction: ${actionDef.prompt.instruction}`);
-      if (actionDef.prompt?.format) lines.push(`Format: ${actionDef.prompt.format}`);
-
-      const boundTool = resolveActionTool(actionDef, name);
-      if (boundTool) {
-        lines.push(`Tool: ${boundTool}`);
-        lines.push(`Response: {"thought": "...", "action": "${name}", "args": {...}}`);
-      } else {
-        lines.push(this._buildActionSchema(name, replyTo));
-      }
-
-      if (actionDef.prompt?.examples?.length) {
-        lines.push('Examples:');
-        for (const ex of actionDef.prompt.examples) {
-          const desc = ex.scenario || ex.input || '';
-          const out = ex.output || ex.query || '';
-          lines.push(`  - ${desc}${out ? ' → ' + out : ''}`);
-        }
-      }
-
-      lines.push('');
-    }
-
-    lines.push('</decision_schema>');
-    return lines.join('\n');
-  }
-
-  _buildActionSchema(name, replyTo) {
-    if (name === 'wait') {
-      return `Response: {"thought": "...", "action": "${name}"}`;
-    }
-    return `Response: {"thought": "...", "action": "${name}", "receiverId": "${replyTo}", "message": "..."}`;
-  }
-
-  _getSenderMeta(event, ctx) {
-    const senderId = event?.senderId || 'system';
-    const senderType = event?.senderType ? event.senderType.toUpperCase() : 'SYSTEM';
-    const myId = this._getMyAgentId(ctx);
-
-    let defaultReplyReceiverId = senderId;
-    const isNonRoutable = !senderId || senderId === 'system' || senderType === 'SERVICE';
-    if (isNonRoutable) {
-      const history = ctx.history || [];
-      for (let i = history.length - 1; i >= 0; i--) {
-        const id = history[i].sender?.id || history[i].senderId;
-        const type = (history[i].sender?.type || history[i].senderType || '').toUpperCase();
-        if (id && id !== 'system' && id !== myId && type !== 'SERVICE') {
-          defaultReplyReceiverId = id;
-          break;
-        }
-      }
-    }
-
-    return { senderId, senderType, myAgentId: myId, defaultReplyReceiverId: defaultReplyReceiverId || senderId };
-  }
-
-  _getMyAgentId(ctx) {
-    const agents = ctx.agents || [];
-    const me = agents.find(a => a.isYou);
-    return me?.agentId || null;
-  }
-}
-
-const MACHINE_CONTEXT_KEYS = [
-  'chatId', 'laneKey', 'ownAgentId', 'activeTaskId', 'pendingProposalId', 'perspectiveId',
-  'delegatedTaskIds', 'orchestrationSpecialistAgentId', 'orchestrationSpecialistAgentIds',
-  'orchestrationActiveStepIndex', 'orchestrationContinueChain', 'lastError', 'lastAction',
-];
-
-function pickAllowedMachineFields(stateId, machineContext) {
-  if (!machineContext || typeof machineContext !== 'object') {
-    return stateId != null ? { stateId } : null;
-  }
-  const out = {};
-  if (stateId != null) out.stateId = stateId;
-  for (const k of MACHINE_CONTEXT_KEYS) {
-    const v = machineContext[k];
-    if (v !== undefined && v !== null) out[k] = v;
-  }
-  if (machineContext.incomingEvent != null) {
-    const ev = machineContext.incomingEvent;
-    out.incomingEventType = typeof ev === 'object' && ev && ev.type != null ? String(ev.type) : '(present)';
-  }
-  return Object.keys(out).length ? out : null;
-}

package/src/cognition/resolveActionTool.js

@@ -1,12 +0,0 @@
-/**
- * Each action may bind at most one registered tool. Args are chosen by the LLM;
- * the tool name is fixed by the action definition's explicit `tool` property.
- */
-
-export function resolveActionTool(actionDef, actionKey) {
-  if (!actionDef) return null;
-  if (actionDef.tool === null) return null;
-  if (typeof actionDef.tool === 'string') return actionDef.tool;
-  if (Array.isArray(actionDef.tools) && actionDef.tools.length >= 1) return actionDef.tools[0];
-  return null;
-}