@hexabot-ai/agentic 3.0.1-alpha.0

package/examples/full/workflow.yml

@@ -0,0 +1,359 @@
+### Example DSL: AI/automation workflow (annotated)
+### This single file is reference documentation for the YAML language used to orchestrate multi-step agents.
+### Convention: strings beginning with "=" are JSONata expressions with scope {context, input, output, iteration, accumulator, result}; all other strings are treated as literals.
+---
+# End-to-end assistant that classifies a user request, collects signals, performs a human-in-the-loop
+# clarification (pausing the run until the user replies), branches by intent/priority, and delivers an email.
+# Declares external inputs the caller must provide when starting a run.
+inputs:
+  schema:
+    query:
+      type: string
+      description: "Natural language request or question from the user."
+    user_email:
+      type: string
+      description: "Where to send the response."
+    priority:
+      type: string
+      enum: ["low", "normal", "high"]
+      description: "Used for routing/escalation decisions."
+    attachments:
+      type: array
+      items:
+        type: string
+      description: "Optional file ids that the user attached with the request."
+
+# Context is provided by the runtime (read-only) and accessed with $context.* inside tasks.
+# Include any long-term state here (thread ids, transcripts, briefs) instead of a separate memory block.
+context:
+  user_id: "=$context.user_id"            # e.g., authenticated account id
+  account_tier: "=$context.account_tier"  # e.g., free/pro/enterprise for policy decisions
+  locale: "=$context.locale"              # e.g., en-US, influences prompts
+  timezone: "=$context.timezone"          # useful for time-sensitive operations
+  channel: "=$context.channel"            # e.g., web, email, slack; used when messaging the user
+  thread_id: "=$context.thread_id"        # thread/conversation id for continuity
+  full_transcript: "=$context.full_transcript"
+  last_summary: "=$context.last_summary"
+  support_playbook: "=$context.support_playbook"
+  product_brief: "=$context.product_brief"
+
+# Global defaults inherited by every task (overridable per task).
+defaults:
+  settings:
+    timeout_ms: 10000
+    retries:
+      enabled: true
+      max_attempts: 2
+      backoff_ms: 400
+      max_delay_ms: 10000
+      jitter: 0
+      multiplier: 1.5
+
+# Task catalog: each task has a unique name, description, action, inputs, settings.
+defs:
+  understand_request:
+    kind: task
+    description: "LLM categorizes the incoming query, extracts a short summary, and lists missing must-have fields."
+    action: call_llm
+    inputs:
+      system_prompt: |
+        You are an intent classifier and requirement extractor.
+        Return JSON with keys: intent, confidence, summary, missing_fields (array), needs_human (boolean).
+        Allowed intents: support, sales, research.
+      user_query: "=$input.query"
+      attachments: "=$input.attachments"
+      last_summary: "=$context.last_summary"
+      user_tier: "=$context.account_tier"
+    settings:
+      model: gpt-4o
+      temperature: 0.2
+      timeout_ms: 6000
+      retries:
+        enabled: true
+        max_attempts: 1
+        backoff_ms: 400
+        max_delay_ms: 3000
+        jitter: 0.05
+        multiplier: 1.2
+
+  fetch_user_profile:
+    kind: task
+    description: "Look up CRM profile and recent cases for the authenticated user."
+    action: get_user_profile
+    inputs:
+      user_id: "=$context.user_id"
+      include_history: true
+
+  # Three distinct actions will run in parallel; their outputs will later be merged.
+  search_recent_news:
+    kind: task
+    description: "Web search for fresh information about the user's company or topic."
+    action: search_web
+    inputs:
+      query: "='updates for ' & $output.fetch_user_profile.profile.company"
+      limit: 3
+    settings:
+      timeout_ms: 7000
+
+  retrieve_memory_thread:
+    kind: task
+    description: "Recall summarized prior conversation for continuity."
+    action: query_memory
+    inputs:
+      thread_id: "=$context.thread_id"     # read thread id from long-term context state
+      user_id: "=$context.user_id"
+    settings:
+      timeout_ms: 3000
+
+  fetch_calendar_events:
+    kind: task
+    description: "Pull the user's upcoming meetings for scheduling-aware replies."
+    action: get_calendar_events
+    inputs:
+      user_email: "=$input.user_email"
+      range: "next 7 days"
+    settings:
+      timeout_ms: 5000
+
+  # Human-in-the-loop primitive: ask the user a clarifying question and pause the run until they respond.
+  ask_for_missing_detail:
+    kind: task
+    description: >
+      Send a clarifying question to the end user when the request lacks required fields.
+      The engine MUST pause the workflow here and resume once a reply is received or a timeout occurs.
+    action: await_user_input                # generic action name that does not imply a specific channel
+    inputs:
+      prompt: |                           # question shown to the user in the same channel that triggered the run
+        = 'To help with your ' & $output.understand_request.intent & ' request, please provide: ' &
+          $join($output.understand_request.missing_fields, ', ')
+      allow_attachments: true
+    settings:
+      await_user: true                     # signals the runtime to checkpoint and wait
+      timeout_ms: 86400000                 # 24h; engines may choose a default if omitted
+
+  synthesize_research:
+    kind: task
+    description: "LLM that combines all signals (including any user clarification) into a concise brief."
+    action: call_llm
+    inputs:
+      intent: "=$output.understand_request.intent"
+      profile: "=$output.fetch_user_profile.profile"
+      news_snippets: "=$output.search_recent_news.snippets"  # from a parallel task
+      memory_summary: "=$output.retrieve_memory_thread.summary"
+      meetings: "=$output.fetch_calendar_events.events"
+      user_clarification: "=$exists($output.ask_for_missing_detail.text) ? $output.ask_for_missing_detail.text : ''"
+      attachments: "=$exists($output.ask_for_missing_detail.attachments) ? $output.ask_for_missing_detail.attachments : $input.attachments"
+    settings:
+      model: gpt-4o
+      temperature: 0.35
+
+  route_by_intent:
+    kind: task
+    description: "Decide which downstream path to take using a branching table."
+    action: decision_router
+    inputs:
+      intent: "=$output.understand_request.intent"
+      priority: "=$input.priority"
+      confidence: "=$output.understand_request.confidence"
+      needs_human: "=$output.understand_request.needs_human"
+    settings:
+      # Multi-branch logic evaluated top-to-bottom; first match wins.
+      branches:
+        - when: "=$output.understand_request.needs_human = true"
+          next: escalate_to_human
+        - when: "=$output.understand_request.intent = 'support' and $output.understand_request.confidence > 0.6"
+          next: draft_support_reply
+        - when: "=$output.understand_request.intent = 'sales'"
+          next: craft_sales_pitch
+        - when: "=$input.priority = 'high'"  # demonstrates condition using workflow input
+          next: escalate_to_human
+      default_next: send_generic_summary
+
+  draft_support_reply:
+    kind: task
+    description: "Generate troubleshooting steps tailored to the user."
+    action: call_llm
+    inputs:
+      profile: "=$output.fetch_user_profile.profile"
+      question: "=$input.query"
+      clarification: "=$exists($output.ask_for_missing_detail.text) ? $output.ask_for_missing_detail.text : ''"
+      troubleshooting_guide: "=$context.support_playbook"
+      signals: "=$output.synthesize_research.synthesis"
+    settings:
+      model: gpt-4o-mini
+      temperature: 0.3
+
+  craft_sales_pitch:
+    kind: task
+    description: "Write a sales email using retrieved company insights."
+    action: call_llm
+    inputs:
+      product_brief: "=$context.product_brief"
+      company_news: "=$output.search_recent_news.snippets"
+      meetings: "=$output.fetch_calendar_events.events"
+      persona: "=$output.fetch_user_profile.profile.persona"
+      query: "=$input.query"
+    settings:
+      model: gpt-4o
+      temperature: 0.55
+
+  escalate_to_human:
+    kind: task
+    description: "Open or update a human-agent ticket with full context."
+    action: create_ticket
+    inputs:
+      user_id: "=$context.user_id"
+      transcript: "=$context.full_transcript"
+      summary: "=$output.synthesize_research.synthesis"
+      clarification: "=$exists($output.ask_for_missing_detail.text) ? $output.ask_for_missing_detail.text : ''"
+
+  send_generic_summary:
+    kind: task
+    description: "Fallback response when no specialized branch applies."
+    action: call_llm
+    inputs:
+      summary: "=$output.synthesize_research.synthesis"
+      intent: "=$output.understand_request.intent"
+      question: "=$input.query"
+    settings:
+      model: gpt-4o-mini
+
+  send_email_response:
+    kind: task
+    description: "Deliver the chosen response via email."
+    action: send_email
+    inputs:
+      to: "=$input.user_email"
+      subject: "='Response for ' & $output.understand_request.intent & ' request'"
+      body: >
+        = (
+          $route := $output.route_by_intent.route;
+          $route = 'draft_support_reply' ? $output.draft_support_reply.message :
+          $route = 'craft_sales_pitch' ? $output.craft_sales_pitch.email :
+          $route = 'escalate_to_human' ? ('Ticket created: ' & $output.escalate_to_human.ticket_id) :
+          $output.send_generic_summary.message
+        )
+      # The JSONata expression above chooses the body from prior outputs without separate templating.
+    settings:
+      track_opens: true
+
+  # Loop-specific tasks used by the for-each demo in the flow below.
+  draft_stakeholder_update:
+    kind: task
+    description: "LLM crafts a short FYI note for each stakeholder iterated in the loop."
+    action: call_llm
+    inputs:
+      stakeholder: "=$iteration.item"                # $iteration.* is provided inside loop bodies
+      intent: "=$output.understand_request.intent"
+      research_brief: "=$output.synthesize_research.synthesis"
+      question: "=$input.query"
+    settings:
+      model: gpt-4o-mini
+      temperature: 0.35
+
+  send_stakeholder_update:
+    kind: task
+    description: "Deliver FYI notes to stakeholders and capture acknowledgement."
+    action: send_email
+    inputs:
+      to: "=$iteration.item.email"
+      subject: "='FYI: ' & $iteration.item.name & ' about ' & $output.understand_request.intent"
+      body: "=$output.draft_stakeholder_update.message"
+
+# Flow defines execution order, mixing sequential chains, parallel blocks, conditionals, waits, and loops.
+flow:
+  - do: understand_request     # Step 1: always start by understanding the request ($input.query).
+
+  # Step 2: If required context is missing, ask the user and pause until they answer.
+  - conditional:
+      description: "Human-in-the-loop gate: pause the run until user replies with missing details."
+      when:
+        - condition: "=$count($output.understand_request.missing_fields) > 0"
+          steps:
+            - do: ask_for_missing_detail  # settings.await_user=true causes a checkpoint + wait-for-reply resume
+        - else:
+          steps: []                       # nothing to do when request is already complete
+
+  - do: fetch_user_profile      # Step 3: enrich with CRM data before branching.
+
+  # Step 4: run three independent enrichment tasks concurrently.
+  # Note: each entry under `parallel.steps` can be a `do`, `conditional`, `loop`, or nested `parallel` block.
+  - parallel:
+      strategy: wait_all        # wait_all ensures downstream steps see every output
+      steps:
+        - do: search_recent_news
+        - do: retrieve_memory_thread
+        - do: fetch_calendar_events
+
+  - do: synthesize_research     # Step 5: summarize signals (including any user clarification).
+  - do: route_by_intent         # Step 6: produce a route key used by the conditional below.
+
+  # Step 7: conditional routing with a nested condition.
+  - conditional:
+      description: "Branch based on router output; demonstrates multi-branch + nested logic."
+      when:
+        - condition: "=$output.route_by_intent.route = 'draft_support_reply'"
+          steps:
+            - do: draft_support_reply
+            # Nested conditional: if the request is high priority, escalate after drafting.
+            - conditional:
+                when:
+                  - condition: "=$input.priority = 'high'"
+                    steps:
+                      - do: escalate_to_human
+        - condition: "=$output.route_by_intent.route = 'craft_sales_pitch'"
+          steps:
+            - do: craft_sales_pitch
+        - condition: "=$output.route_by_intent.route = 'escalate_to_human'"
+          steps:
+            - do: escalate_to_human
+        - else:
+          steps:
+            - do: send_generic_summary
+
+  # Step 8: loop example showcasing for-each fan-out with an accumulator and early exit.
+  - loop:
+      type: for_each
+      name: notify_stakeholders                      # Optional: name surfaces $output.notify_stakeholders.*
+      description: "Fan out FYI updates to profile stakeholders until one acknowledges."
+      for_each:
+        item: stakeholder
+        in: "=$output.fetch_user_profile.profile.stakeholders" # expects [{name, email, role}]
+      max_concurrency: 2                            # throttle deliveries to avoid rate limits
+      until: "=$output.send_stakeholder_update.acknowledged = true" # break once any ack arrives
+      accumulate:
+        as: notifications                           # accumulator is visible as $accumulator.notifications
+        initial: []                                 # seed value for the accumulator
+        merge: >                                    # JSONata to append per-iteration output
+          = $append(
+              $accumulator.notifications,
+              [{'email': $iteration.item.email,
+                'status': $output.send_stakeholder_update.status,
+                'ack': $output.send_stakeholder_update.acknowledged}]
+            )
+      steps:
+        - do: draft_stakeholder_update              # has access to $iteration.item and $iteration.index
+        - do: send_stakeholder_update               # delivers the note and sets acknowledged flag
+      # Accumulated data is accessible as $output.notify_stakeholders.notifications downstream.
+
+  - do: send_email_response   # Step 9: final action uses outputs of whichever branch ran.
+
+# Final workflow outputs expose the important artifacts to callers.
+outputs:
+  delivered: "=$output.send_email_response.status"
+  intent: "=$output.understand_request.intent"
+  missing_fields_resolved: "=$count($output.understand_request.missing_fields) = 0"
+  user_reply: "=$exists($output.ask_for_missing_detail.text) ? $output.ask_for_missing_detail.text : null"
+  research_brief: "=$output.synthesize_research.synthesis"
+  ticket: "=$output.escalate_to_human.ticket_id" # may be null if no escalation occurred
+  stakeholder_notifications: "=$output.notify_stakeholders.notifications"
+
+# Notes:
+# - Expressions: strings starting with "=" are JSONata with scope {context, input, output};
+#   other strings are treated as literals.
+# - Accessors recap: $context.* (runtime info and long-term state you injected),
+#   $input.* (original workflow inputs), $output.* (raw results from prior tasks), $iteration.* (loop locals).
+# - Human-in-the-loop: tasks can declare settings.await_user=true to checkpoint execution, send a message,
+#   and resume when the user replies. Engines may optionally support on_timeout/fallback hooks, not shown here.
+# - Error handling & retries: globally configured in defaults, overridable per task (see above).
+# - Control flow: sequential steps (do), conditionals (conditional), fan-out (parallel, loop), and waits (await_user via task settings).

