Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

15.9 KB
Raw Blame
import * as Match from "effect/Match";
import type { OpenCodeNativeLogRecord } from "./OpenCodeAdapterState.ts";

import type { ProviderDriverKind } from "@akeru/contracts";
import {
  EventId,
  type ProviderRuntimeEvent,
  RuntimeItemId,
  RuntimeRequestId,
  ThreadId,
  TurnId,
} from "@akeru/contracts";
import * as Cause from "effect/Cause";

import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";

import * as Ref from "effect/Ref";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";

import { ProviderAdapterRequestError } from "../../Errors.ts";

import {
  OpenCodeRuntimeError,
  openCodeRuntimeErrorDetail,
  runOpenCodeSdk,
} from "../../opencodeRuntime.ts";
import {
  PROVIDER,
  type OpenCodeSubscribedEvent,
  type OpenCodeRoutedRequestEvent,
  type OpenCodeTextPartState,
  type OpenCodeSessionContext,
  type EventBaseInput,
} from "./OpenCodeAdapterState.ts";
import {
  openCodeEventSessionId,
  openCodeEventSessionTitle,
  isOpenCodeChildRequestEvent,
  nowIso,
  toToolLifecycleItemType,
  sessionErrorMessage,
  updateProviderSession,
} from "./OpenCodeProtocol.ts";
import {
  forgetOpenCodeTextPart,
  retainOpenCodeTextPart,
  forgetOpenCodeTextMessage,
  resolveTextStreamKind,
  mergeOpenCodeAssistantText,
  appendOpenCodeAssistantTextDelta,
  isoFromEpochMs,
  messageRoleForPart,
  detailFromToolPart,
  toolStateCreatedAt,
} from "./OpenCodeText.ts";

