ExecutionEvent =
  | ExecutionStarted
  | ToolCallStarted
  | ToolCallFinished
  | InteractionStarted
  | InteractionResolved
  | ExecutionFinished

ExecutionObserver = {
  handle(event: ExecutionEvent): Effect<void, E>
}

emitExecutionEvent(event)
  -> reads currentExecutionObserver from Effect context
  -> observer.handle(event)

withExecutionObserver(observer)(effect)
  -> installs observer in Effect context
  -> logs and isolates non-interrupt observer failures
  -> preserves interrupt causes as cancellation

composeExecutionObservers(plugins, extensions)
  -> collects plugin.runtime.executionObserver(extension)
  -> dispatches each event to each plugin observer
  -> logs plugin id on observer failure

definePlugin(() => ({
  runtime: {
    executionObserver: (extension) => ({
      handle: (event) => Effect.Effect<void>
    })
  }
}))

createExecutionEngine({ executor, codeExecutor, observer })
  -> observeExecution = withExecutionObserver(observer ?? noopExecutionObserver)

  -> execute(code, options)
       -> runInlineExecution(code, options).pipe(observeExecution)

  -> executeWithPause(code, options)
       -> startPausableExecution(code, options).pipe(observeExecution)

  -> resume(executionId, response)
       -> resumeExecution(executionId, response).pipe(observeExecution)

makeExecutionStack(accountId, organizationId, organizationName)
  -> makeScopedExecutor(...)
  -> CodeExecutorProvider
  -> PluginsProvider
  -> composeExecutionObservers(plugins(), executor)
  -> createExecutionEngine({ executor, codeExecutor, observer })
  -> EngineDecorator.decorate(engine, identity)

engine.execute(code, { onElicitation, trigger })
  -> withExecutionObserver(observer)
     -> emitExecutionEvent(ExecutionStarted)
     -> codeExecutor.execute(code, observedInvoker)
        -> observedInvoker.invoke(toolCall)
           -> emitExecutionEvent(ToolCallStarted)
           -> inner.invoke(toolCall)
           -> emitExecutionEvent(ToolCallFinished)
        -> observeInlineElicitation(ctx)
           -> emitExecutionEvent(InteractionStarted)
           -> onElicitation(ctx)
           -> emitExecutionEvent(InteractionResolved)
     -> emitExecutionEvent(ExecutionFinished)

engine.executeWithPause(code, { trigger })
  -> withExecutionObserver(observer)
     -> emitExecutionEvent(ExecutionStarted)
     -> fork detached code execution fiber
        -> tool calls emit ToolCallStarted/ToolCallFinished
        -> elicitation handler emits InteractionStarted
        -> return paused execution to caller
     -> later, engine.resume(executionId, response)
        -> withExecutionObserver(observer)
        -> complete paused Deferred
        -> detached fiber continues
        -> emitExecutionEvent(InteractionResolved)
        -> emitExecutionEvent(ExecutionFinished)

import { Effect, Match } from "effect";
import { definePlugin, type ExecutionEvent } from "@executor-js/sdk";

const handleExecutionEvent = (history: ExecutionHistoryExtension) =>
  Match.type<ExecutionEvent>().pipe(
    Match.withReturnType<Effect.Effect<void, unknown>>(),
    Match.tag("ExecutionStarted", (event) =>
      history.store.createRun({
        executionId: event.executionId,
        owner: event.owner,
        code: event.code,
        trigger: event.trigger,
        startedAt: event.startedAt,
      }),
    ),
    Match.tag("ToolCallStarted", (event) =>
      history.store.createToolCall({
        executionId: event.executionId,
        toolCallId: event.toolCallId,
        path: event.path,
        args: event.args,
        startedAt: event.startedAt,
      }),
    ),
    Match.tag("ToolCallFinished", (event) =>
      history.store.finishToolCall({
        toolCallId: event.toolCallId,
        status: event.status,
        result: event.result,
        error: event.error,
        completedAt: event.completedAt,
      }),
    ),
    Match.tag("InteractionStarted", (event) =>
      history.store.createInteraction({
        executionId: event.executionId,
        interactionId: event.interactionId,
        context: event.context,
        startedAt: event.startedAt,
      }),
    ),
    Match.tag("InteractionResolved", (event) =>
      history.store.resolveInteraction({
        interactionId: event.interactionId,
        status: event.status,
        response: event.response,
        error: event.error,
        completedAt: event.completedAt,
      }),
    ),
    Match.tag("ExecutionFinished", (event) =>
      history.store.finishRun({
        executionId: event.executionId,
        status: event.status,
        result: event.result,
        error: event.error,
        logs: event.logs,
        completedAt: event.completedAt,
      }),
    ),
    Match.exhaustive,
  );

const executionHistoryPlugin = definePlugin(() => ({
  id: "execution-history",
  storage: () => ({
    executions: executionTable,
    toolCalls: toolCallTable,
    interactions: interactionTable,
  }),
  extension: (ctx) => ({
    store: makeExecutionHistoryStore(ctx.storage),
  }),
  runtime: {
    executionObserver: (history) => ({
      handle: handleExecutionEvent(history),
    }),
  },
}));