@ziggs-ai/agent-sdk 0.1.11 → 0.2.0

package/src/adapters/OpenAIAdapter.ts

@@ -1,187 +0,0 @@
-import OpenAI from 'openai';
-import type { ToolDefinition } from '../tools/defineTool.js';
-import { runtimeLog } from '../shared/runtimeLog.js';
-
-interface ChatResult {
-  content: string | null;
-  tool_calls: OpenAI.Chat.ChatCompletionMessageToolCall[] | null;
-  message: OpenAI.Chat.ChatCompletionMessage;
-  usage: OpenAI.CompletionUsage | undefined;
-}
-
-interface AdapterOptions {
-  key?: string;
-  model?: string;
-}
-
-/** OpenAI completion-token cap varies by model family (e.g. gpt-4o-mini max 16384). */
-export function maxCompletionTokensForModel(model: string): number {
-  const m = model.toLowerCase();
-  if (m.includes('gpt-4o')) return 16384;
-  return 25000;
-}
-
-export class OpenAIAdapter {
-  private client: OpenAI;
-  model: string;
-
-  constructor({ key, model = 'gpt-5.4' }: AdapterOptions) {
-    this.client = new OpenAI({ apiKey: key });
-    this.model = model;
-  }
-
-  async chat(
-    prompt: string,
-    tools: ToolDefinition[] = [],
-    temperature = 0.2,
-    systemHints: OpenAI.Chat.ChatCompletionMessageParam[] = [],
-    options: Record<string, unknown> = {},
-  ): Promise<ChatResult> {
-    const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
-      { role: 'system', content: 'Respond with valid JSON.' },
-      ...systemHints,
-      { role: 'user', content: prompt },
-    ];
-    return this.chatMessages(messages, tools, { ...options, temperature });
-  }
-
-  async chatMessages(
-    messages: OpenAI.Chat.ChatCompletionMessageParam[],
-    tools: ToolDefinition[] = [],
-    options: Record<string, unknown> = {},
-  ): Promise<ChatResult> {
-    const openAITools: OpenAI.Chat.ChatCompletionTool[] | undefined = tools.length > 0
-      ? tools.map(t => {
-          const fn = (t.schema.function || t.schema) as Record<string, unknown>;
-          const tAny = t as unknown as Record<string, unknown>;
-          const usageWhen = tAny['usage']
-            ? ` Use when: ${(tAny['usage'] as Record<string, unknown>)['when']}`
-            : '';
-          return {
-            type: 'function' as const,
-            function: {
-              name: fn['name'] as string,
-              description: ((fn['description'] as string) || '') + usageWhen,
-              parameters: fn['parameters'] as Record<string, unknown>,
-            },
-          };
-        })
-      : undefined;
-
-    try {
-      const { usage: _u, response_format: _explicitResponseFormat, ...restOptions } = options as Record<string, unknown>;
-      const responseFormat = openAITools
-        ? undefined
-        : ((_explicitResponseFormat as OpenAI.ResponseFormatJSONObject) ?? { type: 'json_object' });
-
-      // OpenAI 400s response_format:{type:'json_object'} unless the word "json"
-      // appears somewhere in the messages. Callers are expected to mention it
-      // in their system prompt, but that's an implicit cross-file contract —
-      // guarantee it here instead of trusting every call site to remember.
-      let finalMessages = messages;
-      if (
-        responseFormat?.type === 'json_object' &&
-        !messages.some(m => {
-          const c = typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '');
-          return /json/i.test(c);
-        })
-      ) {
-        finalMessages = [...messages, { role: 'system', content: 'Respond with valid JSON.' }];
-      }
-
-      // Verbose LLM request/response logging — enabled for debugging.
-      // Comment out again to reduce log noise.
-      const divider = '─'.repeat(80);
-      console.log(`\n${divider}`);
-      console.log(`📤 LLM REQUEST → ${this.model}  (${finalMessages.length} msg${finalMessages.length === 1 ? '' : 's'})`);
-      console.log(divider);
-      for (const m of finalMessages) {
-        const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-        const len = content?.length ?? 0;
-        console.log(`\n[${m.role.toUpperCase()}]  ${len} chars`);
-        console.log(content ?? '');
-      }
-      console.log(`${divider}\n`);
-      const res = await this.client.chat.completions.create({
-        model: this.model,
-        messages: finalMessages,
-        stream: false,
-        // Reasoning models (gpt-5.x/o-series) need a high cap for hidden
-        // reasoning tokens; gpt-4o family is capped lower by the API.
-        max_completion_tokens: maxCompletionTokensForModel(this.model),
-        response_format: responseFormat,
-        ...(openAITools && { tools: openAITools }),
-        ...restOptions,
-      } as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming);
-
-      const msg = res.choices[0].message;
-      const finishReason = res.choices[0].finish_reason;
-      const content = msg.content?.trim() ?? null;
-      const toolCalls = msg.tool_calls?.length ? msg.tool_calls : null;
-      // Verbose LLM response logging — enabled for debugging.
-      // Comment out again to reduce log noise.
-      console.log(`\n${divider}`);
-      console.log(`📥 LLM RESPONSE ← ${this.model}  finish=${finishReason}`);
-      console.log(divider);
-      if (content) {
-        console.log(`\n[CONTENT]  ${content.length} chars`);
-        console.log(content);
-      }
-      if (toolCalls) {
-        console.log(`\n[TOOL CALLS]  ${toolCalls.length}`);
-        for (const tc of toolCalls) {
-          console.log(`  → ${tc.function.name}(${tc.function.arguments})`);
-        }
-      }
-      if (!content && !toolCalls) console.log('\n(no content, no tool calls)');
-      if (res.usage) {
-        const u = res.usage as OpenAI.CompletionUsage & { completion_tokens_details?: { reasoning_tokens?: number } };
-        console.log(`\n[USAGE]  prompt=${u.prompt_tokens} completion=${u.completion_tokens}${u.completion_tokens_details?.reasoning_tokens != null ? ` (reasoning=${u.completion_tokens_details.reasoning_tokens})` : ''} total=${u.total_tokens}`);
-      }
-      console.log(`${divider}\n`);
-      if (!content && !toolCalls && finishReason === 'length') {
-        const u = res.usage as (OpenAI.CompletionUsage & { completion_tokens_details?: { reasoning_tokens?: number } }) | undefined;
-        throw new Error(
-          `LLM returned no usable output — completion token budget exhausted before any content ` +
-          `(finish_reason=length, reasoning_tokens=${u?.completion_tokens_details?.reasoning_tokens ?? 'unknown'})`,
-        );
-      }
-      return {
-        content,
-        tool_calls: toolCalls,
-        message: msg,
-        usage: res.usage,
-      };
-    } catch (error) {
-      const err = error as Error & { status?: number; code?: string };
-      runtimeLog.error('OpenAIAdapter', `LLM API call failed: ${err.message}`, {
-        model: this.model,
-        error: err.message,
-        status: err.status || 'unknown',
-        code: err.code || 'unknown',
-      });
-      throw error;
-    }
-  }
-
-  async chatMessagesStream(
-    messages: OpenAI.Chat.ChatCompletionMessageParam[],
-    onChunk: (text: string) => void,
-  ): Promise<string> {
-    const stream = await this.client.chat.completions.create({
-      model: this.model,
-      messages,
-      stream: true,
-      max_completion_tokens: maxCompletionTokensForModel(this.model),
-    });
-    let text = '';
-    for await (const chunk of stream) {
-      const delta = chunk.choices[0]?.delta?.content;
-      if (delta) {
-        text += delta;
-        onChunk(delta);
-      }
-    }
-    return text;
-  }
-}

