@ziggs-ai/agent-sdk 0.1.3 → 0.1.4

package/src/index.ts

@@ -0,0 +1,86 @@
+/**
+ * @ziggs-ai/agent-sdk public surface.
+ *
+ * Foundation:
+ *   • Outcome union — discriminated, hybrid (closed core + extension)
+ *   • Workflow shape — explicit kind: 'parked' | 'thinking'
+ *   • Visible defaults — thinkingDefaults({ initial }) spread by author
+ *   • Validation at load — defineAgent throws on hard problems, warns on soft
+ */
+
+export { defineAgent } from './defineAgent.js';
+export { AgentHost, createAgent, createAgentPool } from './AgentHost.js';
+export { Agent } from './agent/Agent.js';
+export type { TickInput, TickOutput, AgentOptions } from './agent/Agent.js';
+export type { SessionResolver, AgentHostOptions } from './AgentHost.js';
+export { createZiggsEffectHandler } from './server/ZiggsEffectHandler.js';
+export type { ZiggsEffectDeps } from './server/ZiggsEffectHandler.js';
+export { EventQueue } from './server/EventQueue.js';
+export { OutboxBuffer } from './server/OutboxBuffer.js';
+export { normalizeIncomingEvent } from './ingress/normalizeIncoming.js';
+
+// Runtime primitives
+export { AgentMachine } from './runtime/AgentMachine.js';
+export { runTurn } from './runtime/runTurn.js';
+export { PromptBuilder } from './runtime/PromptBuilder.js';
+export { thinkingDefaults, defineThinkingState, DEFAULT_WAIT_PROMPT } from './runtime/defaults.js';
+export { validateWorkflow, WorkflowValidationError } from './runtime/validateWorkflow.js';
+export { outcomeFromEvent, outcomeFromActionResult, applyOutcomeToCtx } from './runtime/buildOutcome.js';
+
+// Types
+export type {
+  Outcome, OutcomeKind,
+  Ctx, Identity, HistoryEntry, ToolResultEntry,
+  Workflow, State, ParkedState, ThinkingState,
+  Action, Transition, PromptDef, ActionPrompt, Produces, ProducesFn,
+  AgreementRef, TaskRef, ProposalRef,
+  AgentConfig, DefineAgentInput, ServicesConfig,
+  // Effects — Agent↔Server boundary
+  Effect, EffectKind, EffectResult, EffectResultMap, EffectHandler,
+  LlmMessage, LlmToolCall, LlmToolSchema, LlmResponse,
+  ContextSnapshot, ReadContextOpts, ToolCallResult, RecordedEntry,
+} from './types.js';
+
+export { default } from './AgentHost.js';
+
+// ── Supporting modules ──────────────────────────────────────────────────────
+
+export { validateContext, ContextWarning } from './cognition/validateContext.js';
+export { runLauncher } from './server/runLauncher.js';
+export { ConnectionPool } from './server/ConnectionPool.js';
+export { createHealthServer } from './server/createHealthServer.js';
+export { TaskService } from './server/tasks/TaskService.js';
+export { AgreementService } from './server/agreements/AgreementService.js';
+export { ToolManager } from './tools/ToolManager.js';
+export { ToolProvider } from './tools/ToolProvider.js';
+export { defineTool } from './tools/defineTool.js';
+export { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
+export { extractJSON, safeParseJSON } from './utils/jsonExtractor.js';
+export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormatter } from './formatters/index.js';
+export { ProactiveTrigger } from './server/proactive/ProactiveTrigger.js';
+export { ZiggsPayClient, createZiggsPayClient } from './server/ziggspay/ZiggsPayClient.js';
+export {
+  PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool,
+  agreementRespondTool, agreementCounterProposalTool, agreementCheckProposalTool,
+  taskSpawnTool, taskUpdateTool, taskUpdatePlanStepTool,
+} from './server/tasks/protocolTools.js';
+export { PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool } from './server/tasks/paymentTools.js';
+export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
+export { dispatchProtocolOp } from './server/tasks/protocolRunner.js';
+export { InMemoryStore, FileMemoryStore } from './memory/MemoryStore.js';
+export type { MemoryStore } from './memory/MemoryStore.js';
+export { classifyIncomingEvent } from './context/classifyEnvelope.js';
+export { buildContextUpdates, CONTEXT_RESET } from './context/applyEffects.js';
+export { getBatchEvents, isTaskResultRelevantToAgent } from './context/batch.js';
+export { classifyWorkflowEvent, findTaskResult, unwrapBatchEvent, findIncomingTaskResult } from './context/routingLabels.js';
+export {
+  WebSocketClient,
+  MessagesClient,
+  ArtifactsClient,
+  ScopeClient,
+  AgentSearchClient,
+  getBackendUrl,
+  getWebSocketUrl,
+} from '@ziggs-ai/api-client';
+
+export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';

