@taico/events 0.1.0 → 0.2.6

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export * from './types/task-events.js';
 export * from './types/thread-events.js';
+export * from './types/worker-events.js';
+export * from './types/execution-events.js';

package/dist/index.js

@@ -1,2 +1,4 @@
 export * from './types/task-events.js';
 export * from './types/thread-events.js';
+export * from './types/worker-events.js';
+export * from './types/execution-events.js';

package/dist/types/execution-events.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Execution Wire Event Types for WebSocket Communication
+ *
+ * These types define the structure of events sent between backend and frontend
+ * via WebSocket for the Executions domain. They serve as a contract between the
+ * backend gateway and frontend consumers.
+ *
+ * Import these types in both backend (for emission) and frontend (for reception)
+ * to ensure type safety across the wire protocol.
+ */
+import type { MinimalEventActor } from './task-events.js';
+/**
+ * Wire event names for Executions domain
+ * These are the stable, external event identifiers sent over the wire protocol.
+ */
+export declare const ExecutionWireEvents: {
+    readonly EXECUTION_CREATED: "execution.created";
+    readonly EXECUTION_UPDATED: "execution.updated";
+    readonly EXECUTION_DELETED: "execution.deleted";
+    readonly EXECUTION_ACTIVITY: "execution.activity";
+    readonly EXECUTION_ACTIVITY_POST: "execution.activity.post";
+    readonly EXECUTION_HEARTBEAT_POST: "execution.heartbeat.post";
+};
+export type ExecutionWireEventName = (typeof ExecutionWireEvents)[keyof typeof ExecutionWireEvents];
+/**
+ * Execution structure as sent over the wire
+ * Matches ExecutionResponseDto from backend
+ */
+export interface ExecutionWirePayload {
+    id: string;
+    taskId: string;
+    taskName: string | null;
+    agentActorId: string;
+    agentSlug: string | null;
+    agentName: string | null;
+    status: 'READY' | 'CLAIMED' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'EXPIRED';
+    requestedAt: string;
+    claimedAt: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    workerSessionId: string | null;
+    leaseExpiresAt: string | null;
+    stopRequestedAt: string | null;
+    failureReason: string | null;
+    triggerReason: string | null;
+    rowVersion: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Execution created event
+ * Emitted when a new execution is created
+ */
+export interface ExecutionCreatedWireEvent {
+    payload: ExecutionWirePayload;
+    actor: MinimalEventActor;
+}
+/**
+ * Execution updated event
+ * Emitted when an execution is updated
+ */
+export interface ExecutionUpdatedWireEvent {
+    payload: ExecutionWirePayload;
+    actor: MinimalEventActor;
+}
+/**
+ * Execution deleted event
+ * Emitted when an execution is deleted
+ */
+export interface ExecutionDeletedWireEvent {
+    payload: {
+        executionId: string;
+    };
+    actor: MinimalEventActor;
+}
+export interface ExecutionActivityPayload {
+    executionId: string;
+    taskId: string;
+    agentActorId: string;
+    kind: string;
+    message?: string;
+    ts: number;
+    runnerSessionId?: string | null;
+}
+export interface PostExecutionActivityPayload {
+    executionId: string;
+    kind?: string;
+    message?: string;
+    ts?: number;
+    runnerSessionId?: string | null;
+}
+export interface PostExecutionHeartbeatPayload {
+    executionId: string;
+}
+/**
+ * Execution activity event
+ * Emitted for real-time activity updates from workers/runners
+ */
+export interface ExecutionActivityWireEvent {
+    payload: ExecutionActivityPayload;
+    actor: MinimalEventActor;
+}
+/**
+ * Union type of all execution wire events
+ */
+export type ExecutionWireEvent = ExecutionCreatedWireEvent | ExecutionUpdatedWireEvent | ExecutionDeletedWireEvent | ExecutionActivityWireEvent;
+/**
+ * Type guards for event identification
+ */
+export declare function isExecutionCreatedEvent(event: ExecutionWireEvent): event is ExecutionCreatedWireEvent;
+export declare function isExecutionDeletedEvent(event: ExecutionWireEvent): event is ExecutionDeletedWireEvent;

package/dist/types/execution-events.js

@@ -0,0 +1,31 @@
+/**
+ * Execution Wire Event Types for WebSocket Communication
+ *
+ * These types define the structure of events sent between backend and frontend
+ * via WebSocket for the Executions domain. They serve as a contract between the
+ * backend gateway and frontend consumers.
+ *
+ * Import these types in both backend (for emission) and frontend (for reception)
+ * to ensure type safety across the wire protocol.
+ */
+/**
+ * Wire event names for Executions domain
+ * These are the stable, external event identifiers sent over the wire protocol.
+ */
+export const ExecutionWireEvents = {
+    EXECUTION_CREATED: 'execution.created',
+    EXECUTION_UPDATED: 'execution.updated',
+    EXECUTION_DELETED: 'execution.deleted',
+    EXECUTION_ACTIVITY: 'execution.activity',
+    EXECUTION_ACTIVITY_POST: 'execution.activity.post',
+    EXECUTION_HEARTBEAT_POST: 'execution.heartbeat.post',
+};
+/**
+ * Type guards for event identification
+ */
+export function isExecutionCreatedEvent(event) {
+    return 'payload' in event && 'id' in event.payload && 'taskId' in event.payload;
+}
+export function isExecutionDeletedEvent(event) {
+    return 'payload' in event && 'executionId' in event.payload;
+}

package/dist/types/worker-events.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Worker Wire Event Types for WebSocket Communication
+ *
+ * These types define the structure of events sent between backend and workers
+ * via WebSocket for the Workers domain. They serve as a contract between the
+ * backend gateway and worker clients.
+ *
+ * Import these types in both backend (for emission/reception) and worker (for emission/reception)
+ * to ensure type safety across the wire protocol.
+ */
+/**
+ * Wire event names for Workers domain
+ * These are the stable, external event identifiers sent over the wire protocol.
+ */
+export declare const WorkerWireEvents: {
+    readonly WORKER_HELLO: "worker.hello";
+    readonly WORKER_HEARTBEAT: "worker.heartbeat";
+    readonly RUN_STARTED: "run.started";
+    readonly RUN_COMPLETED: "run.completed";
+    readonly RUN_FAILED: "run.failed";
+    readonly RUN_ASSIGNED: "run.assigned";
+    readonly STOP_REQUESTED: "stop.requested";
+};
+export type WorkerWireEventName = (typeof WorkerWireEvents)[keyof typeof WorkerWireEvents];
+/**
+ * Worker hello message payload
+ * Sent by worker on connection to register itself with metadata
+ */
+export interface WorkerHelloPayload {
+    hostname?: string;
+    pid?: number;
+    version?: string;
+    capabilities?: string[];
+}
+/**
+ * Worker heartbeat message payload
+ * Sent periodically by worker to indicate it's still alive
+ */
+export interface WorkerHeartbeatPayload {
+    sessionId: string;
+    timestamp: number;
+}
+/**
+ * Run started message payload
+ * Sent by worker when it begins executing a task
+ */
+export interface RunStartedPayload {
+    executionId: string;
+    sessionId: string;
+    startedAt: string;
+}
+/**
+ * Run completed message payload
+ * Sent by worker when task execution finishes successfully
+ */
+export interface RunCompletedPayload {
+    executionId: string;
+    sessionId: string;
+    completedAt: string;
+}
+/**
+ * Run failed message payload
+ * Sent by worker when task execution fails
+ */
+export interface RunFailedPayload {
+    executionId: string;
+    sessionId: string;
+    failedAt: string;
+    reason?: string;
+}
+/**
+ * Run assigned wire event
+ * Sent by backend to worker when a task execution is assigned
+ */
+export interface RunAssignedWireEvent {
+    executionId: string;
+    taskId: string;
+    agentActorId: string;
+    triggerReason?: string;
+}
+/**
+ * Stop requested wire event
+ * Sent by backend to worker to request stopping a running execution
+ */
+export interface StopRequestedWireEvent {
+    executionId: string;
+    taskId: string;
+    reason?: string;
+}
+/**
+ * Worker hello wire event
+ * Response sent by backend after successful registration
+ */
+export interface WorkerHelloResponse {
+    sessionId: string;
+    serverTime: number;
+}
+/**
+ * Worker heartbeat wire event
+ * Response sent by backend after processing heartbeat
+ */
+export interface WorkerHeartbeatResponse {
+    ok: boolean;
+    serverTime: number;
+}
+/**
+ * Generic acknowledgment for run lifecycle events
+ */
+export interface RunLifecycleAck {
+    ok: boolean;
+    executionId: string;
+}

package/dist/types/worker-events.js

@@ -0,0 +1,25 @@
+/**
+ * Worker Wire Event Types for WebSocket Communication
+ *
+ * These types define the structure of events sent between backend and workers
+ * via WebSocket for the Workers domain. They serve as a contract between the
+ * backend gateway and worker clients.
+ *
+ * Import these types in both backend (for emission/reception) and worker (for emission/reception)
+ * to ensure type safety across the wire protocol.
+ */
+/**
+ * Wire event names for Workers domain
+ * These are the stable, external event identifiers sent over the wire protocol.
+ */
+export const WorkerWireEvents = {
+    // Worker -> Backend
+    WORKER_HELLO: 'worker.hello',
+    WORKER_HEARTBEAT: 'worker.heartbeat',
+    RUN_STARTED: 'run.started',
+    RUN_COMPLETED: 'run.completed',
+    RUN_FAILED: 'run.failed',
+    // Backend -> Worker
+    RUN_ASSIGNED: 'run.assigned',
+    STOP_REQUESTED: 'stop.requested',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taico/events",
-  "version": "0.1.0",
+  "version": "0.2.6",
   "type": "module",
   "private": false,
   "license": "MIT",