fix: remove monorepo

app/lib/runtime/__snapshots__/message-parser.spec.ts.snap

@@ -0,0 +1,220 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (0) > onActionClose 1`] = `
+{
+  "action": {
+    "content": "npm install",
+    "type": "shell",
+  },
+  "actionId": "0",
+  "artifactId": "artifact_1",
+  "messageId": "message_1",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (0) > onActionOpen 1`] = `
+{
+  "action": {
+    "content": "",
+    "type": "shell",
+  },
+  "actionId": "0",
+  "artifactId": "artifact_1",
+  "messageId": "message_1",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onActionClose 1`] = `
+{
+  "action": {
+    "content": "npm install",
+    "type": "shell",
+  },
+  "actionId": "0",
+  "artifactId": "artifact_1",
+  "messageId": "message_1",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onActionClose 2`] = `
+{
+  "action": {
+    "content": "some content
+",
+    "filePath": "index.js",
+    "type": "file",
+  },
+  "actionId": "1",
+  "artifactId": "artifact_1",
+  "messageId": "message_1",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onActionOpen 1`] = `
+{
+  "action": {
+    "content": "",
+    "type": "shell",
+  },
+  "actionId": "0",
+  "artifactId": "artifact_1",
+  "messageId": "message_1",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onActionOpen 2`] = `
+{
+  "action": {
+    "content": "",
+    "filePath": "index.js",
+    "type": "file",
+  },
+  "actionId": "1",
+  "artifactId": "artifact_1",
+  "messageId": "message_1",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts with actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (0) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (1) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (2) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (2) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (3) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (3) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (4) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (4) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (5) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (5) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (6) > onArtifactClose 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;
+
+exports[`StreamingMessageParser > valid artifacts without actions > should correctly parse chunks and strip out bolt artifacts (6) > onArtifactOpen 1`] = `
+{
+  "id": "artifact_1",
+  "messageId": "message_1",
+  "title": "Some title",
+}
+`;

app/lib/runtime/action-runner.ts

@@ -0,0 +1,184 @@
+import { WebContainer } from '@webcontainer/api';
+import { map, type MapStore } from 'nanostores';
+import * as nodePath from 'node:path';
+import type { BoltAction } from '~/types/actions';
+import { createScopedLogger } from '~/utils/logger';
+import { unreachable } from '~/utils/unreachable';
+import type { ActionCallbackData } from './message-parser';
+
+const logger = createScopedLogger('ActionRunner');
+
+export type ActionStatus = 'pending' | 'running' | 'complete' | 'aborted' | 'failed';
+
+export type BaseActionState = BoltAction & {
+  status: Exclude<ActionStatus, 'failed'>;
+  abort: () => void;
+  executed: boolean;
+  abortSignal: AbortSignal;
+};
+
+export type FailedActionState = BoltAction &
+  Omit<BaseActionState, 'status'> & {
+    status: Extract<ActionStatus, 'failed'>;
+    error: string;
+  };
+
+export type ActionState = BaseActionState | FailedActionState;
+
+type BaseActionUpdate = Partial<Pick<BaseActionState, 'status' | 'abort' | 'executed'>>;
+
+export type ActionStateUpdate =
+  | BaseActionUpdate
+  | (Omit<BaseActionUpdate, 'status'> & { status: 'failed'; error: string });
+
+type ActionsMap = MapStore<Record<string, ActionState>>;
+
+export class ActionRunner {
+  #webcontainer: Promise<WebContainer>;
+  #currentExecutionPromise: Promise<void> = Promise.resolve();
+
+  actions: ActionsMap = map({});
+
+  constructor(webcontainerPromise: Promise<WebContainer>) {
+    this.#webcontainer = webcontainerPromise;
+  }
+
+  addAction(data: ActionCallbackData) {
+    const { actionId } = data;
+
+    const actions = this.actions.get();
+    const action = actions[actionId];
+
+    if (action) {
+      // action already added
+      return;
+    }
+
+    const abortController = new AbortController();
+
+    this.actions.setKey(actionId, {
+      ...data.action,
+      status: 'pending',
+      executed: false,
+      abort: () => {
+        abortController.abort();
+        this.#updateAction(actionId, { status: 'aborted' });
+      },
+      abortSignal: abortController.signal,
+    });
+
+    this.#currentExecutionPromise.then(() => {
+      this.#updateAction(actionId, { status: 'running' });
+    });
+  }
+
+  async runAction(data: ActionCallbackData) {
+    const { actionId } = data;
+    const action = this.actions.get()[actionId];
+
+    if (!action) {
+      unreachable(`Action ${actionId} not found`);
+    }
+
+    if (action.executed) {
+      return;
+    }
+
+    this.#updateAction(actionId, { ...action, ...data.action, executed: true });
+
+    this.#currentExecutionPromise = this.#currentExecutionPromise
+      .then(() => {
+        return this.#executeAction(actionId);
+      })
+      .catch((error) => {
+        console.error('Action failed:', error);
+      });
+  }
+
+  async #executeAction(actionId: string) {
+    const action = this.actions.get()[actionId];
+
+    this.#updateAction(actionId, { status: 'running' });
+
+    try {
+      switch (action.type) {
+        case 'shell': {
+          await this.#runShellAction(action);
+          break;
+        }
+        case 'file': {
+          await this.#runFileAction(action);
+          break;
+        }
+      }
+
+      this.#updateAction(actionId, { status: action.abortSignal.aborted ? 'aborted' : 'complete' });
+    } catch (error) {
+      this.#updateAction(actionId, { status: 'failed', error: 'Action failed' });
+
+      // re-throw the error to be caught in the promise chain
+      throw error;
+    }
+  }
+
+  async #runShellAction(action: ActionState) {
+    if (action.type !== 'shell') {
+      unreachable('Expected shell action');
+    }
+
+    const webcontainer = await this.#webcontainer;
+
+    const process = await webcontainer.spawn('jsh', ['-c', action.content]);
+
+    action.abortSignal.addEventListener('abort', () => {
+      process.kill();
+    });
+
+    process.output.pipeTo(
+      new WritableStream({
+        write(data) {
+          console.log(data);
+        },
+      }),
+    );
+
+    const exitCode = await process.exit;
+
+    logger.debug(`Process terminated with code ${exitCode}`);
+  }
+
+  async #runFileAction(action: ActionState) {
+    if (action.type !== 'file') {
+      unreachable('Expected file action');
+    }
+
+    const webcontainer = await this.#webcontainer;
+
+    let folder = nodePath.dirname(action.filePath);
+
+    // remove trailing slashes
+    folder = folder.replace(/\/+$/g, '');
+
+    if (folder !== '.') {
+      try {
+        await webcontainer.fs.mkdir(folder, { recursive: true });
+        logger.debug('Created folder', folder);
+      } catch (error) {
+        logger.error('Failed to create folder\n\n', error);
+      }
+    }
+
+    try {
+      await webcontainer.fs.writeFile(action.filePath, action.content);
+      logger.debug(`File written ${action.filePath}`);
+    } catch (error) {
+      logger.error('Failed to write file\n\n', error);
+    }
+  }
+
+  #updateAction(id: string, newState: ActionStateUpdate) {
+    const actions = this.actions.get();
+
+    this.actions.setKey(id, { ...actions[id], ...newState });
+  }
+}