package/src/agent/Agent.ts

@@ -1,104 +0,0 @@
-import type { Ctx, Identity, Workflow, EffectHandler } from '../types.js';
-import { AgentMachine, type TransitionEvent } from '../runtime/AgentMachine.js';
-import { runTurn } from '../runtime/runTurn.js';
-import { PromptBuilder } from '../runtime/PromptBuilder.js';
-import type { MemoryStore } from '../memory/MemoryStore.js';
-import type { ToolManager } from '../tools/ToolManager.js';
-import type { RawEvent } from '../runtime/buildOutcome.js';
-
-export interface AgentOptions {
-  workflow: Workflow;
-  toolManager: ToolManager;
-  promptBuilder?: PromptBuilder;
-}
-
-export interface TickInput {
-  /** Wire event (already normalized: a `message` or `task_result`-style envelope). */
-  event: unknown;
-  /** Server-provided per-session state. Omit on the first tick — a fresh ctx is constructed. */
-  ctx?: Ctx;
-  /** Server-provided workflow state name. Omit on the first tick — defaults to `workflow.initial`. */
-  state?: string;
-  /** Who am I and what session am I running in. The Agent carries this through Ctx. */
-  identity: Identity;
-  /** The single side channel for I/O — LLM, context, tools, send, record. */
-  eff: EffectHandler;
-  /**
-   * Agent-private long-term memory. Operator-provided (default
-   * `InMemoryStore` when omitted by `AgentHost`). Key shape is the agent's
-   * choice — `counterparty:<id>`, `agreement:<id>:notes`, etc.
-   */
-  memory?: MemoryStore;
-  /** Optional tap for FSM transition events (ZIG-442). */
-  transitionTap?: (event: TransitionEvent) => void;
-}
-
-export interface TickOutput {
-  /** Updated ctx — Server persists this against the session. */
-  ctx: Ctx;
-  /** Workflow state name after the tick — Server persists this against the session. */
-  state: string;
-  /** Whether the machine settled at a parked state. */
-  parked: boolean;
-  /** True when a state-timeout outcome matched no transition this tick — the host must NOT re-arm. */
-  stateTimeoutUnhandled: boolean;
-  /** Accumulated LLM call count and token usage for this tick. */
-  metrics: { llmCalls: number; tokens: { total: number; input: number; output: number } };
-}
-
-/**
- * Pure agent: workflow definition + cognition machinery. No I/O, no transport,
- * no services. The Agent's only side channel is the `eff` handler it receives
- * on each `tick`. Server-side state (sessions, lanes, queue, outbox) lives in
- * `AgentHost` — not here.
- *
- * The contract:
- *
- *   `tick({ event, ctx, state, identity, eff })` →
- *   `{ ctx, state, parked }`
- *
- * Reads top-to-bottom like a synchronous function. Every `await eff(...)`
- * inside the cognition core is a yield to the Server, which performs the
- * impure operation and resumes the Agent with the result.
- */
-export class Agent {
-  workflow: Workflow;
-  toolManager: ToolManager;
-  promptBuilder: PromptBuilder;
-
-  constructor({ workflow, toolManager, promptBuilder }: AgentOptions) {
-    if (!workflow?.states) throw new Error('Agent: workflow with states is required');
-    if (!toolManager) throw new Error('Agent: toolManager is required');
-    this.workflow = workflow;
-    this.toolManager = toolManager;
-    this.promptBuilder = promptBuilder || new PromptBuilder();
-  }
-
-  async tick({ event, ctx, state, identity, eff, memory, transitionTap }: TickInput): Promise<TickOutput> {
-    if (!identity?.sessionId) throw new Error('Agent.tick: identity.sessionId is required');
-    if (!eff) throw new Error('Agent.tick: eff is required');
-
-    const machine = new AgentMachine({
-      workflow: this.workflow,
-      executionCore: runTurn,
-      eff,
-      toolManager: this.toolManager,
-      promptBuilder: this.promptBuilder,
-      memory,
-      input: { identity, ctx, state },
-      transitionTap,
-    });
-
-    // `send` awaits the recursive _step until the machine settles at a
-    // parked state (or stops). When it returns, we have the final state.
-    await machine.send({ event: event as RawEvent | undefined, identity });
-
-    return {
-      ctx: machine.ctx,
-      state: machine.state,
-      parked: machine.isParked,
-      stateTimeoutUnhandled: machine.stateTimeoutUnhandled,
-      metrics: { llmCalls: machine.llmCalls, tokens: machine.tokens },
-    };
-  }
-}