export function createOpenCodeEvents(deps: {
  readonly emit: (event: ProviderRuntimeEvent) => Effect.Effect<void, never, never>;
  readonly buildEventBase: (input: EventBaseInput) => Effect.Effect<
    {
      raw?: { source: "opencode.sdk.event"; payload: {} | null };
      requestId?: RuntimeRequestId;
      itemId?: RuntimeItemId;
      turnId?: TurnId;
      eventId: EventId;
      provider: ProviderDriverKind;
      threadId: ThreadId;
      createdAt: string;
    },
    ProviderAdapterRequestError,
    never
  >;
  readonly addRelatedOpenCodeSession: (context: OpenCodeSessionContext, sessionId: string) => void;
  readonly scheduleRequestRelationRetry: (
    context: OpenCodeSessionContext,
    event: OpenCodeRoutedRequestEvent,
  ) => Effect.Effect<void, never, never>;
  readonly writeNativeEventBestEffort: (
    threadId: ThreadId,
    event: OpenCodeNativeLogRecord,
  ) => Effect.Effect<void, never, never>;
  readonly emitOpenCodeRequestEvent: (
    context: OpenCodeSessionContext,
    event: OpenCodeRoutedRequestEvent,
  ) => Effect.Effect<void, ProviderAdapterRequestError, never>;
  readonly emitUnexpectedExit: (
    context: OpenCodeSessionContext,
    message: string,
  ) => Effect.Effect<void, ProviderAdapterRequestError, never>;
}) {
  const emitAssistantTextDelta = Effect.fn("emitAssistantTextDelta")(function* (
    context: OpenCodeSessionContext,
    part: OpenCodeTextPartState,
    turnId: TurnId | undefined,
    raw: OpenCodeSubscribedEvent,
  ) {
    const text = part.text;

    if (text === undefined) {
      return;
    }

    const { latestText, deltaToEmit } = mergeOpenCodeAssistantText(part.emittedText, text);
    part.emittedText = latestText;
    part.text = latestText;

    if (deltaToEmit.length > 0) {
      yield* deps.emit({
        ...(yield* deps.buildEventBase({
          threadId: context.session.threadId,
          turnId,
          itemId: part.id,
          createdAt:
            (part.type === "text" || part.type === "reasoning") && part.time !== undefined
              ? isoFromEpochMs(part.time.start)
              : undefined,
          raw,
        })),
        type: "content.delta",
        payload: {
          streamKind: resolveTextStreamKind(part),
          delta: deltaToEmit,
        },
      });
    }

    if (part.type === "text" && part.time?.end !== undefined && !part.completed) {
      part.completed = true;
      yield* deps.emit({
        ...(yield* deps.buildEventBase({
          threadId: context.session.threadId,
          turnId,
          itemId: part.id,
          createdAt: isoFromEpochMs(part.time.end),
          raw,
        })),
        type: "item.completed",
        payload: {
          itemType: "assistant_message",
          status: "completed",
          title: "Assistant message",
          ...(latestText.length > 0 ? { detail: latestText } : {}),
        },
      });
    }
  });

  const handleSubscribedEvent = Effect.fn("handleSubscribedEvent")(function* (
    context: OpenCodeSessionContext,
    event: OpenCodeSubscribedEvent,
  ) {
    if (event.type === "session.created" || event.type === "session.updated") {
      const session = event.properties.info;

      if (session.parentID && context.relatedSessionIds.has(session.parentID)) {
        deps.addRelatedOpenCodeSession(context, session.id);
      }
    } else if (event.type === "session.deleted") {
      context.relatedSessionIds.delete(event.properties.info.id);
    }

    const payloadSessionId = openCodeEventSessionId(event);
    const isParentEvent = payloadSessionId === context.openCodeSessionId;
    let isKnownPendingTerminalEvent = false;

    if (
      payloadSessionId !== undefined &&
      !context.relatedSessionIds.has(payloadSessionId) &&
      isOpenCodeChildRequestEvent(event)
    ) {
      if (
        event.type === "permission.asked" ||
        event.type === "question.asked" ||
        event.type === "permission.replied" ||
        event.type === "question.replied" ||
        event.type === "question.rejected"
      ) {
        const requestId =
          event.type === "permission.asked" || event.type === "question.asked"
            ? event.properties.id
            : event.properties.requestID;

        isKnownPendingTerminalEvent =
          event.type !== "permission.asked" &&
          event.type !== "question.asked" &&
          (context.pendingPermissions.has(requestId) || context.pendingQuestions.has(requestId));

        if (!isKnownPendingTerminalEvent) {
          yield* deps.scheduleRequestRelationRetry(context, event);

          return;
        }
      }
    }

    const isChildRequestEvent =
      payloadSessionId !== undefined &&
      isOpenCodeChildRequestEvent(event) &&
      (context.relatedSessionIds.has(payloadSessionId) || isKnownPendingTerminalEvent);

    if (!isParentEvent && !isChildRequestEvent) {
      return;
    }

    const turnId = context.activeTurnId;
    yield* deps.writeNativeEventBestEffort(context.session.threadId, {
      observedAt: yield* nowIso,
      event: {
        provider: PROVIDER,
        threadId: context.session.threadId,
        providerThreadId: context.openCodeSessionId,
        type: event.type,
        ...(turnId ? { turnId } : {}),
        payload: event,
      },
    });

    switch (event.type) {
      case "session.updated": {
        const title = openCodeEventSessionTitle(event);

        if (title) {
          yield* deps.emit({
            ...(yield* deps.buildEventBase({
              threadId: context.session.threadId,
              raw: event,
            })),
            type: "thread.metadata.updated",
            payload: {
              name: title,
              metadata: {
                sessionID: context.openCodeSessionId,
              },
            },
          });
        }

        break;
      }

      case "message.updated": {
        context.messageRoleById.set(event.properties.info.id, event.properties.info.role);

        if (event.properties.info.role === "assistant") {
          const parts = context.textPartsByMessageId.get(event.properties.info.id);

          if (parts) {
            for (const part of parts.values()) {
              yield* emitAssistantTextDelta(context, part, turnId, event);
            }
          }
        }

        break;
      }

      case "message.removed": {
        context.messageRoleById.delete(event.properties.messageID);
        forgetOpenCodeTextMessage(context, event.properties.messageID);
        break;
      }

      case "message.part.removed": {
        forgetOpenCodeTextPart(context, event.properties.partID);
        break;
      }

      case "message.part.delta": {
        const existingPart = context.textPartById.get(event.properties.partID);

        if (!existingPart) {
          break;
        }

        const role = messageRoleForPart(context, existingPart);

        if (role !== "assistant") {
          break;
        }

        const streamKind = resolveTextStreamKind(existingPart);
        const delta = event.properties.delta;

        if (delta.length === 0) {
          break;
        }

        const previousText = existingPart.emittedText ?? existingPart.text ?? "";
        const { nextText, deltaToEmit } = appendOpenCodeAssistantTextDelta(previousText, delta);

        if (deltaToEmit.length === 0) {
          break;
        }

        existingPart.emittedText = nextText;
        existingPart.text = nextText;
        yield* deps.emit({
          ...(yield* deps.buildEventBase({
            threadId: context.session.threadId,
            turnId,
            itemId: event.properties.partID,
            raw: event,
          })),
          type: "content.delta",
          payload: {
            streamKind,
            delta: deltaToEmit,
          },
        });
        break;
      }

      case "message.part.updated": {
        const part = event.properties.part;
        const messageRole = messageRoleForPart(context, part);

        if (part.type === "text" || part.type === "reasoning") {
          const state = retainOpenCodeTextPart(context, part);

          if (messageRole === "assistant") {
            yield* emitAssistantTextDelta(context, state, turnId, event);
          }
        }

        if (part.type === "tool") {
          const itemType = toToolLifecycleItemType(part.tool);

          const title =
            part.state.status === "running" ? (part.state.title ?? part.tool) : part.tool;

          const detail = detailFromToolPart(part);

          const payload = {
            itemType,
            ...Match.value(part.state.status).pipe(
              Match.when("error", () => ({ status: "failed" as const })),
              Match.when("completed", () => ({ status: "completed" as const })),
              Match.orElse(() => ({ status: "inProgress" as const })),
            ),
            ...(title ? { title } : {}),
            ...(detail ? { detail } : {}),
            data: {
              tool: part.tool,
              state: part.state,
            },
          };

          const runtimeEvent: ProviderRuntimeEvent = {
            ...(yield* deps.buildEventBase({
              threadId: context.session.threadId,
              turnId,
              itemId: part.callID,
              createdAt: toolStateCreatedAt(part),
              raw: event,
            })),
            type:
              part.state.status === "pending"
                ? "item.started"
                : part.state.status === "completed" || part.state.status === "error"
                  ? "item.completed"
                  : "item.updated",
            payload,
          };

          yield* deps.emit(runtimeEvent);
        }

        break;
      }

      case "permission.asked":
      case "permission.replied":
      case "question.asked":
      case "question.replied":
      case "question.rejected": {
        yield* deps.emitOpenCodeRequestEvent(context, event);
        break;
      }

      case "session.status": {
        if (event.properties.status.type === "busy") {
          yield* updateProviderSession(context, {
            status: "running",
            activeTurnId: turnId,
          });
        }

        if (event.properties.status.type === "retry") {
          yield* deps.emit({
            ...(yield* deps.buildEventBase({
              threadId: context.session.threadId,
              turnId,
              raw: event,
            })),
            type: "runtime.warning",
            payload: {
              message: event.properties.status.message,
              detail: event.properties.status,
            },
          });
          break;
        }

        if (event.properties.status.type === "idle" && turnId) {
          context.activeTurnId = undefined;
          yield* updateProviderSession(context, { status: "ready" }, { clearActiveTurnId: true });
          yield* deps.emit({
            ...(yield* deps.buildEventBase({
              threadId: context.session.threadId,
              turnId,
              raw: event,
            })),
            type: "turn.completed",
            payload: {
              state: "completed",
            },
          });
        }

        break;
      }

      case "session.error": {
        const message = sessionErrorMessage(event.properties.error);
        const activeTurnId = context.activeTurnId;
        context.activeTurnId = undefined;
        yield* updateProviderSession(
          context,
          {
            status: "error",
            lastError: message,
          },
          { clearActiveTurnId: true },
        );

        if (activeTurnId) {
          yield* deps.emit({
            ...(yield* deps.buildEventBase({
              threadId: context.session.threadId,
              turnId: activeTurnId,
              raw: event,
            })),
            type: "turn.completed",
            payload: {
              state: "failed",
              errorMessage: message,
            },
          });
        }

        yield* deps.emit({
          ...(yield* deps.buildEventBase({
            threadId: context.session.threadId,
            raw: event,
          })),
          type: "runtime.error",
          payload: {
            message,
            class: "provider_error",
            detail: event.properties.error,
          },
        });
        break;
      }

      default:
        break;
    }
  });

  const startEventPump = Effect.fn("startEventPump")(function* (context: OpenCodeSessionContext) {
    // One AbortController per session scope. The finalizer fires when
    // the scope closes (explicit stop, unexpected exit, or layer
    // shutdown) and cancels the in-flight `event.subscribe` fetch so
    // the async iterable unwinds cleanly.
    const eventsAbortController = new AbortController();
    yield* Scope.addFinalizer(
      context.sessionScope,
      Effect.sync(() => eventsAbortController.abort()),
    );

    // Fibers forked into `context.sessionScope` are interrupted
    // automatically when the scope closes — no bookkeeping required.
    yield* Effect.flatMap(
      runOpenCodeSdk("event.subscribe", () =>
        context.client.event.subscribe(undefined, {
          signal: eventsAbortController.signal,
        }),
      ),
      (subscription) =>
        Stream.fromAsyncIterable(
          subscription.stream,
          (cause) =>
            new OpenCodeRuntimeError({
              operation: "event.subscribe",
              detail: openCodeRuntimeErrorDetail(cause),
              cause,
            }),
        ).pipe(Stream.runForEach((event) => handleSubscribedEvent(context, event))),
    ).pipe(
      Effect.exit,
      Effect.flatMap((exit) =>
        Effect.gen(function* () {
          // Expected paths: caller aborted the fetch or the session
          // has already been marked stopped. Treat as a clean exit.
          if (eventsAbortController.signal.aborted || (yield* Ref.get(context.stopped))) {
            return;
          }

          if (Exit.isFailure(exit)) {
            yield* deps.emitUnexpectedExit(
              context,
              openCodeRuntimeErrorDetail(Cause.squash(exit.cause)),
            );
          }
        }),
      ),
      Effect.forkIn(context.sessionScope),
    );

    if (!context.server.external && context.server.exitCode !== null) {
      yield* context.server.exitCode.pipe(
        Effect.flatMap((code) =>
          Effect.gen(function* () {
            if (yield* Ref.get(context.stopped)) {
              return;
            }

            yield* deps.emitUnexpectedExit(
              context,
              `OpenCode server exited unexpectedly (${code}).`,
            );
          }),
        ),
        Effect.forkIn(context.sessionScope),
      );
    }
  });

  return { emitAssistantTextDelta, handleSubscribedEvent, startEventPump };
}