package/examples/loop/actions/await-reply.ts

@@ -0,0 +1,47 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from 'zod';
+
+import { defineAction } from '../../../src';
+import type { Settings } from '../../../src/dsl.types';
+import type { LoopExampleContext } from '../context';
+
+const inputSchema = z.object({});
+const resumeSchema = z.object({
+  text: z.string(),
+});
+const outputSchema = z.object({
+  text: z.string(),
+});
+
+type AwaitReplyInput = z.infer<typeof inputSchema>;
+type AwaitReplyOutput = z.infer<typeof outputSchema>;
+
+export const awaitReply = defineAction<
+  AwaitReplyInput,
+  AwaitReplyOutput,
+  LoopExampleContext,
+  Settings
+>({
+  name: 'await_reply',
+  description:
+    'Pause workflow execution until the simulated user sends a reply payload.',
+  inputSchema,
+  outputSchema,
+  execute: async ({ context }) => {
+    const resumeData = await context.workflow.suspend({
+      reason: 'awaiting_user_response',
+      data: { hint: 'Provide phone number' },
+    });
+    const parsed = resumeSchema.safeParse(resumeData);
+    if (!parsed.success) {
+      throw new Error('resumeData must include a string `text` field.');
+    }
+
+    return parsed.data;
+  },
+});