app/lib/runtime/message-parser.spec.ts

@@ -0,0 +1,207 @@
+import { describe, expect, it, vi } from 'vitest';
+import { StreamingMessageParser, type ActionCallback, type ArtifactCallback } from './message-parser';
+
+interface ExpectedResult {
+  output: string;
+  callbacks?: {
+    onArtifactOpen?: number;
+    onArtifactClose?: number;
+    onActionOpen?: number;
+    onActionClose?: number;
+  };
+}
+
+describe('StreamingMessageParser', () => {
+  it('should pass through normal text', () => {
+    const parser = new StreamingMessageParser();
+    expect(parser.parse('test_id', 'Hello, world!')).toBe('Hello, world!');
+  });
+
+  it('should allow normal HTML tags', () => {
+    const parser = new StreamingMessageParser();
+    expect(parser.parse('test_id', 'Hello <strong>world</strong>!')).toBe('Hello <strong>world</strong>!');
+  });
+
+  describe('no artifacts', () => {
+    it.each<[string | string[], ExpectedResult | string]>([
+      ['Foo bar', 'Foo bar'],
+      ['Foo bar <', 'Foo bar '],
+      ['Foo bar <p', 'Foo bar <p'],
+      [['Foo bar <', 's', 'p', 'an>some text</span>'], 'Foo bar <span>some text</span>'],
+    ])('should correctly parse chunks and strip out bolt artifacts (%#)', (input, expected) => {
+      runTest(input, expected);
+    });
+  });
+
+  describe('invalid or incomplete artifacts', () => {
+    it.each<[string | string[], ExpectedResult | string]>([
+      ['Foo bar <b', 'Foo bar '],
+      ['Foo bar <ba', 'Foo bar <ba'],
+      ['Foo bar <bol', 'Foo bar '],
+      ['Foo bar <bolt', 'Foo bar '],
+      ['Foo bar <bolta', 'Foo bar <bolta'],
+      ['Foo bar <boltA', 'Foo bar '],
+      ['Foo bar <boltArtifacs></boltArtifact>', 'Foo bar <boltArtifacs></boltArtifact>'],
+      ['Before <oltArtfiact>foo</boltArtifact> After', 'Before <oltArtfiact>foo</boltArtifact> After'],
+      ['Before <boltArtifactt>foo</boltArtifact> After', 'Before <boltArtifactt>foo</boltArtifact> After'],
+    ])('should correctly parse chunks and strip out bolt artifacts (%#)', (input, expected) => {
+      runTest(input, expected);
+    });
+  });
+
+  describe('valid artifacts without actions', () => {
+    it.each<[string | string[], ExpectedResult | string]>([
+      [
+        'Some text before <boltArtifact title="Some title" id="artifact_1">foo bar</boltArtifact> Some more text',
+        {
+          output: 'Some text before  Some more text',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 0, onActionClose: 0 },
+        },
+      ],
+      [
+        ['Some text before <boltArti', 'fact', ' title="Some title" id="artifact_1">foo</boltArtifact> Some more text'],
+        {
+          output: 'Some text before  Some more text',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 0, onActionClose: 0 },
+        },
+      ],
+      [
+        [
+          'Some text before <boltArti',
+          'fac',
+          't title="Some title" id="artifact_1"',
+          ' ',
+          '>',
+          'foo</boltArtifact> Some more text',
+        ],
+        {
+          output: 'Some text before  Some more text',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 0, onActionClose: 0 },
+        },
+      ],
+      [
+        [
+          'Some text before <boltArti',
+          'fact',
+          ' title="Some title" id="artifact_1"',
+          ' >fo',
+          'o</boltArtifact> Some more text',
+        ],
+        {
+          output: 'Some text before  Some more text',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 0, onActionClose: 0 },
+        },
+      ],
+      [
+        [
+          'Some text before <boltArti',
+          'fact tit',
+          'le="Some ',
+          'title" id="artifact_1">fo',
+          'o',
+          '<',
+          '/boltArtifact> Some more text',
+        ],
+        {
+          output: 'Some text before  Some more text',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 0, onActionClose: 0 },
+        },
+      ],
+      [
+        [
+          'Some text before <boltArti',
+          'fact title="Some title" id="artif',
+          'act_1">fo',
+          'o<',
+          '/boltArtifact> Some more text',
+        ],
+        {
+          output: 'Some text before  Some more text',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 0, onActionClose: 0 },
+        },
+      ],
+      [
+        'Before <boltArtifact title="Some title" id="artifact_1">foo</boltArtifact> After',
+        {
+          output: 'Before  After',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 0, onActionClose: 0 },
+        },
+      ],
+    ])('should correctly parse chunks and strip out bolt artifacts (%#)', (input, expected) => {
+      runTest(input, expected);
+    });
+  });
+
+  describe('valid artifacts with actions', () => {
+    it.each<[string | string[], ExpectedResult | string]>([
+      [
+        'Before <boltArtifact title="Some title" id="artifact_1"><boltAction type="shell">npm install</boltAction></boltArtifact> After',
+        {
+          output: 'Before  After',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 1, onActionClose: 1 },
+        },
+      ],
+      [
+        'Before <boltArtifact title="Some title" id="artifact_1"><boltAction type="shell">npm install</boltAction><boltAction type="file" filePath="index.js">some content</boltAction></boltArtifact> After',
+        {
+          output: 'Before  After',
+          callbacks: { onArtifactOpen: 1, onArtifactClose: 1, onActionOpen: 2, onActionClose: 2 },
+        },
+      ],
+    ])('should correctly parse chunks and strip out bolt artifacts (%#)', (input, expected) => {
+      runTest(input, expected);
+    });
+  });
+});
+
+function runTest(input: string | string[], outputOrExpectedResult: string | ExpectedResult) {
+  let expected: ExpectedResult;
+
+  if (typeof outputOrExpectedResult === 'string') {
+    expected = { output: outputOrExpectedResult };
+  } else {
+    expected = outputOrExpectedResult;
+  }
+
+  const callbacks = {
+    onArtifactOpen: vi.fn<ArtifactCallback>((data) => {
+      expect(data).toMatchSnapshot('onArtifactOpen');
+    }),
+    onArtifactClose: vi.fn<ArtifactCallback>((data) => {
+      expect(data).toMatchSnapshot('onArtifactClose');
+    }),
+    onActionOpen: vi.fn<ActionCallback>((data) => {
+      expect(data).toMatchSnapshot('onActionOpen');
+    }),
+    onActionClose: vi.fn<ActionCallback>((data) => {
+      expect(data).toMatchSnapshot('onActionClose');
+    }),
+  };
+
+  const parser = new StreamingMessageParser({
+    artifactElement: () => '',
+    callbacks,
+  });
+
+  let message = '';
+
+  let result = '';
+
+  const chunks = Array.isArray(input) ? input : input.split('');
+
+  for (const chunk of chunks) {
+    message += chunk;
+
+    result += parser.parse('message_1', message);
+  }
+
+  for (const name in expected.callbacks) {
+    const callbackName = name;
+
+    expect(callbacks[callbackName as keyof typeof callbacks]).toHaveBeenCalledTimes(
+      expected.callbacks[callbackName as keyof typeof expected.callbacks] ?? 0,
+    );
+  }
+
+  expect(result).toEqual(expected.output);
+}