package/src/cognition/validateContext.ts

@@ -1,95 +0,0 @@
-export class ContextWarning {
-  constructor(public path: string, public message: string) {}
-  toString(): string { return `[context] ${this.path}: ${this.message}`; }
-}
-
-type WarnFn = (path: string, msg: string) => void;
-
-export function validateContext(
-  ctx: unknown,
-  { logger }: { logger?: { warn: (msg: string) => void } } = {},
-): ContextWarning[] {
-  const warnings: ContextWarning[] = [];
-  const warn: WarnFn = (path, msg) => warnings.push(new ContextWarning(path, msg));
-
-  if (!ctx || typeof ctx !== 'object') {
-    warn('context', 'missing or not an object');
-    return warnings;
-  }
-
-  const c = ctx as Record<string, unknown>;
-  validateAgreements(c['agreements'], warn);
-  validateAgents(c['agents'], warn);
-  validateHistory(c['history'], warn);
-  validateUsers(c['users'], warn);
-
-  if (logger && warnings.length > 0) {
-    for (const w of warnings) logger.warn(w.toString());
-  }
-  return warnings;
-}
-
-function validateAgreements(agreements: unknown, warn: WarnFn): void {
-  if (!Array.isArray(agreements)) return;
-  for (let i = 0; i < agreements.length; i++) {
-    const ag = agreements[i] as Record<string, unknown>;
-    const path = `agreements[${i}]`;
-    if (!ag || typeof ag !== 'object') { warn(path, 'not an object'); continue; }
-    for (const key of ['agreementId', 'parties']) {
-      if (ag[key] == null) warn(`${path}.${key}`, 'missing');
-    }
-    if (ag['parties'] && typeof ag['parties'] === 'object') {
-      const parties = ag['parties'] as Record<string, unknown>;
-      for (const key of ['creator', 'provider']) {
-        if (!parties[key]) warn(`${path}.parties.${key}`, 'missing');
-      }
-    }
-    if (ag['proposal'] && typeof ag['proposal'] === 'object') {
-      if (!(ag['proposal'] as Record<string, unknown>)['status']) warn(`${path}.proposal.status`, 'missing');
-    }
-    if (ag['task'] && typeof ag['task'] === 'object') {
-      const t = ag['task'] as Record<string, unknown>;
-      if (!t['taskId']) warn(`${path}.task.taskId`, 'missing');
-      if (!t['state']) warn(`${path}.task.state`, 'missing');
-    }
-  }
-}
-
-function validateAgents(agents: unknown, warn: WarnFn): void {
-  if (!Array.isArray(agents)) return;
-  let youCount = 0;
-  for (let i = 0; i < agents.length; i++) {
-    const agent = agents[i] as Record<string, unknown>;
-    const path = `agents[${i}]`;
-    if (!agent || typeof agent !== 'object') { warn(path, 'not an object'); continue; }
-    if (!agent['agentId']) warn(`${path}.agentId`, 'missing');
-    if (agent['isYou']) youCount++;
-  }
-  if (agents.length > 0 && youCount === 0) warn('agents', 'no agent has isYou=true — agent identity will be unknown');
-  if (youCount > 1) warn('agents', `${youCount} agents have isYou=true — should be exactly 1`);
-}
-
-function validateHistory(history: unknown, warn: WarnFn): void {
-  if (!Array.isArray(history)) return;
-  for (let i = 0; i < history.length; i++) {
-    const entry = history[i] as Record<string, unknown>;
-    const path = `history[${i}]`;
-    if (!entry || typeof entry !== 'object') { warn(path, 'not an object'); continue; }
-    if (!entry['entryType'] && entry['entryType'] !== 0) warn(`${path}.entryType`, 'missing');
-    if (entry['entryType'] === 'message' && !entry['sender']) warn(`${path}.sender`, 'missing for message entry');
-    if (entry['entryType'] === 'task_history') {
-      const svc = entry['service'] as Record<string, unknown> | undefined;
-      if (!svc?.['task']) warn(`${path}.service.task`, 'missing for task_history entry');
-    }
-  }
-}
-
-function validateUsers(users: unknown, warn: WarnFn): void {
-  if (!Array.isArray(users)) return;
-  for (let i = 0; i < users.length; i++) {
-    const user = users[i] as Record<string, unknown>;
-    const path = `users[${i}]`;
-    if (!user || typeof user !== 'object') { warn(path, 'not an object'); continue; }
-    if (!user['userId']) warn(`${path}.userId`, 'missing');
-  }
-}

