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.

4.1 KB
Raw Blame
import * as Data from "effect/Data";
import * as Predicate from "effect/Predicate";
import type * as EffectAcpSchema from "effect-acp/schema";

import { type AcpPermissionRequest, type AcpParsedSessionEvent } from "./AcpRuntimeTypes.ts";
import {
  normalizeToolKind,
  toolCallState,
  parseTypedToolCallState,
  boundToolCallRawPayload,
} from "./AcpToolCalls.ts";

function normalizePlanStepStatus(
  raw: EffectAcpSchema.PlanEntry["status"] | "inProgress",
): "pending" | "inProgress" | "completed" {
  switch (raw) {
    case "completed":
      return "completed";
    case "in_progress":
    case "inProgress":
      return "inProgress";
    default:
      return "pending";
  }
}

export function parsePermissionRequest(
  params: EffectAcpSchema.RequestPermissionRequest,
): AcpPermissionRequest {
  const toolCall = toolCallState(
    {
      toolCallId: params.toolCall.toolCallId,
      title: params.toolCall.title,
      kind: params.toolCall.kind,
      status: params.toolCall.status,
      rawInput: params.toolCall.rawInput,
      rawOutput: params.toolCall.rawOutput,
      content: params.toolCall.content,
      locations: params.toolCall.locations,
    },
    { fallbackStatus: "pending" },
  );

  const kind = normalizeToolKind(params.toolCall.kind) ?? "unknown";

  const detail =
    toolCall?.command ??
    toolCall?.title ??
    toolCall?.detail ??
    (Predicate.isString(params.sessionId) ? `Session ${params.sessionId}` : undefined);

  return {
    kind,
    ...(detail ? { detail } : {}),
    ...(toolCall ? { toolCall } : {}),
  };
}

export function parseSessionUpdateEvent(params: EffectAcpSchema.SessionNotification) {
  const upd = params.update;
  const events: Array<AcpParsedSessionEvent> = [];
  let modeId: string | undefined;

  switch (upd.sessionUpdate) {
    case "current_mode_update": {
      modeId = upd.currentModeId.trim();

      if (modeId) {
        events.push(parsedEvents.ModeChanged({ modeId }));
      }

      break;
    }

    case "plan": {
      const plan = upd.entries.map((entry, index) => ({
        step: entry.content.trim().length > 0 ? entry.content.trim() : `Step ${index + 1}`,
        status: normalizePlanStepStatus(entry.status),
      }));

      if (plan.length > 0) {
        events.push(
          parsedEvents.PlanUpdated({
            payload: {
              plan,
            },
            rawPayload: params,
          }),
        );
      }

      break;
    }

    case "tool_call": {
      const toolCall = parseTypedToolCallState(upd, {
        fallbackStatus: "pending",
      });

      if (toolCall) {
        events.push(
          parsedEvents.ToolCallUpdated({
            toolCall,
            rawPayload: boundToolCallRawPayload(params, upd, toolCall),
          }),
        );
      }

      break;
    }

    case "tool_call_update": {
      const toolCall = parseTypedToolCallState(upd);

      if (toolCall) {
        events.push(
          parsedEvents.ToolCallUpdated({
            toolCall,
            rawPayload: boundToolCallRawPayload(params, upd, toolCall),
          }),
        );
      }

      break;
    }

    case "agent_message_chunk": {
      if (upd.content.type === "text" && upd.content.text.length > 0) {
        events.push(parsedEvents.ContentDelta({ text: upd.content.text, rawPayload: params }));
      }

      break;
    }

    default:
      break;
  }

  return { ...(modeId !== undefined ? { modeId } : {}), events };
}

export {
  type AcpSessionMode,
  type AcpSessionModeState,
  type AcpToolCallState,
  type AcpPlanUpdate,
  type AcpPermissionRequest,
  type AcpParsedSessionEvent,
  type AcpToolCallEmitDecisionInput,
  type AcpToolCallEmitDecision,
  type SessionLoadGate,
} from "./AcpRuntimeTypes.ts";

export {
  extractModelConfigId,
  findSessionConfigOption,
  collectSessionConfigOptionValues,
  parseSessionModeState,
  sessionModelStateFromInitialize,
  syntheticLoadSessionResponseFromInitialize,
} from "./AcpSessionModel.ts";

export { mergeToolCallState, decideToolCallUpdateEmission } from "./AcpToolCalls.ts";

export { sessionUpdateIsReplay, waitForSessionLoadReplayIdle } from "./AcpSessionReplay.ts";

const parsedEvents = Data.taggedEnum<AcpParsedSessionEvent>();