app/lib/runtime/message-parser.ts

@@ -0,0 +1,285 @@
+import type { ActionType, BoltAction, BoltActionData, FileAction, ShellAction } from '~/types/actions';
+import type { BoltArtifactData } from '~/types/artifact';
+import { createScopedLogger } from '~/utils/logger';
+import { unreachable } from '~/utils/unreachable';
+
+const ARTIFACT_TAG_OPEN = '<boltArtifact';
+const ARTIFACT_TAG_CLOSE = '</boltArtifact>';
+const ARTIFACT_ACTION_TAG_OPEN = '<boltAction';
+const ARTIFACT_ACTION_TAG_CLOSE = '</boltAction>';
+
+const logger = createScopedLogger('MessageParser');
+
+export interface ArtifactCallbackData extends BoltArtifactData {
+  messageId: string;
+}
+
+export interface ActionCallbackData {
+  artifactId: string;
+  messageId: string;
+  actionId: string;
+  action: BoltAction;
+}
+
+export type ArtifactCallback = (data: ArtifactCallbackData) => void;
+export type ActionCallback = (data: ActionCallbackData) => void;
+
+export interface ParserCallbacks {
+  onArtifactOpen?: ArtifactCallback;
+  onArtifactClose?: ArtifactCallback;
+  onActionOpen?: ActionCallback;
+  onActionClose?: ActionCallback;
+}
+
+interface ElementFactoryProps {
+  messageId: string;
+}
+
+type ElementFactory = (props: ElementFactoryProps) => string;
+
+export interface StreamingMessageParserOptions {
+  callbacks?: ParserCallbacks;
+  artifactElement?: ElementFactory;
+}
+
+interface MessageState {
+  position: number;
+  insideArtifact: boolean;
+  insideAction: boolean;
+  currentArtifact?: BoltArtifactData;
+  currentAction: BoltActionData;
+  actionId: number;
+}
+
+export class StreamingMessageParser {
+  #messages = new Map<string, MessageState>();
+
+  constructor(private _options: StreamingMessageParserOptions = {}) {}
+
+  parse(messageId: string, input: string) {
+    let state = this.#messages.get(messageId);
+
+    if (!state) {
+      state = {
+        position: 0,
+        insideAction: false,
+        insideArtifact: false,
+        currentAction: { content: '' },
+        actionId: 0,
+      };
+
+      this.#messages.set(messageId, state);
+    }
+
+    let output = '';
+    let i = state.position;
+    let earlyBreak = false;
+
+    while (i < input.length) {
+      if (state.insideArtifact) {
+        const currentArtifact = state.currentArtifact;
+
+        if (currentArtifact === undefined) {
+          unreachable('Artifact not initialized');
+        }
+
+        if (state.insideAction) {
+          const closeIndex = input.indexOf(ARTIFACT_ACTION_TAG_CLOSE, i);
+
+          const currentAction = state.currentAction;
+
+          if (closeIndex !== -1) {
+            currentAction.content += input.slice(i, closeIndex);
+
+            let content = currentAction.content.trim();
+
+            if ('type' in currentAction && currentAction.type === 'file') {
+              content += '\n';
+            }
+
+            currentAction.content = content;
+
+            this._options.callbacks?.onActionClose?.({
+              artifactId: currentArtifact.id,
+              messageId,
+
+              /**
+               * We decrement the id because it's been incremented already
+               * when `onActionOpen` was emitted to make sure the ids are
+               * the same.
+               */
+              actionId: String(state.actionId - 1),
+
+              action: currentAction as BoltAction,
+            });
+
+            state.insideAction = false;
+            state.currentAction = { content: '' };
+
+            i = closeIndex + ARTIFACT_ACTION_TAG_CLOSE.length;
+          } else {
+            break;
+          }
+        } else {
+          const actionOpenIndex = input.indexOf(ARTIFACT_ACTION_TAG_OPEN, i);
+          const artifactCloseIndex = input.indexOf(ARTIFACT_TAG_CLOSE, i);
+
+          if (actionOpenIndex !== -1 && (artifactCloseIndex === -1 || actionOpenIndex < artifactCloseIndex)) {
+            const actionEndIndex = input.indexOf('>', actionOpenIndex);
+
+            if (actionEndIndex !== -1) {
+              state.insideAction = true;
+
+              state.currentAction = this.#parseActionTag(input, actionOpenIndex, actionEndIndex);
+
+              this._options.callbacks?.onActionOpen?.({
+                artifactId: currentArtifact.id,
+                messageId,
+                actionId: String(state.actionId++),
+                action: state.currentAction as BoltAction,
+              });
+
+              i = actionEndIndex + 1;
+            } else {
+              break;
+            }
+          } else if (artifactCloseIndex !== -1) {
+            this._options.callbacks?.onArtifactClose?.({ messageId, ...currentArtifact });
+
+            state.insideArtifact = false;
+            state.currentArtifact = undefined;
+
+            i = artifactCloseIndex + ARTIFACT_TAG_CLOSE.length;
+          } else {
+            break;
+          }
+        }
+      } else if (input[i] === '<' && input[i + 1] !== '/') {
+        let j = i;
+        let potentialTag = '';
+
+        while (j < input.length && potentialTag.length < ARTIFACT_TAG_OPEN.length) {
+          potentialTag += input[j];
+
+          if (potentialTag === ARTIFACT_TAG_OPEN) {
+            const nextChar = input[j + 1];
+
+            if (nextChar && nextChar !== '>' && nextChar !== ' ') {
+              output += input.slice(i, j + 1);
+              i = j + 1;
+              break;
+            }
+
+            const openTagEnd = input.indexOf('>', j);
+
+            if (openTagEnd !== -1) {
+              const artifactTag = input.slice(i, openTagEnd + 1);
+
+              const artifactTitle = this.#extractAttribute(artifactTag, 'title') as string;
+              const artifactId = this.#extractAttribute(artifactTag, 'id') as string;
+
+              if (!artifactTitle) {
+                logger.warn('Artifact title missing');
+              }
+
+              if (!artifactId) {
+                logger.warn('Artifact id missing');
+              }
+
+              state.insideArtifact = true;
+
+              const currentArtifact = {
+                id: artifactId,
+                title: artifactTitle,
+              } satisfies BoltArtifactData;
+
+              state.currentArtifact = currentArtifact;
+
+              this._options.callbacks?.onArtifactOpen?.({ messageId, ...currentArtifact });
+
+              const artifactFactory = this._options.artifactElement ?? createArtifactElement;
+
+              output += artifactFactory({ messageId });
+
+              i = openTagEnd + 1;
+            } else {
+              earlyBreak = true;
+            }
+
+            break;
+          } else if (!ARTIFACT_TAG_OPEN.startsWith(potentialTag)) {
+            output += input.slice(i, j + 1);
+            i = j + 1;
+            break;
+          }
+
+          j++;
+        }
+
+        if (j === input.length && ARTIFACT_TAG_OPEN.startsWith(potentialTag)) {
+          break;
+        }
+      } else {
+        output += input[i];
+        i++;
+      }
+
+      if (earlyBreak) {
+        break;
+      }
+    }
+
+    state.position = i;
+
+    return output;
+  }
+
+  reset() {
+    this.#messages.clear();
+  }
+
+  #parseActionTag(input: string, actionOpenIndex: number, actionEndIndex: number) {
+    const actionTag = input.slice(actionOpenIndex, actionEndIndex + 1);
+
+    const actionType = this.#extractAttribute(actionTag, 'type') as ActionType;
+
+    const actionAttributes = {
+      type: actionType,
+      content: '',
+    };
+
+    if (actionType === 'file') {
+      const filePath = this.#extractAttribute(actionTag, 'filePath') as string;
+
+      if (!filePath) {
+        logger.debug('File path not specified');
+      }
+
+      (actionAttributes as FileAction).filePath = filePath;
+    } else if (actionType !== 'shell') {
+      logger.warn(`Unknown action type '${actionType}'`);
+    }
+
+    return actionAttributes as FileAction | ShellAction;
+  }
+
+  #extractAttribute(tag: string, attributeName: string): string | undefined {
+    const match = tag.match(new RegExp(`${attributeName}="([^"]*)"`, 'i'));
+    return match ? match[1] : undefined;
+  }
+}
+
+const createArtifactElement: ElementFactory = (props) => {
+  const elementProps = [
+    'class="__boltArtifact__"',
+    ...Object.entries(props).map(([key, value]) => {
+      return `data-${camelToDashCase(key)}=${JSON.stringify(value)}`;
+    }),
+  ];
+
+  return `<div ${elementProps.join(' ')}></div>`;
+};
+
+function camelToDashCase(input: string) {
+  return input.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}