package/src/context/applyEffects.ts

@@ -1,80 +0,0 @@
-import { isProtocolToolName, mapProtocolToolToOperation } from '../tasks/protocolRegistry.js';
-
-function applyTaskOperationResultToContext(updates: Record<string, unknown>, operation: string | null, result: Record<string, unknown>): void {
-  const r = result || {};
-  const agreement = (r['agreement'] as Record<string, unknown>) ||
-    (r['agreementId'] ? r : null);
-  const task = (r['task'] as Record<string, unknown>) || (r['taskId'] ? r : null);
-
-  if (operation === 'agreement-propose' || operation === 'agreement-subcontract') {
-    // Agreement creation no longer spawns a task. The caller has made a
-    // proposal that the proposedTo party still needs to approve.
-    if (agreement) updates['proposal'] = r;
-  }
-  if (operation === 'task-spawn') {
-    if (task) {
-      updates['delegatedTask'] = r;
-      if (task['taskId']) {
-        if (!updates['_delegatedTaskIds']) updates['_delegatedTaskIds'] = [];
-        (updates['_delegatedTaskIds'] as string[]).push(task['taskId'] as string);
-      }
-    }
-  }
-  if (operation === 'task-update') {
-    const status = (task?.['state'] || r['state'] || r['status']) as string | undefined;
-    if (status === 'completed') updates['taskCompleted'] = true;
-    if (status === 'failed') updates['taskFailed'] = true;
-  }
-  if (operation === 'agreement-respond') updates['respondedProposal'] = r;
-}
-
-export const CONTEXT_RESET: Record<string, unknown> = Object.freeze({
-  messageSent: false, activeWait: false, proposal: null, taskCompleted: false,
-  taskFailed: false, subtaskResult: null, subtaskFailed: false, toolResults: null,
-  lastError: null, lastAction: null, lastActionResult: null, approval: false,
-  rejection: false, taskAssignment: null, incomingMessage: false,
-  respondedProposal: null, searchCompleted: false, boardResults: null, taskPublished: false,
-});
-
-export function buildContextUpdates(actionName: string, emittedEvents: unknown[]): Record<string, unknown> {
-  const updates: Record<string, unknown> = { ...CONTEXT_RESET, lastAction: actionName };
-  if (!Array.isArray(emittedEvents)) return updates;
-  const toolResults: unknown[] = [];
-
-  for (const ev of emittedEvents) {
-    if (!ev || typeof ev !== 'object') continue;
-    const events = Array.isArray(ev) ? ev : [ev];
-    for (const e of events) {
-      const event = e as Record<string, unknown>;
-      switch (event['type']) {
-        case 'tool_result':
-          toolResults.push({ tool: event['tool'], result: event['result'] });
-          updates['lastActionResult'] = event;
-          if (isProtocolToolName(event['tool'] as string)) {
-            applyTaskOperationResultToContext(updates, mapProtocolToolToOperation(event['tool'] as string), (event['result'] as Record<string, unknown>) || {});
-          }
-          break;
-        case 'tool_error':
-          toolResults.push({ tool: event['tool'], error: event['error'] });
-          updates['lastActionResult'] = event;
-          updates['lastError'] = event['error'];
-          break;
-        case 'message_sent':
-          updates['messageSent'] = true; updates['lastActionResult'] = event; break;
-        case 'message_duplicate_skipped':
-          updates['messageSent'] = true; break;
-        case 'waited':
-          updates['activeWait'] = true; break;
-        case 'task_result': {
-          updates['lastActionResult'] = event;
-          applyTaskOperationResultToContext(updates, (event['operation'] as string) || null, (event['result'] as Record<string, unknown>) || {});
-          break;
-        }
-        case 'task_error':
-          updates['lastError'] = event['error']; updates['lastActionResult'] = event; break;
-      }
-    }
-  }
-  if (toolResults.length > 0) updates['toolResults'] = toolResults;
-  return updates;
-}

