Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

2.2 KB
Raw Blame
import { sessionTurnOrigin } from "../core/turn-origin.ts";
import type { App } from "./app-types.ts";
import type { SessionStore } from "../sessions/session-store.ts";
import { parseScopeId, type ScopeId, type Session, type TurnOrigin } from "../types.ts";

export async function startSession(
  app: Pick<App, "turn" | "forkSession" | "spawnSession" | "discardSession">,
  sessions: Pick<SessionStore, "get" | "updateTitle">,
  actorId: string,
  input: {
    scopeId: ScopeId;
    forkOf?: string;
    text?: string;
    title?: string;
    origin?: TurnOrigin;
    sessionSenderId?: string;
    delegatingRunId?: string;
  },
): Promise<{ session: Session; refused?: string } | { error: string }> {
  const out = input.forkOf
    ? await app.forkSession(input.forkOf, actorId)
    : await app.spawnSession(actorId, { scopeId: input.scopeId, ...(input.title ? { title: input.title } : {}) });
  if (!out) return { error: "cannot start a session in this context" };
  if (input.forkOf && input.title) await sessions.updateTitle(out.session.id, input.title);
  const current = async () => (await sessions.get(out.session.id)) ?? out.session;
  if (!input.text) return { session: await current() };
  const scope = parseScopeId(out.session.scopeId);
  const turn = await app.turn({
    surface: "web",
    actor: { externalId: actorId },
    conversation: {
      kind: out.session.type,
      threadRef: out.session.threadRef,
      ...(scope.kind === "channel" || scope.kind === "group" ? { channelRef: scope.ref } : {}),
      ...(out.session.channelName ? { channelName: out.session.channelName } : {}),
    },
    text: input.text,
    ...(input.origin ? { origin: sessionTurnOrigin(input.origin, input.text) } : {}),
    ...(input.sessionSenderId ? { sessionSenderId: input.sessionSenderId } : {}),
    ...(input.delegatingRunId ? { delegatingRunId: input.delegatingRunId } : {}),
    spawned: true,
    async: true,
  });
  if (turn.status !== "refused") return { session: await current() };
  const reason = (turn as { reason?: string }).reason ?? "the first message was refused";
  if (input.forkOf) return { session: await current(), refused: reason };
  await app.discardSession(out.session.id, actorId);
  return { error: reason };
}