package/examples/loop/actions/index.ts

@@ -0,0 +1,19 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import type { Action, Settings } from '../../../src';
+import type { LoopExampleContext } from '../context';
+
+import { awaitReply } from './await-reply';
+import { sendTextMessage } from './send-text-message';
+
+export const loopExampleActions: Record<
+  string,
+  Action<unknown, unknown, LoopExampleContext, Settings>
+> = {
+  send_text_message: sendTextMessage,
+  await_reply: awaitReply,
+};

package/examples/loop/actions/send-text-message.ts

@@ -0,0 +1,40 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from 'zod';
+
+import { defineAction } from '../../../src';
+import type { Settings } from '../../../src/dsl.types';
+import type { LoopExampleContext } from '../context';
+
+const inputSchema = z.object({
+  text: z.string(),
+});
+const outputSchema = z.object({
+  text: z.string(),
+});
+
+type SendTextMessageInput = z.infer<typeof inputSchema>;
+type SendTextMessageOutput = z.infer<typeof outputSchema>;
+
+export const sendTextMessage = defineAction<
+  SendTextMessageInput,
+  SendTextMessageOutput,
+  LoopExampleContext,
+  Settings
+>({
+  name: 'send_text_message',
+  description: 'Mock action that emits a text message to the subscriber.',
+  inputSchema,
+  outputSchema,
+  execute: async ({ input, context }) => {
+    context.log('Send text message', { text: input.text });
+
+    return {
+      text: input.text,
+    };
+  },
+});