package/src/context/batch.ts

@@ -1,19 +0,0 @@
-import { isBroadcastTarget } from '@ziggs-ai/api-client';
-
-export function getBatchEvents(rawEvent: unknown): unknown[] {
-  if (!rawEvent) return [];
-  const e = rawEvent as Record<string, unknown>;
-  if (e['type'] === 'batch' && Array.isArray(e['events'])) return e['events'] as unknown[];
-  return [rawEvent];
-}
-
-export function isTaskResultRelevantToAgent(result: Record<string, unknown>, ownAgentId: string | null): boolean {
-  if (!ownAgentId) return true;
-  const parties = (result['agreement'] as Record<string, unknown> | undefined)?.['parties'] as Record<string, unknown> | undefined ?? {};
-  return !!(
-    result['creatorIsYou'] || result['providerIsYou'] || result['payerIsYou'] || result['proposedToIsYou'] ||
-    parties['creator'] === ownAgentId || parties['provider'] === ownAgentId ||
-    parties['payer'] === ownAgentId || parties['proposedTo'] === ownAgentId ||
-    isBroadcastTarget(parties['proposedTo'] as string | undefined)
-  );
-}

package/src/context/classifyEnvelope.ts

@@ -1,38 +0,0 @@
-import { CONTEXT_RESET } from './applyEffects.js';
-import { getBatchEvents, isTaskResultRelevantToAgent } from './batch.js';
-
-function isTaskAssignment(result: Record<string, unknown>, ownAgentId: string | null): boolean {
-  const parties = (result['agreement'] as Record<string, unknown> | undefined)?.['parties'] as Record<string, unknown> | undefined ?? {};
-  const isProvider = result['providerIsYou'] || parties['provider'] === ownAgentId;
-  return !!(isProvider && (result['state'] === 'active' || result['state'] === 'in-progress'));
-}
-
-export function classifyIncomingEvent(rawEvent: unknown, ownAgentId: string | null): Record<string, unknown> {
-  const flags: Record<string, unknown> = { ...CONTEXT_RESET };
-  if (!rawEvent) return flags;
-
-  for (const ev of getBatchEvents(rawEvent)) {
-    if (!ev) continue;
-    const e = ev as Record<string, unknown>;
-    if (e['type'] !== 'task_result') { flags['incomingMessage'] = true; continue; }
-
-    const result = (e['result'] as Record<string, unknown>) || {};
-    if (ownAgentId && !isTaskResultRelevantToAgent(result, ownAgentId) && e['receiverId'] !== ownAgentId) continue;
-
-    const state = result['state'] as string | undefined;
-    const ag = result['agreement'] as Record<string, unknown> | undefined;
-    const parties = (ag?.['parties'] as Record<string, unknown>) || {};
-    const proposalStatus = (ag?.['proposal'] as Record<string, unknown> | undefined)?.['status'];
-
-    if (state === 'active' && proposalStatus === 'approved' && ownAgentId && parties['creator'] === ownAgentId) {
-      flags['approval'] = true; flags['taskAssignment'] = result; continue;
-    }
-    if (isTaskAssignment(result, ownAgentId)) { flags['taskAssignment'] = result; flags['approval'] = true; continue; }
-    if (proposalStatus === 'approved' || (state === 'active' && proposalStatus === 'pending')) { flags['approval'] = true; flags['taskAssignment'] = result; continue; }
-    if (proposalStatus === 'rejected' || state === 'cancelled') { flags['rejection'] = true; continue; }
-    if (state === 'completed') { flags['subtaskResult'] = result; continue; }
-    if (state === 'failed') { flags['subtaskResult'] = result; flags['subtaskFailed'] = true; continue; }
-    flags['subtaskResult'] = result;
-  }
-  return flags;
-}

