agent-mockingbird 0.0.1

package/apps/server/src/backend/contracts/events.ts

@@ -0,0 +1,320 @@
+import type {
+  ChatMessage,
+  ChatMessagePart,
+  HeartbeatSnapshot,
+  SessionMessagePartPhase,
+  SessionSummary,
+  UsageSnapshot,
+} from "@agent-mockingbird/contracts/dashboard";
+
+type RuntimeEventSource = "api" | "runtime" | "scheduler" | "system";
+
+interface RuntimeEventBase<TType extends string, TPayload> {
+  id: string;
+  type: TType;
+  source: RuntimeEventSource;
+  at: string;
+  payload: TPayload;
+}
+
+export type HeartbeatUpdatedEvent = RuntimeEventBase<"heartbeat.updated", HeartbeatSnapshot>;
+export type UsageUpdatedEvent = RuntimeEventBase<"usage.updated", UsageSnapshot>;
+export type SessionStateUpdatedEvent = RuntimeEventBase<"session.state.updated", SessionSummary>;
+
+interface SessionMessageCreatedPayload {
+  sessionId: string;
+  message: ChatMessage;
+}
+export type SessionMessageCreatedEvent = RuntimeEventBase<"session.message.created", SessionMessageCreatedPayload>;
+
+interface SessionMessagePartUpdatedPayload {
+  sessionId: string;
+  messageId: string;
+  part: ChatMessagePart;
+  phase: SessionMessagePartPhase;
+  observedAt: string;
+}
+export type SessionMessagePartUpdatedEvent = RuntimeEventBase<"session.message.part.updated", SessionMessagePartUpdatedPayload>;
+
+interface SessionMessageDeltaPayload {
+  sessionId: string;
+  messageId: string;
+  text: string;
+  mode: "append" | "replace";
+  observedAt: string;
+}
+export type SessionMessageDeltaEvent = RuntimeEventBase<"session.message.delta", SessionMessageDeltaPayload>;
+
+interface SessionRunStatusPayload {
+  sessionId: string;
+  status: "idle" | "busy" | "retry";
+  attempt?: number;
+  message?: string;
+  nextAt?: string;
+}
+export type SessionRunStatusUpdatedEvent = RuntimeEventBase<"session.run.status.updated", SessionRunStatusPayload>;
+
+interface SessionCompactedPayload {
+  sessionId: string;
+}
+export type SessionCompactedEvent = RuntimeEventBase<"session.compacted", SessionCompactedPayload>;
+
+interface SessionRunErrorPayload {
+  sessionId: string | null;
+  name?: string;
+  message: string;
+}
+export type SessionRunErrorEvent = RuntimeEventBase<"session.run.error", SessionRunErrorPayload>;
+
+interface SessionPermissionRequestPayload {
+  id: string;
+  sessionId: string;
+  permission: string;
+  patterns: string[];
+  metadata: Record<string, unknown>;
+  always: string[];
+}
+export type SessionPermissionRequestedEvent = RuntimeEventBase<
+  "session.permission.requested",
+  SessionPermissionRequestPayload
+>;
+
+interface SessionPermissionResolvedPayload {
+  sessionId: string;
+  requestId: string;
+  reply: "once" | "always" | "reject";
+}
+export type SessionPermissionResolvedEvent = RuntimeEventBase<
+  "session.permission.resolved",
+  SessionPermissionResolvedPayload
+>;
+
+interface SessionQuestionOption {
+  label: string;
+  description: string;
+}
+
+interface SessionQuestionInfo {
+  question: string;
+  header: string;
+  options: SessionQuestionOption[];
+  multiple?: boolean;
+  custom?: boolean;
+}
+
+interface SessionQuestionRequestPayload {
+  id: string;
+  sessionId: string;
+  questions: SessionQuestionInfo[];
+}
+export type SessionQuestionRequestedEvent = RuntimeEventBase<
+  "session.question.requested",
+  SessionQuestionRequestPayload
+>;
+
+interface SessionQuestionResolvedPayload {
+  sessionId: string;
+  requestId: string;
+  outcome: "replied" | "rejected";
+}
+export type SessionQuestionResolvedEvent = RuntimeEventBase<
+  "session.question.resolved",
+  SessionQuestionResolvedPayload
+>;
+
+interface BackgroundRunUpdatedPayload {
+  runId: string;
+  parentSessionId: string;
+  parentExternalSessionId: string;
+  childExternalSessionId: string;
+  childSessionId: string | null;
+  requestedBy: string;
+  prompt: string;
+  status: "created" | "running" | "retrying" | "idle" | "completed" | "failed" | "aborted";
+  resultSummary: string | null;
+  error: string | null;
+  createdAt: string;
+  updatedAt: string;
+  startedAt: string | null;
+  completedAt: string | null;
+}
+export type BackgroundRunUpdatedEvent = RuntimeEventBase<"background.run.updated", BackgroundRunUpdatedPayload>;
+
+interface ConfigUpdatedPayload {
+  hash: string;
+  path: string;
+  providerCount: number;
+  modelCount: number;
+  smokeTestSessionId: string | null;
+  smokeTestResponse: string | null;
+}
+export type ConfigUpdatedEvent = RuntimeEventBase<"config.updated", ConfigUpdatedPayload>;
+
+interface ConfigUpdateFailedPayload {
+  stage: string;
+  message: string;
+}
+export type ConfigUpdateFailedEvent = RuntimeEventBase<"config.update.failed", ConfigUpdateFailedPayload>;
+
+interface ConfigRolledBackPayload {
+  attemptedHash: string | null;
+  restoredHash: string | null;
+  message: string;
+}
+export type ConfigRolledBackEvent = RuntimeEventBase<"config.update.rolled_back", ConfigRolledBackPayload>;
+
+interface SkillsCatalogUpdatedPayload {
+  revision: string;
+}
+export type SkillsCatalogUpdatedEvent = RuntimeEventBase<"skills.catalog.updated", SkillsCatalogUpdatedPayload>;
+
+export type RuntimeEvent =
+  | HeartbeatUpdatedEvent
+  | UsageUpdatedEvent
+  | SessionStateUpdatedEvent
+  | SessionMessageCreatedEvent
+  | SessionMessagePartUpdatedEvent
+  | SessionMessageDeltaEvent
+  | SessionRunStatusUpdatedEvent
+  | SessionCompactedEvent
+  | SessionRunErrorEvent
+  | SessionPermissionRequestedEvent
+  | SessionPermissionResolvedEvent
+  | SessionQuestionRequestedEvent
+  | SessionQuestionResolvedEvent
+  | BackgroundRunUpdatedEvent
+  | ConfigUpdatedEvent
+  | ConfigUpdateFailedEvent
+  | ConfigRolledBackEvent
+  | SkillsCatalogUpdatedEvent;
+
+function baseRuntimeEvent<TType extends RuntimeEvent["type"], TPayload>(
+  type: TType,
+  payload: TPayload,
+  source: RuntimeEventSource,
+): RuntimeEventBase<TType, TPayload> {
+  return {
+    id: crypto.randomUUID(),
+    type,
+    source,
+    at: new Date().toISOString(),
+    payload,
+  };
+}
+
+export function createHeartbeatUpdatedEvent(payload: HeartbeatSnapshot, source: RuntimeEventSource): HeartbeatUpdatedEvent {
+  return baseRuntimeEvent("heartbeat.updated", payload, source);
+}
+
+export function createUsageUpdatedEvent(payload: UsageSnapshot, source: RuntimeEventSource): UsageUpdatedEvent {
+  return baseRuntimeEvent("usage.updated", payload, source);
+}
+
+export function createSessionStateUpdatedEvent(payload: SessionSummary, source: RuntimeEventSource): SessionStateUpdatedEvent {
+  return baseRuntimeEvent("session.state.updated", payload, source);
+}
+
+export function createSessionMessageCreatedEvent(
+  payload: SessionMessageCreatedPayload,
+  source: RuntimeEventSource,
+): SessionMessageCreatedEvent {
+  return baseRuntimeEvent("session.message.created", payload, source);
+}
+
+export function createSessionMessagePartUpdatedEvent(
+  payload: SessionMessagePartUpdatedPayload,
+  source: RuntimeEventSource,
+): SessionMessagePartUpdatedEvent {
+  return baseRuntimeEvent("session.message.part.updated", payload, source);
+}
+
+export function createSessionMessageDeltaEvent(
+  payload: SessionMessageDeltaPayload,
+  source: RuntimeEventSource,
+): SessionMessageDeltaEvent {
+  return baseRuntimeEvent("session.message.delta", payload, source);
+}
+
+export function createSessionRunStatusUpdatedEvent(
+  payload: SessionRunStatusPayload,
+  source: RuntimeEventSource,
+): SessionRunStatusUpdatedEvent {
+  return baseRuntimeEvent("session.run.status.updated", payload, source);
+}
+
+export function createSessionCompactedEvent(
+  payload: SessionCompactedPayload,
+  source: RuntimeEventSource,
+): SessionCompactedEvent {
+  return baseRuntimeEvent("session.compacted", payload, source);
+}
+
+export function createSessionRunErrorEvent(
+  payload: SessionRunErrorPayload,
+  source: RuntimeEventSource,
+): SessionRunErrorEvent {
+  return baseRuntimeEvent("session.run.error", payload, source);
+}
+
+export function createSessionPermissionRequestedEvent(
+  payload: SessionPermissionRequestPayload,
+  source: RuntimeEventSource,
+): SessionPermissionRequestedEvent {
+  return baseRuntimeEvent("session.permission.requested", payload, source);
+}
+
+export function createSessionPermissionResolvedEvent(
+  payload: SessionPermissionResolvedPayload,
+  source: RuntimeEventSource,
+): SessionPermissionResolvedEvent {
+  return baseRuntimeEvent("session.permission.resolved", payload, source);
+}
+
+export function createSessionQuestionRequestedEvent(
+  payload: SessionQuestionRequestPayload,
+  source: RuntimeEventSource,
+): SessionQuestionRequestedEvent {
+  return baseRuntimeEvent("session.question.requested", payload, source);
+}
+
+export function createSessionQuestionResolvedEvent(
+  payload: SessionQuestionResolvedPayload,
+  source: RuntimeEventSource,
+): SessionQuestionResolvedEvent {
+  return baseRuntimeEvent("session.question.resolved", payload, source);
+}
+
+export function createBackgroundRunUpdatedEvent(
+  payload: BackgroundRunUpdatedPayload,
+  source: RuntimeEventSource,
+): BackgroundRunUpdatedEvent {
+  return baseRuntimeEvent("background.run.updated", payload, source);
+}
+
+export function createConfigUpdatedEvent(
+  payload: ConfigUpdatedPayload,
+  source: RuntimeEventSource,
+): ConfigUpdatedEvent {
+  return baseRuntimeEvent("config.updated", payload, source);
+}
+
+export function createConfigUpdateFailedEvent(
+  payload: ConfigUpdateFailedPayload,
+  source: RuntimeEventSource,
+): ConfigUpdateFailedEvent {
+  return baseRuntimeEvent("config.update.failed", payload, source);
+}
+
+export function createConfigRolledBackEvent(
+  payload: ConfigRolledBackPayload,
+  source: RuntimeEventSource,
+): ConfigRolledBackEvent {
+  return baseRuntimeEvent("config.update.rolled_back", payload, source);
+}
+
+export function createSkillsCatalogUpdatedEvent(
+  payload: SkillsCatalogUpdatedPayload,
+  source: RuntimeEventSource,
+): SkillsCatalogUpdatedEvent {
+  return baseRuntimeEvent("skills.catalog.updated", payload, source);
+}