package/examples/loop/context.ts

@@ -0,0 +1,32 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  BaseWorkflowContext,
+  WorkflowEventEmitter,
+  type WorkflowEventEmitterLike,
+} from '../../src';
+
+export type LoopExampleContextState = {
+  channel: string;
+};
+
+export class LoopExampleContext extends BaseWorkflowContext<LoopExampleContextState> {
+  public eventEmitter: WorkflowEventEmitterLike<WorkflowEventEmitter>;
+
+  constructor(
+    state: LoopExampleContextState,
+    eventEmitter: WorkflowEventEmitterLike<WorkflowEventEmitter> = new WorkflowEventEmitter(),
+  ) {
+    super(state);
+    this.eventEmitter = eventEmitter;
+  }
+
+  log(message: string, payload?: unknown): void {
+    const suffix = payload === undefined ? '' : ` ${JSON.stringify(payload)}`;
+    console.log(`[loop] ${message}${suffix}`);
+  }
+}

package/examples/loop/workflow.ts

@@ -0,0 +1,66 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+import { Workflow, WorkflowEventEmitter } from '../../src';
+
+import { loopExampleActions } from './actions';
+import { LoopExampleContext } from './context';
+
+const workflowPath = path.join(__dirname, 'workflow.yml');
+
+async function main() {
+  const yamlSource = fs.readFileSync(workflowPath, 'utf8');
+  const workflow = Workflow.fromYaml(yamlSource, {
+    actions: loopExampleActions,
+  });
+  const emitter = new WorkflowEventEmitter();
+  const context = new LoopExampleContext({ channel: 'chat' }, emitter);
+
+  emitter.on('hook:workflow:start', () => context.log('workflow started'));
+  emitter.on('hook:workflow:suspended', ({ step, reason }) =>
+    context.log(`workflow suspended at "${step.name}"`, { reason }),
+  );
+  emitter.on('hook:workflow:finish', ({ output }) =>
+    context.log('workflow finished', output),
+  );
+
+  const runner = await workflow.buildAsyncRunner();
+  let result = await runner.start({
+    inputData: {},
+    context,
+  });
+  const simulatedReplies = ['12', '12345678'];
+  let attempt = 0;
+
+  while (result.status === 'suspended') {
+    const nextReply =
+      simulatedReplies[Math.min(attempt, simulatedReplies.length - 1)];
+    attempt += 1;
+
+    if (!nextReply) {
+      throw new Error('No simulated reply available for resuming the workflow');
+    }
+
+    context.log('resuming with simulated reply', { text: nextReply });
+    result = await runner.resume({
+      resumeData: { text: nextReply },
+    });
+  }
+
+  if (result.status === 'finished') {
+    console.log('Final workflow outputs:', result.output);
+
+    return;
+  }
+
+  console.error('Workflow failed:', result.error);
+}
+
+// pnpm dlx ts-node packages/agentic/examples/loop/workflow.ts
+void main();