package/src/ingress/normalizeIncoming.ts

@@ -0,0 +1,119 @@
+import { OPEN_AGREEMENT_TARGET } from '../tasks/taskCore.js';
+
+export interface NormalizedEvent {
+  chatId: string | null;
+  event: {
+    senderId?: string;
+    senderType?: string;
+    receiverId?: string;
+    timestamp: number;
+    type: 'task_result' | 'message';
+    result?: unknown;
+    text?: string;
+  };
+  shouldProcess: boolean;
+  reason: string | null;
+}
+
+interface WireParties {
+  creatorId?: string;
+  providerId?: string;
+  payerId?: string;
+  proposedToId?: string;
+}
+
+interface WireTask {
+  taskId?: string;
+  agentId?: string;
+  executorId?: string;
+  payerId?: string;
+  proposedTo?: string;
+  createdBy?: string;
+  parentTaskId?: string;
+  state?: string;
+  proposal?: unknown;
+  agreement?: { parties?: WireParties };
+}
+
+interface WireMetadata {
+  chatId?: string;
+  chat_id?: string;
+  entryType?: string;
+  content_type?: string;
+  contentType?: string;
+  receiverId?: string;
+  sender?: { id?: string; type?: string };
+  receiver?: { id?: string };
+  to?: { id?: string };
+  task?: WireTask;
+  [key: string]: unknown;
+}
+
+interface NormalizeArgs {
+  text: string;
+  metadata?: WireMetadata;
+  ownAgentId?: string | null;
+}
+
+function normalizeChatId(metadata: WireMetadata): string | null {
+  return metadata.chatId || metadata.chat_id || null;
+}
+
+function normalizeReceiverId(metadata: WireMetadata, taskData: WireTask | null): string | null {
+  return metadata.receiver?.id || metadata.receiverId || metadata.to?.id || taskData?.executorId || taskData?.proposedTo || null;
+}
+
+function isTaskRelated(metadata: WireMetadata, taskData: WireTask | null): boolean {
+  if (!taskData?.taskId) return false;
+  const entryType = metadata.entryType || 'message';
+  const contentType = metadata.content_type || metadata.contentType || 'text';
+  return (
+    entryType === 'notification' || entryType === 'task_history'
+    || contentType === 'task' || contentType === 'task_update'
+    || Boolean(taskData.state || taskData.proposal || taskData.parentTaskId || taskData.executorId || taskData.agentId || taskData.payerId || taskData.createdBy)
+  );
+}
+
+function isRelevantForAgent(ids: (string | null | undefined)[], ownAgentId: string | null): boolean {
+  if (!ownAgentId) return true;
+  return ids.includes(ownAgentId) || ids.includes(OPEN_AGREEMENT_TARGET);
+}
+
+export function normalizeIncomingEvent({ text, metadata = {}, ownAgentId = null }: NormalizeArgs): NormalizedEvent {
+  const taskData = metadata.task || null;
+  const chatId = normalizeChatId(metadata);
+  const receiverId = normalizeReceiverId(metadata, taskData);
+  const senderType = metadata.sender?.type ? String(metadata.sender.type).toUpperCase() : undefined;
+
+  const base = {
+    senderId: metadata.sender?.id,
+    senderType,
+    receiverId: receiverId || undefined,
+    timestamp: Date.now(),
+  };
+
+  if (isTaskRelated(metadata, taskData)) {
+    const receiverFromMeta = metadata.receiver?.id || metadata.receiverId || null;
+    const parties = taskData!.agreement?.parties ?? {};
+    const candidateIds = [
+      parties.creatorId, parties.providerId, parties.payerId, parties.proposedToId,
+      taskData!.agentId, taskData!.executorId, taskData!.payerId, taskData!.proposedTo, taskData!.createdBy,
+      receiverFromMeta,
+    ].filter(Boolean);
+    const relevant = isRelevantForAgent(candidateIds, ownAgentId);
+    return {
+      chatId,
+      event: { ...base, type: 'task_result', result: taskData, text },
+      shouldProcess: relevant,
+      reason: relevant ? null : 'task_not_targeted_to_agent',
+    };
+  }
+
+  const relevant = !ownAgentId || !receiverId || receiverId === ownAgentId || receiverId === OPEN_AGREEMENT_TARGET;
+  return {
+    chatId,
+    event: { ...base, type: 'message', text },
+    shouldProcess: relevant,
+    reason: relevant ? null : 'message_not_targeted_to_agent',
+  };
+}

