@taico/events 0.0.3 → 0.2.0

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/thread-events.d.ts

@@ -20,6 +20,7 @@ export declare const ThreadWireEvents: {
     readonly THREAD_TITLE_UPDATED: "thread.title.updated";
     readonly MESSAGE_CREATED: "thread.message.created";
     readonly AGENT_ACTIVITY: "thread.agent.activity";
+    readonly AGENT_RESPONSE_DELTA: "thread.agent.response.delta";
 };
 export type ThreadWireEventName = (typeof ThreadWireEvents)[keyof typeof ThreadWireEvents];
 /**
@@ -28,7 +29,14 @@ export type ThreadWireEventName = (typeof ThreadWireEvents)[keyof typeof ThreadW
 export interface TaskSummaryWirePayload {
     id: string;
     name: string;
+    description: string;
     status: 'NOT_STARTED' | 'IN_PROGRESS' | 'FOR_REVIEW' | 'DONE';
+    assigneeActor: Actor | null;
+    createdByActor: Actor;
+    tags: TagWirePayload[];
+    commentCount: number;
+    inputRequests: unknown[];
+    updatedAt: string;
 }
 /**
  * Context block summary structure as sent over the wire
@@ -56,16 +64,13 @@ export interface Actor {
 export interface ThreadWirePayload {
     id: string;
     title: string;
-    createdByActorId: string;
+    chatSessionId: string | null;
     createdByActor: Actor;
     parentTaskId: string | null;
-    parentTask: TaskSummaryWirePayload | null;
-    stateBlockId: string;
-    stateBlock: ContextBlockSummaryWirePayload;
+    stateContextBlockId: string;
     tags: TagWirePayload[];
     tasks: TaskSummaryWirePayload[];
-    contextBlocks: ContextBlockSummaryWirePayload[];
-    participantActorIds: string[];
+    referencedContextBlocks: ContextBlockSummaryWirePayload[];
     participants: Actor[];
     rowVersion: number;
     createdAt: string;
@@ -141,7 +146,19 @@ export interface AgentActivityWireEvent {
     };
     actor: MinimalEventActor;
 }
+/**
+ * Agent response delta event
+ * Emitted when assistant streaming text chunks are received.
+ */
+export interface AgentResponseDeltaWireEvent {
+    payload: {
+        threadId: string;
+        streamId: string;
+        delta: string;
+    };
+    actor: MinimalEventActor;
+}
 /**
  * Union type of all thread wire events
  */
-export type ThreadWireEvent = ThreadCreatedWireEvent | ThreadUpdatedWireEvent | ThreadDeletedWireEvent | ThreadTitleUpdatedWireEvent | MessageCreatedWireEvent | AgentActivityWireEvent;
+export type ThreadWireEvent = ThreadCreatedWireEvent | ThreadUpdatedWireEvent | ThreadDeletedWireEvent | ThreadTitleUpdatedWireEvent | MessageCreatedWireEvent | AgentActivityWireEvent | AgentResponseDeltaWireEvent;

package/dist/types/thread-events.js

@@ -19,6 +19,7 @@ export const ThreadWireEvents = {
     THREAD_TITLE_UPDATED: 'thread.title.updated',
     MESSAGE_CREATED: 'thread.message.created',
     AGENT_ACTIVITY: 'thread.agent.activity',
+    AGENT_RESPONSE_DELTA: 'thread.agent.response.delta',
 };
 export var ActorType;
 (function (ActorType) {

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.0.3",
+  "version": "0.2.0",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -26,4 +26,4 @@
   "devDependencies": {
     "typescript": "^5.6.3"
   }
-}
+}