@locusai/shared 0.11.5 → 0.11.7

package/dist/__tests__/protocol-contracts.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=protocol-contracts.test.d.ts.map

package/dist/__tests__/protocol-contracts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-contracts.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/protocol-contracts.test.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -2,4 +2,5 @@ export * from "./common";
 export * from "./constants";
 export * from "./enums";
 export * from "./models";
+export * from "./protocol";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -29,10 +29,23 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
+  parseUIIntent: () => parseUIIntent,
+  parseHostEvent: () => parseHostEvent,
+  parseCliStreamEvent: () => parseCliStreamEvent,
+  isValidTransition: () => isValidTransition,
+  isUIIntentType: () => isUIIntentType,
+  isTerminalStatus: () => isTerminalStatus,
   isJwtUser: () => isJwtUser,
+  isHostEventType: () => isHostEventType,
   isApiKeyUser: () => isApiKeyUser,
+  getNextStatus: () => getNextStatus,
   getAuthUserId: () => getAuthUserId,
   generateUUID: () => generateUUID,
+  createUIIntent: () => createUIIntent,
+  createProtocolError: () => createProtocolError,
+  createHostEvent: () => createHostEvent,
+  createErrorEvent: () => createErrorEvent,
+  createCliStreamEvent: () => createCliStreamEvent,
   WorkspacesResponseSchema: () => WorkspacesResponseSchema,
   WorkspaceStatsSchema: () => WorkspaceStatsSchema,
   WorkspaceStatsResponseSchema: () => WorkspaceStatsResponseSchema,