package/examples/loop/workflow.yml

@@ -0,0 +1,66 @@
+defaults:
+  settings:
+    timeout_ms: 0
+    retries:
+      enabled: false
+      max_attempts: 3
+      backoff_ms: 25
+      max_delay_ms: 10000
+      jitter: 0
+      multiplier: 2
+
+defs:
+  ask_phone_number:
+    kind: task
+    description: Ask the subscriber for their phone number.
+    action: send_text_message
+    inputs:
+      text: Please enter your phone number in 8 digits.
+    settings:
+      typing: 0
+
+  ask_phone_number_again:
+    kind: task
+    description: Ask again when the provided value is invalid.
+    action: send_text_message
+    inputs:
+      text: Invalid phone number. Please enter exactly 8 digits.
+    settings:
+      typing: 0
+
+  confirm_phone_number:
+    kind: task
+    description: Confirm that the phone number was captured.
+    action: send_text_message
+    inputs:
+      text: Well received.
+    settings:
+      typing: 0
+
+  await_phone_reply:
+    kind: task
+    description: Suspend the workflow until a subscriber reply is received.
+    action: await_reply
+
+flow:
+  - do: ask_phone_number
+
+  - loop:
+      type: while
+      name: capture_phone_number
+      description: Keep waiting for a valid 8-digit phone number.
+      while: =$not($exists($output.await_phone_reply.text) and $exists($match($trim($output.await_phone_reply.text), /^\d{8}$/)))
+      steps:
+        - do: await_phone_reply
+        - conditional:
+            when:
+              - condition: =$exists($match($trim($output.await_phone_reply.text), /^\d{8}$/))
+                steps:
+                  - do: confirm_phone_number
+              - else: true
+                steps:
+                  - do: ask_phone_number_again
+
+outputs:
+  phone_number: =$trim($output.await_phone_reply.text)
+  result: =$trim($output.await_phone_reply.text)