package/src/memory/MemoryStore.ts

@@ -0,0 +1,104 @@
+/**
+ * Agent-private long-term memory.
+ *
+ * This is the SDK's contract; the *storage* is operator-provided. The agent
+ * picks the key shape (often `counterparty:<id>`, sometimes `agreement:<id>:notes`,
+ * etc.) — the SDK does not enforce one.
+ *
+ * Reference implementations: `InMemoryStore` (default; non-durable) and
+ * `FileMemoryStore` (single JSON file; useful for local dev). Anything
+ * production-grade (sqlite, redis, postgres, …) is operator-owned.
+ *
+ * Aligns with the project's "agents are third-party" framing: an agent's
+ * private notes are its own concern, not the backend's.
+ */
+export interface MemoryStore {
+  get(key: string): Promise<unknown | undefined>;
+  put(key: string, value: unknown): Promise<void>;
+  list(prefix: string): Promise<{ key: string; value: unknown }[]>;
+  delete?(key: string): Promise<void>;
+}
+
+/** Non-durable reference impl. Per-process; lost on restart. */
+export class InMemoryStore implements MemoryStore {
+  private readonly store = new Map<string, unknown>();
+
+  async get(key: string): Promise<unknown | undefined> {
+    return this.store.get(key);
+  }
+
+  async put(key: string, value: unknown): Promise<void> {
+    this.store.set(key, value);
+  }
+
+  async list(prefix: string): Promise<{ key: string; value: unknown }[]> {
+    const out: { key: string; value: unknown }[] = [];
+    for (const [k, v] of this.store) {
+      if (k.startsWith(prefix)) out.push({ key: k, value: v });
+    }
+    return out;
+  }
+
+  async delete(key: string): Promise<void> {
+    this.store.delete(key);
+  }
+}
+
+/**
+ * Single-file JSON store. Reads on startup, writes on every put — fine for
+ * local dev and example agents; not for production (no concurrency control,
+ * no atomicity). Operators with serious durability needs ship their own
+ * `MemoryStore` (sqlite, redis, …) and pass it via `defineAgent({ memory })`.
+ */
+export class FileMemoryStore implements MemoryStore {
+  private cache: Record<string, unknown> | null = null;
+  private loading: Promise<void> | null = null;
+
+  constructor(private readonly path: string) {}
+
+  private async _ensureLoaded(): Promise<void> {
+    if (this.cache) return;
+    if (!this.loading) {
+      this.loading = (async () => {
+        try {
+          const fs = await import('fs/promises');
+          const txt = await fs.readFile(this.path, 'utf-8');
+          this.cache = JSON.parse(txt) as Record<string, unknown>;
+        } catch {
+          this.cache = {};
+        }
+      })();
+    }
+    await this.loading;
+  }
+
+  private async _flush(): Promise<void> {
+    if (!this.cache) return;
+    const fs = await import('fs/promises');
+    await fs.writeFile(this.path, JSON.stringify(this.cache, null, 2), 'utf-8');
+  }
+
+  async get(key: string): Promise<unknown | undefined> {
+    await this._ensureLoaded();
+    return this.cache![key];
+  }
+
+  async put(key: string, value: unknown): Promise<void> {
+    await this._ensureLoaded();
+    this.cache![key] = value;
+    await this._flush();
+  }
+
+  async list(prefix: string): Promise<{ key: string; value: unknown }[]> {
+    await this._ensureLoaded();
+    return Object.entries(this.cache!)
+      .filter(([k]) => k.startsWith(prefix))
+      .map(([key, value]) => ({ key, value }));
+  }
+
+  async delete(key: string): Promise<void> {
+    await this._ensureLoaded();
+    delete this.cache![key];
+    await this._flush();
+  }
+}