@@ -40,7 +53,9 @@ __export(exports_src, {
   WorkspaceResponseSchema: () => WorkspaceResponseSchema,
   WorkspaceIdParamSchema: () => WorkspaceIdParamSchema,
   WorkspaceCreatedPayloadSchema: () => WorkspaceCreatedPayloadSchema,
+  WorkspaceContextSchema: () => WorkspaceContextSchema,
   WorkspaceAndUserParamSchema: () => WorkspaceAndUserParamSchema,
+  WebviewReadyIntentSchema: () => WebviewReadyIntentSchema,
   VerifyOtpSchema: () => VerifyOtpSchema,
   UserSchema: () => UserSchema,
   UserRole: () => UserRole,
@@ -52,6 +67,16 @@ __export(exports_src, {
   UpdateDocSchema: () => UpdateDocSchema,
   UpdateDocGroupSchema: () => UpdateDocGroupSchema,
   UnlockSchema: () => UnlockSchema,
+  UIIntentTypeSchema: () => UIIntentTypeSchema,
+  UIIntentType: () => UIIntentType,
+  UIIntentSchema: () => UIIntentSchema,
+  ToolStartedEventSchema: () => ToolStartedEventSchema,
+  ToolCompletedEventSchema: () => ToolCompletedEventSchema,
+  TimelineEntrySchema: () => TimelineEntrySchema,
+  TimelineEntryKindSchema: () => TimelineEntryKindSchema,
+  TimelineEntryKind: () => TimelineEntryKind,
+  ThinkingEventSchema: () => ThinkingEventSchema,
+  TextDeltaEventSchema: () => TextDeltaEventSchema,
   TasksResponseSchema: () => TasksResponseSchema,
   TaskStatus: () => TaskStatus,
   TaskSchema: () => TaskSchema,
@@ -62,7 +87,10 @@ __export(exports_src, {
   TaskIdOnlyParamSchema: () => TaskIdOnlyParamSchema,
   TaskDeletedPayloadSchema: () => TaskDeletedPayloadSchema,
   TaskCreatedPayloadSchema: () => TaskCreatedPayloadSchema,
+  TERMINAL_STATUSES: () => TERMINAL_STATUSES,
   SuccessResponseSchema: () => SuccessResponseSchema,
+  SubmitPromptIntentSchema: () => SubmitPromptIntentSchema,
+  StopSessionIntentSchema: () => StopSessionIntentSchema,
   StatusChangedPayloadSchema: () => StatusChangedPayloadSchema,
   SprintsResponseSchema: () => SprintsResponseSchema,
   SprintStatusChangedPayloadSchema: () => SprintStatusChangedPayloadSchema,
@@ -72,11 +100,31 @@ __export(exports_src, {
   SprintQuerySchema: () => SprintQuerySchema,
   SprintIdParamSchema: () => SprintIdParamSchema,
   SprintCreatedPayloadSchema: () => SprintCreatedPayloadSchema,
+  SessionTransitionEventSchema: () => SessionTransitionEventSchema,
+  SessionTransitionEvent: () => SessionTransitionEvent,
+  SessionSummarySchema: () => SessionSummarySchema,
+  SessionStatusSchema: () => SessionStatusSchema,
+  SessionStatus: () => SessionStatus,
+  SessionStateEventSchema: () => SessionStateEventSchema,
+  SessionMetadataSchema: () => SessionMetadataSchema,
+  SessionListEventSchema: () => SessionListEventSchema,
+  SessionCompletedEventSchema: () => SessionCompletedEventSchema,
+  SelectionContextSchema: () => SelectionContextSchema,
   STALE_AGENT_TIMEOUT_MS: () => STALE_AGENT_TIMEOUT_MS,
+  SESSION_TRANSITIONS: () => SESSION_TRANSITIONS,
+  ResumeSessionIntentSchema: () => ResumeSessionIntentSchema,
+  RequestSessionsIntentSchema: () => RequestSessionsIntentSchema,
+  RequestSessionDetailIntentSchema: () => RequestSessionDetailIntentSchema,
   ReportCiResultSchema: () => ReportCiResultSchema,
   RecordCiSchema: () => RecordCiSchema,
+  ProtocolVersionSchema: () => ProtocolVersionSchema,
+  ProtocolErrorSchema: () => ProtocolErrorSchema,
+  ProtocolErrorCodeSchema: () => ProtocolErrorCodeSchema,
+  ProtocolErrorCode: () => ProtocolErrorCode,
+  ProtocolEnvelopeSchema: () => ProtocolEnvelopeSchema,
   PaginationRequestSchema: () => PaginationRequestSchema,
   PaginationMetaSchema: () => PaginationMetaSchema,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
   OtpRequestSchema: () => OtpRequestSchema,
   OrganizationsResponseSchema: () => OrganizationsResponseSchema,
   OrganizationSchema: () => OrganizationSchema,
@@ -98,6 +146,9 @@ __export(exports_src, {
   InvitationResponseSchema: () => InvitationResponseSchema,
   InvitationQuerySchema: () => InvitationQuerySchema,
   InvitationIdParamSchema: () => InvitationIdParamSchema,
+  HostEventTypeSchema: () => HostEventTypeSchema,
+  HostEventType: () => HostEventType,
+  HostEventSchema: () => HostEventSchema,
   EventsResponseSchema: () => EventsResponseSchema,
   EventType: () => EventType,
   EventSchema: () => EventSchema,
@@ -105,6 +156,7 @@ __export(exports_src, {
   EventQuerySchema: () => EventQuerySchema,
   EventPayloadSchema: () => EventPayloadSchema,
   ErrorResponseSchema: () => ErrorResponseSchema,
+  ErrorEventSchema: () => ErrorEventSchema,
   DocsResponseSchema: () => DocsResponseSchema,
   DocType: () => DocType,
   DocSchema: () => DocSchema,
@@ -127,10 +179,23 @@ __export(exports_src, {
   CreateDocGroupSchema: () => CreateDocGroupSchema,
   CreateArtifactSchema: () => CreateArtifactSchema,
   CreateApiKeySchema: () => CreateApiKeySchema,
+  ContextPayloadSchema: () => ContextPayloadSchema,
   CompleteRegistrationSchema: () => CompleteRegistrationSchema,
   CommentSchema: () => CommentSchema,
   CommentResponseSchema: () => CommentResponseSchema,
   CommentAddedPayloadSchema: () => CommentAddedPayloadSchema,
+  CliToolStartedEventSchema: () => CliToolStartedEventSchema,
+  CliToolCompletedEventSchema: () => CliToolCompletedEventSchema,
+  CliThinkingEventSchema: () => CliThinkingEventSchema,
+  CliTextDeltaEventSchema: () => CliTextDeltaEventSchema,
+  CliStreamEventTypeSchema: () => CliStreamEventTypeSchema,
+  CliStreamEventType: () => CliStreamEventType,
+  CliStreamEventSchema: () => CliStreamEventSchema,
+  CliStatusEventSchema: () => CliStatusEventSchema,
+  CliStartEventSchema: () => CliStartEventSchema,
+  CliErrorEventSchema: () => CliErrorEventSchema,
+  CliDoneEventSchema: () => CliDoneEventSchema,
+  ClearSessionIntentSchema: () => ClearSessionIntentSchema,
   CiRanPayloadSchema: () => CiRanPayloadSchema,
   ChecklistItemSchema: () => ChecklistItemSchema,
   ChecklistInitializedPayloadSchema: () => ChecklistInitializedPayloadSchema,
@@ -154,6 +219,7 @@ __export(exports_src, {
   AddMemberSchema: () => AddMemberSchema,
   AddCommentSchema: () => AddCommentSchema,
   ActivityResponseSchema: () => ActivityResponseSchema,
+  ActiveFileContextSchema: () => ActiveFileContextSchema,
   AcceptanceItemSchema: () => AcceptanceItemSchema,
   AcceptInvitationSchema: () => AcceptInvitationSchema,
   AcceptInvitationResponseSchema: () => AcceptInvitationResponseSchema,
@@ -932,3 +998,538 @@ var WorkspaceStatsSchema = import_zod13.z.object({
 var WorkspaceStatsResponseSchema = import_zod13.z.object({
   stats: WorkspaceStatsSchema
 });
+// src/protocol/cli-stream.ts
+var import_zod16 = require("zod");
+
+// src/protocol/envelope.ts
+var import_zod14 = require("zod");
+var PROTOCOL_VERSION = 1;
+var ProtocolVersionSchema = import_zod14.z.literal(PROTOCOL_VERSION);
+var ProtocolEnvelopeSchema = import_zod14.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod14.z.string()
+});
+
+// src/protocol/errors.ts
+var import_zod15 = require("zod");
+var ProtocolErrorCode = {
+  CLI_NOT_FOUND: "CLI_NOT_FOUND",
+  AUTH_EXPIRED: "AUTH_EXPIRED",
+  NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
+  CONTEXT_LIMIT: "CONTEXT_LIMIT",
+  MALFORMED_EVENT: "MALFORMED_EVENT",
+  PROCESS_CRASHED: "PROCESS_CRASHED",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  UNKNOWN: "UNKNOWN"
+};
+var ProtocolErrorCodeSchema = import_zod15.z.enum(ProtocolErrorCode);
+var ProtocolErrorSchema = import_zod15.z.object({
+  code: ProtocolErrorCodeSchema,
+  message: import_zod15.z.string(),
+  details: import_zod15.z.unknown().optional(),
+  recoverable: import_zod15.z.boolean()
+});
+
+// src/protocol/cli-stream.ts
+var CliStreamEventType = {
+  START: "start",
+  TEXT_DELTA: "text_delta",
+  THINKING: "thinking",
+  TOOL_STARTED: "tool_started",
+  TOOL_COMPLETED: "tool_completed",
+  STATUS: "status",
+  ERROR: "error",
+  DONE: "done"
+};
+var CliStreamEventTypeSchema = import_zod16.z.enum(CliStreamEventType);
+var CliStreamBaseSchema = import_zod16.z.object({
+  protocol: ProtocolVersionSchema,
+  sessionId: import_zod16.z.string(),
+  timestamp: import_zod16.z.number()
+});
+var CliStartEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.START),
+  payload: import_zod16.z.object({
+    command: import_zod16.z.string(),
+    model: import_zod16.z.string().optional(),
+    provider: import_zod16.z.string().optional(),
+    cwd: import_zod16.z.string().optional()
+  })
+});
+var CliTextDeltaEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.TEXT_DELTA),
+  payload: import_zod16.z.object({
+    content: import_zod16.z.string()
+  })
+});
+var CliThinkingEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.THINKING),
+  payload: import_zod16.z.object({
+    content: import_zod16.z.string().optional()
+  })
+});
+var CliToolStartedEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.TOOL_STARTED),
+  payload: import_zod16.z.object({
+    tool: import_zod16.z.string(),
+    toolId: import_zod16.z.string().optional(),
+    parameters: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional()
+  })
+});
+var CliToolCompletedEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.TOOL_COMPLETED),
+  payload: import_zod16.z.object({
+    tool: import_zod16.z.string(),
+    toolId: import_zod16.z.string().optional(),
+    success: import_zod16.z.boolean(),
+    duration: import_zod16.z.number().optional(),
+    error: import_zod16.z.string().optional()
+  })
+});
+var CliStatusEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.STATUS),
+  payload: import_zod16.z.object({
+    status: import_zod16.z.string(),
+    message: import_zod16.z.string().optional()
+  })
+});
+var CliErrorEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.ERROR),
+  payload: import_zod16.z.object({
+    error: ProtocolErrorSchema
+  })
+});
+var CliDoneEventSchema = CliStreamBaseSchema.extend({
+  type: import_zod16.z.literal(CliStreamEventType.DONE),
+  payload: import_zod16.z.object({
+    exitCode: import_zod16.z.number().int(),
+    duration: import_zod16.z.number(),
+    toolsUsed: import_zod16.z.array(import_zod16.z.string()).optional(),
+    tokensUsed: import_zod16.z.number().optional(),
+    success: import_zod16.z.boolean()
+  })
+});
+var CliStreamEventSchema = import_zod16.z.discriminatedUnion("type", [
+  CliStartEventSchema,
+  CliTextDeltaEventSchema,
+  CliThinkingEventSchema,
+  CliToolStartedEventSchema,
+  CliToolCompletedEventSchema,
+  CliStatusEventSchema,
+  CliErrorEventSchema,
+  CliDoneEventSchema
+]);
+function createCliStreamEvent(type, sessionId, payload) {
+  return CliStreamEventSchema.parse({
+    protocol: PROTOCOL_VERSION,
+    type,
+    sessionId,
+    timestamp: Date.now(),
+    payload
+  });
+}
+function parseCliStreamEvent(value) {
+  const result = CliStreamEventSchema.safeParse(value);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+// src/protocol/context.ts
+var import_zod17 = require("zod");
+var ActiveFileContextSchema = import_zod17.z.object({
+  filePath: import_zod17.z.string(),
+  languageId: import_zod17.z.string().optional()
+});
+var SelectionContextSchema = import_zod17.z.object({
+  filePath: import_zod17.z.string(),
+  languageId: import_zod17.z.string().optional(),
+  startLine: import_zod17.z.number().int().min(0),
+  startColumn: import_zod17.z.number().int().min(0),
+  endLine: import_zod17.z.number().int().min(0),
+  endColumn: import_zod17.z.number().int().min(0),
+  text: import_zod17.z.string()
+});
+var WorkspaceContextSchema = import_zod17.z.object({
+  rootPath: import_zod17.z.string(),
+  name: import_zod17.z.string().optional()
+});
+var ContextPayloadSchema = import_zod17.z.object({
+  workspace: WorkspaceContextSchema.optional(),
+  activeFile: ActiveFileContextSchema.optional(),
+  selection: SelectionContextSchema.optional()
+});
+// src/protocol/host-events.ts
+var import_zod19 = require("zod");
+
+// src/protocol/session.ts
+var import_zod18 = require("zod");
+var SessionStatus = {
+  IDLE: "idle",
+  STARTING: "starting",
+  RUNNING: "running",
+  STREAMING: "streaming",
+  COMPLETED: "completed",
+  CANCELED: "canceled",
+  INTERRUPTED: "interrupted",
+  FAILED: "failed",
+  RESUMING: "resuming"
+};
+var SessionStatusSchema = import_zod18.z.enum(SessionStatus);
+var SessionTransitionEvent = {
+  CREATE_SESSION: "create_session",
+  CLI_SPAWNED: "cli_spawned",
+  FIRST_TEXT_DELTA: "first_text_delta",
+  RESULT_RECEIVED: "result_received",
+  USER_STOP: "user_stop",
+  PROCESS_LOST: "process_lost",
+  RESUME: "resume",
+  ERROR: "error"
+};
+var SessionTransitionEventSchema = import_zod18.z.enum(SessionTransitionEvent);
+var SESSION_TRANSITIONS = [
+  {
+    from: SessionStatus.IDLE,
+    event: SessionTransitionEvent.CREATE_SESSION,
+    to: SessionStatus.STARTING
+  },
+  {
+    from: SessionStatus.STARTING,
+    event: SessionTransitionEvent.CLI_SPAWNED,
+    to: SessionStatus.RUNNING
+  },
+  {
+    from: SessionStatus.STARTING,
+    event: SessionTransitionEvent.ERROR,
+    to: SessionStatus.FAILED
+  },
+  {
+    from: SessionStatus.RUNNING,
+    event: SessionTransitionEvent.FIRST_TEXT_DELTA,
+    to: SessionStatus.STREAMING
+  },
+  {
+    from: SessionStatus.RUNNING,
+    event: SessionTransitionEvent.USER_STOP,
+    to: SessionStatus.CANCELED
+  },
+  {
+    from: SessionStatus.RUNNING,
+    event: SessionTransitionEvent.PROCESS_LOST,
+    to: SessionStatus.INTERRUPTED
+  },
+  {
+    from: SessionStatus.RUNNING,
+    event: SessionTransitionEvent.ERROR,
+    to: SessionStatus.FAILED
+  },
+  {
+    from: SessionStatus.STREAMING,
+    event: SessionTransitionEvent.RESULT_RECEIVED,
+    to: SessionStatus.COMPLETED
+  },
+  {
+    from: SessionStatus.STREAMING,
+    event: SessionTransitionEvent.USER_STOP,
+    to: SessionStatus.CANCELED
+  },
+  {
+    from: SessionStatus.STREAMING,
+    event: SessionTransitionEvent.PROCESS_LOST,
+    to: SessionStatus.INTERRUPTED
+  },
+  {
+    from: SessionStatus.STREAMING,
+    event: SessionTransitionEvent.ERROR,
+    to: SessionStatus.FAILED
+  },
+  {
+    from: SessionStatus.INTERRUPTED,
+    event: SessionTransitionEvent.RESUME,
+    to: SessionStatus.RESUMING
+  },
+  {
+    from: SessionStatus.RESUMING,
+    event: SessionTransitionEvent.CLI_SPAWNED,
+    to: SessionStatus.RUNNING
+  },
+  {
+    from: SessionStatus.RESUMING,
+    event: SessionTransitionEvent.ERROR,
+    to: SessionStatus.FAILED
+  },
+  {
+    from: SessionStatus.COMPLETED,
+    event: SessionTransitionEvent.CREATE_SESSION,
+    to: SessionStatus.STARTING
+  },
+  {
+    from: SessionStatus.CANCELED,
+    event: SessionTransitionEvent.CREATE_SESSION,
+    to: SessionStatus.STARTING
+  },
+  {
+    from: SessionStatus.FAILED,
+    event: SessionTransitionEvent.CREATE_SESSION,
+    to: SessionStatus.STARTING
+  }
+];
+var TERMINAL_STATUSES = new Set([
+  SessionStatus.COMPLETED,
+  SessionStatus.CANCELED,
+  SessionStatus.FAILED
+]);
+var SessionMetadataSchema = import_zod18.z.object({
+  sessionId: import_zod18.z.string(),
+  status: SessionStatusSchema,
+  model: import_zod18.z.string().optional(),
+  createdAt: import_zod18.z.number(),
+  updatedAt: import_zod18.z.number(),
+  title: import_zod18.z.string().optional()
+});
+var SessionSummarySchema = import_zod18.z.object({
+  sessionId: import_zod18.z.string(),
+  status: SessionStatusSchema,
+  model: import_zod18.z.string().optional(),
+  title: import_zod18.z.string().optional(),
+  createdAt: import_zod18.z.number(),
+  updatedAt: import_zod18.z.number(),
+  messageCount: import_zod18.z.number(),
+  toolCount: import_zod18.z.number()
+});
+
+// src/protocol/host-events.ts
+var HostEventType = {
+  SESSION_STATE: "session_state",
+  TEXT_DELTA: "text_delta",
+  TOOL_STARTED: "tool_started",
+  TOOL_COMPLETED: "tool_completed",
+  THINKING: "thinking",
+  ERROR: "error",
+  SESSION_LIST: "session_list",
+  SESSION_COMPLETED: "session_completed"
+};
+var HostEventTypeSchema = import_zod19.z.enum(HostEventType);
+var TimelineEntryKind = {
+  MESSAGE: "message",
+  TOOL_CALL: "tool_call",
+  STATUS: "status",
+  ERROR: "error",
+  DONE: "done"
+};
+var TimelineEntryKindSchema = import_zod19.z.enum(TimelineEntryKind);
+var TimelineEntrySchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  kind: TimelineEntryKindSchema,
+  timestamp: import_zod19.z.number(),
+  data: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown())
+});
+var SessionStateEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.SESSION_STATE),
+  payload: import_zod19.z.object({
+    sessionId: import_zod19.z.string(),
+    status: SessionStatusSchema,
+    metadata: SessionMetadataSchema.optional(),
+    timeline: import_zod19.z.array(TimelineEntrySchema).optional()
+  })
+});
+var TextDeltaEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.TEXT_DELTA),
+  payload: import_zod19.z.object({
+    sessionId: import_zod19.z.string(),
+    content: import_zod19.z.string()
+  })
+});
+var ToolStartedEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.TOOL_STARTED),
+  payload: import_zod19.z.object({
+    sessionId: import_zod19.z.string(),
+    tool: import_zod19.z.string(),
+    toolId: import_zod19.z.string().optional(),
+    parameters: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()).optional()
+  })
+});
+var ToolCompletedEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.TOOL_COMPLETED),
+  payload: import_zod19.z.object({
+    sessionId: import_zod19.z.string(),
+    tool: import_zod19.z.string(),
+    toolId: import_zod19.z.string().optional(),
+    result: import_zod19.z.unknown().optional(),
+    duration: import_zod19.z.number().optional(),
+    success: import_zod19.z.boolean(),
+    error: import_zod19.z.string().optional()
+  })
+});
+var ThinkingEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.THINKING),
+  payload: import_zod19.z.object({
+    sessionId: import_zod19.z.string(),
+    content: import_zod19.z.string().optional()
+  })
+});
+var ErrorEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.ERROR),
+  payload: import_zod19.z.object({
+    sessionId: import_zod19.z.string().optional(),
+    error: ProtocolErrorSchema
+  })
+});
+var SessionListEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.SESSION_LIST),
+  payload: import_zod19.z.object({
+    sessions: import_zod19.z.array(SessionSummarySchema)
+  })
+});
+var SessionCompletedEventSchema = import_zod19.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod19.z.literal(HostEventType.SESSION_COMPLETED),
+  payload: import_zod19.z.object({
+    sessionId: import_zod19.z.string(),
+    summary: import_zod19.z.string().optional()
+  })
+});
+var HostEventSchema = import_zod19.z.discriminatedUnion("type", [
+  SessionStateEventSchema,
+  TextDeltaEventSchema,
+  ToolStartedEventSchema,
+  ToolCompletedEventSchema,
+  ThinkingEventSchema,
+  ErrorEventSchema,
+  SessionListEventSchema,
+  SessionCompletedEventSchema
+]);
+function createHostEvent(type, payload) {
+  return HostEventSchema.parse({
+    protocol: PROTOCOL_VERSION,
+    type,
+    payload
+  });
+}
+
+// src/protocol/ui-intents.ts
+var import_zod20 = require("zod");
+var UIIntentType = {
+  SUBMIT_PROMPT: "submit_prompt",
+  STOP_SESSION: "stop_session",
+  RESUME_SESSION: "resume_session",
+  REQUEST_SESSIONS: "request_sessions",
+  REQUEST_SESSION_DETAIL: "request_session_detail",
+  CLEAR_SESSION: "clear_session",
+  WEBVIEW_READY: "webview_ready"
+};
+var UIIntentTypeSchema = import_zod20.z.enum(UIIntentType);
+var SubmitPromptIntentSchema = import_zod20.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod20.z.literal(UIIntentType.SUBMIT_PROMPT),
+  payload: import_zod20.z.object({
+    text: import_zod20.z.string().min(1),
+    context: ContextPayloadSchema.optional()
+  })
+});
+var StopSessionIntentSchema = import_zod20.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod20.z.literal(UIIntentType.STOP_SESSION),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string()
+  })
+});
+var ResumeSessionIntentSchema = import_zod20.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod20.z.literal(UIIntentType.RESUME_SESSION),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string()
+  })
+});
+var RequestSessionsIntentSchema = import_zod20.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod20.z.literal(UIIntentType.REQUEST_SESSIONS),
+  payload: import_zod20.z.object({}).optional()
+});
+var RequestSessionDetailIntentSchema = import_zod20.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod20.z.literal(UIIntentType.REQUEST_SESSION_DETAIL),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string()
+  })
+});
+var ClearSessionIntentSchema = import_zod20.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod20.z.literal(UIIntentType.CLEAR_SESSION),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string()
+  })
+});
+var WebviewReadyIntentSchema = import_zod20.z.object({
+  protocol: ProtocolVersionSchema,
+  type: import_zod20.z.literal(UIIntentType.WEBVIEW_READY),
+  payload: import_zod20.z.object({}).optional()
+});
+var UIIntentSchema = import_zod20.z.discriminatedUnion("type", [
+  SubmitPromptIntentSchema,
+  StopSessionIntentSchema,
+  ResumeSessionIntentSchema,
+  RequestSessionsIntentSchema,
+  RequestSessionDetailIntentSchema,
+  ClearSessionIntentSchema,
+  WebviewReadyIntentSchema
+]);
+function createUIIntent(type, payload) {
+  return UIIntentSchema.parse({
+    protocol: PROTOCOL_VERSION,
+    type,
+    payload
+  });
+}
+
+// src/protocol/helpers.ts
+function parseUIIntent(message) {
+  return UIIntentSchema.safeParse(message);
+}
+function parseHostEvent(message) {
+  return HostEventSchema.safeParse(message);
+}
+function isUIIntentType(intent, type) {
+  return intent.type === type;
+}
+function isHostEventType(event, type) {
+  return event.type === type;
+}
+function isValidTransition(from, event) {
+  return SESSION_TRANSITIONS.some((t) => t.from === from && t.event === event);
+}
+function getNextStatus(from, event) {
+  const transition = SESSION_TRANSITIONS.find((t) => t.from === from && t.event === event);
+  return transition?.to ?? null;
+}
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+function createProtocolError(code, message, options) {
+  return {
+    code,
+    message,
+    details: options?.details,
+    recoverable: options?.recoverable ?? false
+  };
+}
+function createErrorEvent(code, message, options) {
+  return {
+    protocol: PROTOCOL_VERSION,
+    type: HostEventType.ERROR,
+    payload: {
+      sessionId: options?.sessionId,
+      error: createProtocolError(code, message, {
+        details: options?.details,
+        recoverable: options?.recoverable
+      })
+    }
+  };
+}