package/apps/server/src/backend/contracts/runtime.ts

@@ -0,0 +1,111 @@
+import type { ChatMessage } from "@agent-mockingbird/contracts/dashboard";
+
+import type { RuntimeEvent } from "./events";
+
+
+export interface RuntimeTextInputPart {
+  type: "text";
+  text: string;
+}
+
+export interface RuntimeFileInputPart {
+  type: "file";
+  mime: string;
+  filename?: string;
+  url: string;
+}
+
+export type RuntimeInputPart = RuntimeTextInputPart | RuntimeFileInputPart;
+
+export interface SendUserMessageInput {
+  sessionId: string;
+  content: string;
+  parts?: RuntimeInputPart[];
+  agent?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface RuntimeMessageAck {
+  sessionId: string;
+  messages: ChatMessage[];
+}
+
+export interface RuntimeHealthCheckInput {
+  force?: boolean;
+}
+
+export interface RuntimeHealthCheckResult {
+  ok: boolean;
+  checkedAt: string;
+  latencyMs: number | null;
+  fromCache: boolean;
+  cacheTtlMs: number;
+  cacheExpiresAt: string;
+  probeSessionId: string | null;
+  responseText: string | null;
+  error: { name: string; message: string } | null;
+}
+
+export type BackgroundRunStatus =
+  | "created"
+  | "running"
+  | "retrying"
+  | "idle"
+  | "completed"
+  | "failed"
+  | "aborted";
+
+export interface SpawnBackgroundSessionInput {
+  parentSessionId: string;
+  title?: string;
+  requestedBy?: string;
+  prompt?: string;
+}
+
+export interface BackgroundRunHandle {
+  runId: string;
+  parentSessionId: string;
+  parentExternalSessionId: string;
+  childExternalSessionId: string;
+  childSessionId: string | null;
+  requestedBy: string;
+  prompt: string;
+  status: BackgroundRunStatus;
+  resultSummary: string | null;
+  createdAt: string;
+  updatedAt: string;
+  startedAt: string | null;
+  completedAt: string | null;
+  error: string | null;
+}
+
+export interface PromptBackgroundAsyncInput {
+  runId: string;
+  content: string;
+  parts?: RuntimeInputPart[];
+  model?: string;
+  system?: string;
+  agent?: string;
+  noReply?: boolean;
+}
+
+export interface ListBackgroundRunsInput {
+  parentSessionId?: string;
+  limit?: number;
+  inFlightOnly?: boolean;
+}
+
+export interface RuntimeEngine {
+  sendUserMessage(input: SendUserMessageInput): Promise<RuntimeMessageAck>;
+  subscribe(onEvent: (event: RuntimeEvent) => void): () => void;
+  dispose?(): Promise<void> | void;
+  syncSessionMessages?(sessionId: string): Promise<void>;
+  checkHealth?(input?: RuntimeHealthCheckInput): Promise<RuntimeHealthCheckResult>;
+  abortSession?(sessionId: string): Promise<boolean>;
+  compactSession?(sessionId: string): Promise<boolean>;
+  spawnBackgroundSession?(input: SpawnBackgroundSessionInput): Promise<BackgroundRunHandle>;
+  promptBackgroundAsync?(input: PromptBackgroundAsyncInput): Promise<BackgroundRunHandle>;
+  getBackgroundStatus?(runId: string): Promise<BackgroundRunHandle | null>;
+  listBackgroundRuns?(input?: ListBackgroundRunsInput): Promise<Array<BackgroundRunHandle>>;
+  abortBackground?(runId: string): Promise<boolean>;
+}