package/src/runtime/AgentMachine.ts

@@ -0,0 +1,298 @@
+import type { Ctx, Outcome, Workflow, Identity, EffectHandler } from '../types.js';
+import { runtimeLog } from '../shared/runtimeLog.js';
+import { applyOutcomeToCtx, outcomeFromEvent, type RawEvent } from './buildOutcome.js';
+import type { runTurn as RunTurnFn } from './runTurn.js';
+import { PromptBuilder } from './PromptBuilder.js';
+import type { MemoryStore } from '../memory/MemoryStore.js';
+import type { ToolManager } from '../tools/ToolManager.js';
+
+export interface MachineSnapshot {
+  value: string;
+  ctx: Ctx;
+  status: 'active' | 'stopped';
+}
+
+interface MachineInput {
+  identity: Identity;
+  /** Server-provided ctx for an existing session. If omitted, a fresh ctx is built. */
+  ctx?: Ctx;
+  /** Server-provided state name for an existing session. Defaults to workflow.initial. */
+  state?: string;
+}
+
+interface MachineOptions {
+  workflow: Workflow;
+  executionCore: typeof RunTurnFn;
+  /** Side channel for all I/O. Provided by the Server. */
+  eff: EffectHandler;
+  /** Pure tool metadata (schemas, flags). Owned by the Agent. */
+  toolManager: ToolManager;
+  promptBuilder: PromptBuilder;
+  /** Agent-private long-term memory. Operator-provided. */
+  memory?: MemoryStore;
+  input: MachineInput;
+}
+
+interface IncomingFrame {
+  event?: RawEvent;
+  identity?: Identity;
+}
+
+type Subscriber = (snapshot: MachineSnapshot) => void;
+
+/**
+ * Per-lane interpreter. Holds (current state name, Ctx). Re-entry is the
+ * single primitive: every external event and every turn produces exactly
+ * one Outcome that re-enters the current state.
+ *
+ * Parked states stop on entry. Thinking states run an LLM turn → produce an
+ * outcome → re-enter. Transitions are evaluated against the new outcome
+ * (first matching `when` wins; no `when` is fallthrough).
+ *
+ * `_running` guards against concurrent turns on the same machine — outer
+ * runtime is expected to serialize via EventQueue, but we belt-and-suspenders.
+ */
+export class AgentMachine {
+  workflow: Workflow;
+  executionCore: typeof RunTurnFn;
+  eff: EffectHandler;
+  toolManager: ToolManager;
+  promptBuilder: PromptBuilder;
+  memory?: MemoryStore;
+  state: string;
+  status: 'active' | 'stopped' = 'active';
+  ctx: Ctx;
+  _running = false;
+  _subscribers = new Set<Subscriber>();
+  _prevSnapshot: MachineSnapshot | null = null;
+  _pendingFrames: IncomingFrame[] = [];
+  _draining = false;
+  _llmCalls = 0;
+  _tokens = { total: 0, input: 0, output: 0 };
+
+  get llmCalls(): number { return this._llmCalls; }
+  get tokens(): { total: number; input: number; output: number } { return this._tokens; }
+
+  constructor({ workflow, executionCore, eff, toolManager, promptBuilder, memory, input }: MachineOptions) {
+    this.workflow = workflow;
+    this.executionCore = executionCore;
+    this.eff = eff;
+    this.toolManager = toolManager;
+    this.promptBuilder = promptBuilder;
+    this.memory = memory;
+    this.state = input.state || workflow.initial;
+    this.ctx = input.ctx
+      ? { ...input.ctx, identity: input.identity }
+      : {
+          identity: input.identity,
+          activeAgreementId: null,
+          activeTaskId: null,
+          pendingProposalAgreementId: null,
+          delegatedAgreementIds: [],
+          delegatedTaskIds: [],
+          toolResults: [],
+          lastOutcome: { kind: 'enter' },
+        };
+  }
+
+  getSnapshot(): MachineSnapshot {
+    return { value: this.state, ctx: this.ctx, status: this.status };
+  }
+
+  /** Parked = currently in a parked state and not executing a turn. */
+  get isParked(): boolean {
+    if (this._running) return false;
+    const sd = this.workflow.states[this.state];
+    return sd?.kind === 'parked';
+  }
+
+  subscribe(fn: Subscriber): { unsubscribe: () => void } {
+    this._subscribers.add(fn);
+    return { unsubscribe: () => this._subscribers.delete(fn) };
+  }
+
+  /**
+   * Process an incoming wire event: convert to outcome → apply to ctx →
+   * evaluate current state's transitions → re-enter or stop.
+   *
+   * Serialized via a single-slot queue: if a turn is already in flight, the
+   * frame is held until the running turn settles, then drained. Without this,
+   * an inbound event mid-turn re-entered _step with a stale state and a hot
+   * `_running=true`, which spawned overlapping turns and re-created the
+   * clarifyingDuringApproval feedback loop even after fixing the workflow
+   * fall-through (ZIG-181).
+   */
+  async send(frame: IncomingFrame): Promise<void> {
+    if (this.status !== 'active') return;
+    this._pendingFrames.push(frame);
+    if (this._draining) return;
+    this._draining = true;
+    try {
+      while (this._pendingFrames.length) {
+        const next = this._pendingFrames.shift()!;
+        await this._handleFrame(next);
+      }
+    } finally {
+      this._draining = false;
+    }
+  }
+
+  async _handleFrame(frame: IncomingFrame): Promise<void> {
+    if (this.status !== 'active') return;
+    if (frame.identity) this.ctx.identity = frame.identity;
+
+    const ev = frame.event;
+    this._lastIncomingEvent = ev ?? null;
+    runtimeLog.debug(
+      'FSM',
+      `_handleFrame ev.type=${ev?.type} ev.senderId=${ev?.senderId} ev.receiverId=${ev?.receiverId} myId=${this.ctx.identity?.agentId}`,
+    );
+    const outcome = outcomeFromEvent(ev, this.ctx.identity.agentId);
+
+    // `outcomeFromEvent` never returns null — it falls back to `{ kind: 'enter' }`
+    // when all events in a batch are no-ops (resource_changed, self-echo, etc.).
+    // If a real raw event produced `enter`, that means the event carried no
+    // meaningful signal for the FSM, so skip it entirely.  Without this guard
+    // `idle`'s unconditional `{ to: 'understanding' }` transition fires on every
+    // resource_changed wake-up, kicking off an LLM turn that sends a duplicate
+    // message, which triggers another resource_changed, and so on.
+    if (ev && outcome.kind === 'enter') return;
+
+    if (
+      outcome.kind === 'subtask-finished' &&
+      ev?.type === 'task_result' &&
+      ev?.result?.taskId &&
+      this.ctx.delegatedTaskIds.includes(ev.result.taskId)
+    ) {
+      // Already correctly classified — no override needed.
+    }
+
+    applyOutcomeToCtx(this.ctx, outcome);
+    await this._step(outcome);
+  }
+
+  async _step(outcome: Outcome, depth = 0): Promise<void> {
+    const fromState = this.state;
+    const target = this._evaluateTransitions(outcome);
+    const o = outcome as Record<string, unknown>;
+    runtimeLog.debug(
+      'FSM',
+      `_step from=${fromState} outcome.kind=${o?.kind} senderId=${o?.senderId ?? '<none>'} myId=${this.ctx.identity?.agentId ?? '<none>'} → target=${target ?? '(stay)'} depth=${depth}`,
+    );
+    if (target && target !== this.state) {
+      this.state = target;
+      this._notify();
+    }
+
+    const sd = this.workflow.states[this.state];
+    if (!sd) return;
+    if (sd.kind === 'parked') {
+      runtimeLog.debug('FSM', `_step parked state=${this.state} — exit`);
+      // Notify so runtime detects park and resolves the wait promise.
+      this._notify();
+      return;
+    }
+
+    // Recursion / runaway-turn guard. Without this, a thinking state whose
+    // transitions don't match the turn outcome (e.g. `delegating` not
+    // catching `tool-result` from an agent_network search) re-enters the
+    // same state forever — the LLM keeps re-rolling search/dummy actions
+    // until something accidentally matches, burning tokens and emitting
+    // duplicate side effects (ZIG-181: ziggs ran `discoverSpecialist` six
+    // times before finally invoking `delegate`). 12 is well above any
+    // legitimate same-state turn chain we exercise in tests; if we trip
+    // it, treat the state as wedged and park.
+    if (depth >= 12) {
+      runtimeLog.warn(
+        'AgentMachine',
+        `state=${this.state} runaway turn loop (depth=${depth}); parking`,
+      );
+      this._notify();
+      return;
+    }
+    runtimeLog.debug('FSM', `_step thinking state=${this.state} — run turn`);
+
+    // Thinking: run a turn, produce an outcome, re-step.
+    this._running = true;
+    try {
+      const { outcome: turnOutcome, toolResults, llmCalls, tokens } = await this.executionCore({
+        stateId: this.state,
+        statePrompt: sd.prompt,
+        actions: sd.actions,
+        incomingEvent: this.ctx.lastOutcome ? this._lastIncomingEvent : null,
+        ctx: this.ctx,
+        eff: this.eff,
+        toolManager: this.toolManager,
+        promptBuilder: this.promptBuilder,
+        memory: this.memory,
+        definition: this.workflow,
+      });
+
+      this.ctx.toolResults = toolResults;
+      this._llmCalls += llmCalls;
+      this._tokens.total += tokens.total;
+      this._tokens.input += tokens.input;
+      this._tokens.output += tokens.output;
+      applyOutcomeToCtx(this.ctx, turnOutcome);
+      this._running = false;
+      this._notify();
+
+      await this._step(turnOutcome, depth + 1);
+    } catch (error: unknown) {
+      runtimeLog.error('AgentMachine', `state=${this.state} error: ${(error as Error)?.message || error}`);
+      const errOutcome: Outcome = {
+        kind: 'error',
+        source: 'unknown',
+        cause: (error as Error)?.message || String(error),
+        retryable: false,
+      };
+      applyOutcomeToCtx(this.ctx, errOutcome);
+      this._running = false;
+      this._notify();
+      // Try to fall through using current state's transitions; if none match
+      // the error outcome the machine just parks (next event will re-enter).
+      const fallback = this._evaluateTransitions(errOutcome);
+      if (fallback && fallback !== this.state) {
+        this.state = fallback;
+        this._notify();
+      }
+    }
+  }
+
+  _evaluateTransitions(outcome: Outcome): string | null {
+    const sd = this.workflow.states[this.state];
+    if (!sd?.transitions?.length) {
+      runtimeLog.debug('FSM', `evaluate state=${this.state}: NO TRANSITIONS DEFINED`);
+      return null;
+    }
+    for (let i = 0; i < sd.transitions.length; i++) {
+      const rule = sd.transitions[i]!;
+      let matched: boolean;
+      let err: unknown = null;
+      if (!rule.when) {
+        matched = true;
+      } else {
+        try { matched = !!rule.when(outcome, this.ctx); }
+        catch (e) { matched = false; err = e; }
+      }
+      runtimeLog.debug(
+        'FSM',
+        `evaluate state=${this.state} rule[${i}] to=${rule.to} when=${rule.when ? 'fn' : 'always'} → ${matched}${err ? ` ERR=${(err as Error).message}` : ''}`,
+      );
+      if (matched) return rule.to;
+    }
+    runtimeLog.debug('FSM', `evaluate state=${this.state}: NONE matched`);
+    return null;
+  }
+
+  _notify(): void {
+    const snapshot = this.getSnapshot();
+    for (const fn of this._subscribers) {
+      try { fn(snapshot); } catch {}
+    }
+  }
+
+  // Held so PromptBuilder/runTurn can render the original wire event in <event>.
+  // Set by the runtime layer when it calls send(); we don't classify it twice.
+  _lastIncomingEvent: RawEvent | null = null;
+}