package/examples/suspend-resume/actions/format-reply.ts

@@ -0,0 +1,43 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from 'zod';
+
+import { defineAction, type Settings } from '../../../src';
+import type { SuspendResumeContext } from '../context';
+
+const inputSchema = z.object({
+  reply: z.string(),
+});
+const outputSchema = z.object({
+  message: z.string(),
+});
+
+type FormatReplyInput = z.infer<typeof inputSchema>;
+type FormatReplyOutput = z.infer<typeof outputSchema>;
+
+export const formatReply = defineAction<
+  FormatReplyInput,
+  FormatReplyOutput,
+  SuspendResumeContext,
+  Settings
+>({
+  name: 'format_reply',
+  description: 'Formats the user reply captured after resuming execution.',
+  inputSchema,
+  outputSchema,
+  execute: async ({ input, context }) => {
+    const trimmed = input.reply.trim();
+
+    context.log('Formatting reply after resume', { reply: trimmed });
+
+    return {
+      message: trimmed
+        ? `User replied: ${trimmed}`
+        : 'No reply was provided when resuming the workflow.',
+    };
+  },
+});

package/examples/suspend-resume/actions/index.ts

@@ -0,0 +1,13 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { formatReply } from './format-reply';
+import { waitForUser } from './wait-for-user';
+
+export const suspendResumeActions = {
+  wait_for_user: waitForUser,
+  format_reply: formatReply,
+};