package/src/context/routingLabels.ts

@@ -1,46 +0,0 @@
-import { isProtocolToolName } from '../tasks/protocolRegistry.js';
-import { getBatchEvents, isTaskResultRelevantToAgent } from './batch.js';
-
-export function unwrapBatchEvent(event: unknown): unknown {
-  const e = event as Record<string, unknown> | null | undefined;
-  if (e?.['type'] === 'batch' && Array.isArray(e['events']) && e['events'][0]) return e['events'][0];
-  return event;
-}
-
-export function classifyWorkflowEvent(event: unknown, ownAgentId: string | null = null): string {
-  const events = getBatchEvents(event);
-  if (events.length === 0) return 'message';
-
-  let sawTaskResult = false, sawOwnTaskResult = false;
-
-  for (const ev of events) {
-    const e = ev as Record<string, unknown> | null | undefined;
-    if (e?.['type'] !== 'task_result') continue;
-    sawTaskResult = true;
-    const result = (e['result'] as Record<string, unknown>) || {};
-    if (!isTaskResultRelevantToAgent(result, ownAgentId)) continue;
-    sawOwnTaskResult = true;
-    const state = result['state'] as string | undefined;
-    const ag = result['agreement'] as Record<string, unknown> | undefined;
-    const parties = (ag?.['parties'] as Record<string, unknown>) || {};
-    const proposalStatus = ag?.['proposal'] ? (ag['proposal'] as Record<string, unknown>)['status'] : undefined;
-    const isProvider = result['providerIsYou'] || parties['provider'] === ownAgentId;
-    if (isProvider && (state === 'active' || state === 'in-progress')) return 'task_assignment';
-    if (proposalStatus === 'approved' || (state === 'active' && proposalStatus === 'pending')) return 'task_approved';
-    if (proposalStatus === 'rejected' || state === 'cancelled') return 'task_rejected';
-  }
-  if (sawOwnTaskResult || sawTaskResult) return 'task_update';
-  return 'message';
-}
-
-export function findTaskResult(output: Record<string, unknown> | null | undefined): unknown {
-  const events = (output?.['emittedEvents'] as unknown[]) ?? [];
-  return events.find(e => {
-    const ev = e as Record<string, unknown>;
-    return ev['type'] === 'task_result' || (ev['type'] === 'tool_result' && isProtocolToolName(ev['tool'] as string));
-  }) ?? null;
-}
-
-export function findIncomingTaskResult(incomingEvent: unknown): unknown {
-  return getBatchEvents(incomingEvent).find(e => (e as Record<string, unknown>)?.['type'] === 'task_result') ?? null;
-}

package/src/defineAgent.ts

@@ -1,70 +0,0 @@
-import type { AgentConfig, DefineAgentInput, Workflow } from './types.js';
-import { validateWorkflow } from './runtime/validateWorkflow.js';
-import { injectKickoffDefault } from './runtime/kickoff.js';
-import { runtimeLog } from './shared/runtimeLog.js';
-
-/**
- * Validates the workflow synchronously, resolves merged tools and model, and
- * returns a frozen AgentConfig. Never mutates the input. `wait` defaults remain
- * the author's visible spread of `thinkingDefaults`. ONE default is injected (as
- * new objects): the agreement-kickoff state `kickingOff` plus a last-position
- * transition into it, appended to every state that does not already handle a
- * proposer-side proposal-resolved/approve outcome (runtime/kickoff.ts). The
- * state name 'kickingOff' is reserved; defining it throws.
- *
- * Validation throws WorkflowValidationError on hard problems and logs warnings
- * on soft ones (e.g. missing wait fallthrough).
- */
-export function defineAgent(input: DefineAgentInput): AgentConfig {
-  if (!input?.agentId) throw new Error('[defineAgent] agentId is required');
-  if (!input?.description) throw new Error('[defineAgent] description is required');
-  if (!input?.states) throw new Error('[defineAgent] states is required');
-  if (!input?.initial) throw new Error('[defineAgent] initial state is required');
-
-  // Agreement-kickoff default (see runtime/kickoff.ts): injected BEFORE
-  // validation so the injected state/transitions are validated too.
-  const workflow: Workflow = injectKickoffDefault({
-    id: input.agentId,
-    description: input.description,
-    initial: input.initial,
-    states: input.states,
-  });
-
-  const { warnings } = validateWorkflow(workflow);
-  for (const w of warnings) runtimeLog.warn('defineAgent', w);
-
-  const tools = [
-    ...(Array.isArray(input.tools) ? input.tools : []),
-    ...(Array.isArray(input.services?.tools) ? input.services!.tools! : []),
-  ];
-
-  const model =
-    input.services?.llm?.model ||
-    process.env.LLM_MODEL ||
-    process.env.OPENAI_MODEL ||
-    'gpt-5.4';
-
-  // Strip the structural fields we already consumed; pass through everything
-  // else (operatorKey, taskTools, custom keys consumed by AgentHost).
-  const {
-    agentId, description, specialization, services: _services, initial: _initial,
-    states: _states, tools: _tools, operatorKey, taskTools, ...rest
-  } = input;
-
-  const config: AgentConfig = {
-    openaiKey: process.env.OPENAI_API_KEY,
-    anthropicKey: process.env.ANTHROPIC_API_KEY,
-    ...(operatorKey ? { operatorKey } : {}),
-    agentId,
-    description,
-    ...(specialization ? { specialization } : {}),
-    tools,
-    model,
-    workflow,
-    ...(input.services ? { services: input.services } : {}),
-    ...(taskTools !== undefined ? { taskTools } : {}),
-    ...rest,
-  };
-
-  return Object.freeze(config) as AgentConfig;
-}