@hexabot-ai/types 3.0.0-alpha.0

package/src/user/user-profile.ts

@@ -0,0 +1,21 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { userProfileBaseSchema } from "../shared/profile";
+
+export const userProfileStubSchema = userProfileBaseSchema;
+
+export const userProfileSchema = userProfileBaseSchema;
+
+export const userProfileFullSchema = userProfileBaseSchema;
+
+export type UserProfileStub = z.infer<typeof userProfileStubSchema>;
+
+export type UserProfile = z.infer<typeof userProfileSchema>;
+
+export type UserProfileFull = z.infer<typeof userProfileFullSchema>;

package/src/user/user.ts

@@ -0,0 +1,87 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { attachmentSchema } from "../attachment/attachment";
+import { labelSchema } from "../chat/label";
+import { asId, asIdArray, withAliases } from "../shared/aliases";
+import { preprocess } from "../shared/preprocess";
+import { subscriberBaseSchema } from "../shared/profile";
+
+import { roleSchema } from "./role";
+import {
+  userProfileAssignedSchema,
+  userProviderSchema,
+} from "./user-profile-assigned";
+
+const userAliasMap = {
+  labelIds: "labels",
+  assignedToId: "assignedTo",
+  roleIds: "roles",
+  avatarId: "avatar",
+} as const;
+const userStubObjectSchema = subscriberBaseSchema.extend({
+  username: z.string(),
+  email: z.string(),
+  sendEmail: z.coerce.boolean(),
+  state: z.coerce.boolean(),
+  resetCount: z.coerce.number(),
+  resetToken: preprocess(
+    (value) => (value == null ? null : value),
+    z.string().nullable(),
+  ),
+  provider: userProviderSchema.optional(),
+});
+
+export const userStubSchema = userStubObjectSchema;
+
+export const userSchema = preprocess(
+  (value) => withAliases(value, userAliasMap),
+  userStubObjectSchema.extend({
+    labels: preprocess(
+      (value) => (Array.isArray(value) ? asIdArray(value) : []),
+      z.array(z.string()),
+    ),
+    assignedTo: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
+    roles: preprocess(
+      (value) => (Array.isArray(value) ? asIdArray(value) : []),
+      z.array(z.string()),
+    ),
+    avatar: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
+  }),
+);
+
+export const userFullSchema = userStubObjectSchema.extend({
+  labels: preprocess(
+    (value) => (Array.isArray(value) ? value : []),
+    z.array(z.lazy(() => labelSchema)),
+  ),
+  assignedTo: preprocess(
+    (value) => (value == null ? null : value),
+    userProfileAssignedSchema.nullable(),
+  ),
+  roles: preprocess(
+    (value) => (Array.isArray(value) ? value : []),
+    z.array(z.lazy(() => roleSchema)),
+  ),
+  avatar: preprocess(
+    (value) => (value == null ? null : value),
+    attachmentSchema.nullable(),
+  ),
+});
+
+export type UserStub = z.infer<typeof userStubSchema>;
+
+export type User = z.infer<typeof userSchema>;
+
+export type UserFull = z.infer<typeof userFullSchema>;

package/src/workflow/domain.ts

@@ -0,0 +1,47 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+export enum WorkflowType {
+  conversational = "conversational",
+  manual = "manual",
+  scheduled = "scheduled",
+}
+
+export enum WorkflowVersionAction {
+  create = "create",
+  update = "update",
+  restore = "restore",
+  import = "import",
+}
+
+export enum MemoryScope {
+  global = "global",
+  workflow = "workflow",
+  thread = "thread",
+  run = "run",
+}
+
+export enum McpServerTransport {
+  http = "http",
+  stdio = "stdio",
+}
+
+export enum DirectionType {
+  HORIZONTAL = "horizontal",
+  VERTICAL = "vertical",
+}
+
+export const workflowTypeSchema = z.enum(WorkflowType);
+
+export const workflowVersionActionSchema = z.enum(WorkflowVersionAction);
+
+export const memoryScopeSchema = z.enum(MemoryScope);
+
+export const mcpServerTransportSchema = z.enum(McpServerTransport);
+
+export const directionTypeSchema = z.enum(DirectionType);

package/src/workflow/helpers.ts

@@ -0,0 +1,40 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { subscriberSchema } from "../chat/subscriber";
+import { toRecord } from "../shared/object";
+import { userSchema } from "../user/user";
+
+export const nullishToNull = (value: unknown): unknown => {
+  return value == null ? null : value;
+};
+
+export const userOrSubscriberSchema = z.union([
+  z.lazy(() => userSchema),
+  subscriberSchema,
+]);
+
+export const parseUserOrSubscriber = (
+  value: unknown,
+): z.infer<typeof userOrSubscriberSchema> => {
+  const record = toRecord(value);
+
+  if (record?.type === "UserOrmEntity") {
+    return userSchema.parse(value);
+  }
+  if (record?.type === "SubscriberOrmEntity") {
+    return subscriberSchema.parse(value);
+  }
+
+  const parsedUser = userSchema.safeParse(value);
+  if (parsedUser.success) {
+    return parsedUser.data;
+  }
+
+  return subscriberSchema.parse(value);
+};

package/src/workflow/index.ts

@@ -0,0 +1,70 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+export {
+  DirectionType,
+  McpServerTransport,
+  MemoryScope,
+  WorkflowType,
+  WorkflowVersionAction,
+} from "./domain";
+
+export {
+  createWorkflowFullSchema,
+  workflowFullSchema,
+  workflowSchema,
+  workflowStubSchema,
+  type Workflow,
+  type WorkflowDefinitionParser,
+  type WorkflowFull,
+  type WorkflowStub,
+} from "./workflow";
+
+export {
+  workflowVersionFullSchema,
+  workflowVersionSchema,
+  workflowVersionStubSchema,
+  type WorkflowVersion,
+  type WorkflowVersionFull,
+  type WorkflowVersionStub,
+} from "./workflow-version";
+
+export {
+  resolveRunDurationMs,
+  workflowRunFullSchema,
+  workflowRunSchema,
+  workflowRunStubSchema,
+  type WorkflowRun,
+  type WorkflowRunFull,
+  type WorkflowRunStub,
+} from "./workflow-run";
+
+export {
+  memoryDefinitionFullSchema,
+  memoryDefinitionSchema,
+  memoryDefinitionStubSchema,
+  type MemoryDefinition,
+  type MemoryDefinitionFull,
+  type MemoryDefinitionStub,
+} from "./memory-definition";
+
+export {
+  memoryRecordFullSchema,
+  memoryRecordSchema,
+  memoryRecordStubSchema,
+  type MemoryRecord,
+  type MemoryRecordFull,
+  type MemoryRecordStub,
+} from "./memory-record";
+
+export {
+  mcpServerFullSchema,
+  mcpServerSchema,
+  mcpServerStubSchema,
+  type McpServer,
+  type McpServerFull,
+  type McpServerStub,
+} from "./mcp-server";

package/src/workflow/mcp-server.ts

@@ -0,0 +1,64 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { credentialSchema } from "../user/credential";
+
+import { mcpServerTransportSchema } from "./domain";
+
+const mcpServerAliasMap = {
+  credentialId: "credential",
+} as const;
+const mcpServerStubObjectSchema = baseStubSchema.extend({
+  name: z.string(),
+  enabled: z.coerce.boolean(),
+  transport: mcpServerTransportSchema,
+  url: preprocess(
+    (value) => (value == null ? null : value),
+    z.string().nullable(),
+  ),
+  command: preprocess(
+    (value) => (value == null ? null : value),
+    z.string().nullable(),
+  ),
+  args: preprocess(
+    (value) => (value == null ? null : value),
+    z.array(z.string()).nullable(),
+  ),
+  cwd: preprocess(
+    (value) => (value == null ? null : value),
+    z.string().nullable(),
+  ),
+});
+
+export const mcpServerStubSchema = mcpServerStubObjectSchema;
+
+export const mcpServerSchema = preprocess(
+  (value) => withAliases(value, mcpServerAliasMap),
+  mcpServerStubObjectSchema.extend({
+    credential: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
+  }),
+);
+
+export const mcpServerFullSchema = mcpServerStubObjectSchema.extend({
+  credential: preprocess(
+    (value) => (value == null ? null : credentialSchema.parse(value)),
+    credentialSchema.nullable(),
+  ).optional(),
+});
+
+export type McpServerStub = z.infer<typeof mcpServerStubSchema>;
+
+export type McpServer = z.infer<typeof mcpServerSchema>;
+
+export type McpServerFull = z.infer<typeof mcpServerFullSchema>;

package/src/workflow/memory-definition.ts

@@ -0,0 +1,31 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { baseStubSchema } from "../shared/base";
+
+import { memoryScopeSchema } from "./domain";
+
+const memoryDefinitionObjectSchema = baseStubSchema.extend({
+  name: z.string(),
+  slug: z.string(),
+  scope: memoryScopeSchema,
+  schema: z.any(),
+  ttlSeconds: z.coerce.number().nullable().optional(),
+});
+
+export const memoryDefinitionStubSchema = memoryDefinitionObjectSchema;
+
+export const memoryDefinitionSchema = memoryDefinitionObjectSchema;
+
+export const memoryDefinitionFullSchema = memoryDefinitionObjectSchema;
+
+export type MemoryDefinitionStub = z.infer<typeof memoryDefinitionStubSchema>;
+
+export type MemoryDefinition = z.infer<typeof memoryDefinitionSchema>;
+
+export type MemoryDefinitionFull = z.infer<typeof memoryDefinitionFullSchema>;

package/src/workflow/memory-record.ts

@@ -0,0 +1,71 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { threadSchema } from "../chat/thread";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+
+import { parseUserOrSubscriber, userOrSubscriberSchema } from "./helpers";
+import { memoryDefinitionSchema } from "./memory-definition";
+import { workflowSchema } from "./workflow";
+import { workflowRunSchema } from "./workflow-run";
+const memoryRecordAliasMap = {
+  definitionId: "definition",
+  ownerId: "owner",
+  workflowId: "workflow",
+  runId: "run",
+  threadId: "thread",
+} as const;
+const memoryRecordStubObjectSchema = baseStubSchema.extend({
+  value: z.record(z.string(), z.unknown()),
+  ttlSeconds: z.coerce.number().nullable().optional(),
+  expiresAt: z.coerce.date().nullable().optional(),
+});
+
+export const memoryRecordStubSchema = memoryRecordStubObjectSchema;
+
+export const memoryRecordSchema = preprocess(
+  (value) => withAliases(value, memoryRecordAliasMap),
+  memoryRecordStubObjectSchema.extend({
+    definition: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+    owner: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+    workflow: preprocess(
+      (value) => (value == null ? undefined : asId(value)),
+      z.string().optional(),
+    ).optional(),
+    run: preprocess(
+      (value) => (value == null ? undefined : asId(value)),
+      z.string().optional(),
+    ).optional(),
+    thread: preprocess(
+      (value) => (value == null ? undefined : asId(value)),
+      z.string().optional(),
+    ).optional(),
+  }),
+);
+
+export const memoryRecordFullSchema = memoryRecordStubObjectSchema.extend({
+  definition: memoryDefinitionSchema,
+  owner: preprocess(parseUserOrSubscriber, userOrSubscriberSchema),
+  workflow: workflowSchema.nullable().optional(),
+  run: workflowRunSchema.nullable().optional(),
+  thread: threadSchema.nullable().optional(),
+});
+
+export type MemoryRecordStub = z.infer<typeof memoryRecordStubSchema>;
+
+export type MemoryRecord = z.infer<typeof memoryRecordSchema>;
+
+export type MemoryRecordFull = z.infer<typeof memoryRecordFullSchema>;

package/src/workflow/workflow-run.ts

@@ -0,0 +1,156 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { threadSchema } from "../chat/thread";
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { cloneWithPrototype, toRecord } from "../shared/object";
+import { preprocess } from "../shared/preprocess";
+
+import {
+  nullishToNull,
+  parseUserOrSubscriber,
+  userOrSubscriberSchema,
+} from "./helpers";
+import { workflowSchema } from "./workflow";
+import { workflowVersionSchema } from "./workflow-version";
+
+const workflowRunStatusSchema = z.enum([
+  "idle",
+  "running",
+  "suspended",
+  "finished",
+  "failed",
+]);
+const resolveTimestampMs = (value?: Date | string | null): number | null => {
+  if (!value) {
+    return null;
+  }
+
+  const date = value instanceof Date ? value : new Date(value);
+  const timestamp = date.getTime();
+
+  return Number.isNaN(timestamp) ? null : timestamp;
+};
+
+export const resolveRunDurationMs = (run: {
+  createdAt?: Date | string | null;
+  finishedAt?: Date | string | null;
+  failedAt?: Date | string | null;
+  suspendedAt?: Date | string | null;
+  status?: z.infer<typeof workflowRunStatusSchema> | null;
+}): number | null => {
+  const createdAtMs = resolveTimestampMs(run.createdAt);
+  if (createdAtMs == null) {
+    return null;
+  }
+
+  const endAtMs =
+    resolveTimestampMs(run.finishedAt) ??
+    resolveTimestampMs(run.failedAt) ??
+    resolveTimestampMs(run.suspendedAt) ??
+    (run.status === "running" ? Date.now() : null);
+
+  if (endAtMs == null) {
+    return null;
+  }
+
+  return Math.max(0, endAtMs - createdAtMs);
+};
+
+const workflowRunAliasMap = {
+  workflowId: "workflow",
+  workflowVersionId: "workflowVersion",
+  triggeredById: "triggeredBy",
+  threadId: "thread",
+} as const;
+const workflowRunStubObjectSchema = baseStubSchema.extend({
+  status: workflowRunStatusSchema,
+  input: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+  output: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+  context: preprocess(
+    (value) => (value == null ? {} : value),
+    z.record(z.string(), z.any()),
+  ),
+  snapshot: preprocess(nullishToNull, z.any().nullable()),
+  stepLog: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+  suspendedStep: preprocess(nullishToNull, z.string().nullable()),
+  suspensionReason: preprocess(nullishToNull, z.string().nullable()),
+  suspensionData: preprocess(nullishToNull, z.unknown().nullable()),
+  suspensionStepExecId: preprocess(nullishToNull, z.string().nullable()),
+  suspensionIndex: preprocess(nullishToNull, z.coerce.number().nullable()),
+  suspensionKey: preprocess(nullishToNull, z.string().nullable()),
+  suspensionAwaitResults: preprocess(
+    nullishToNull,
+    z.record(z.string(), z.any()).nullable(),
+  ),
+  lastResumeData: preprocess(nullishToNull, z.unknown().nullable()),
+  error: preprocess(nullishToNull, z.string().nullable()),
+  suspendedAt: preprocess(nullishToNull, z.coerce.date().nullable()),
+  finishedAt: preprocess(nullishToNull, z.coerce.date().nullable()),
+  failedAt: preprocess(nullishToNull, z.coerce.date().nullable()),
+  duration: preprocess(nullishToNull, z.coerce.number().nullable()),
+  metadata: preprocess(nullishToNull, z.record(z.string(), z.any()).nullable()),
+});
+const withWorkflowRunDuration = (value: unknown): unknown => {
+  const record = toRecord(value);
+  if (!record) {
+    return value;
+  }
+
+  const next = cloneWithPrototype(record);
+  next.duration = resolveRunDurationMs(next as never);
+
+  return next;
+};
+const nullableUserOrSubscriberSchema = preprocess(
+  (value) => (value == null ? null : parseUserOrSubscriber(value)),
+  userOrSubscriberSchema.nullable(),
+);
+
+export const workflowRunStubSchema = preprocess(
+  withWorkflowRunDuration,
+  workflowRunStubObjectSchema,
+);
+
+export const workflowRunSchema = preprocess(
+  (value) => withAliases(withWorkflowRunDuration(value), workflowRunAliasMap),
+  workflowRunStubObjectSchema.extend({
+    workflow: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+    workflowVersion: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
+    triggeredBy: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
+  }),
+);
+
+export const workflowRunFullSchema = preprocess(
+  (value) => withWorkflowRunDuration(value),
+  workflowRunStubObjectSchema.extend({
+    workflow: workflowSchema,
+    workflowVersion: z
+      .lazy(() => workflowVersionSchema)
+      .nullable()
+      .optional(),
+    triggeredBy: nullableUserOrSubscriberSchema,
+    thread: threadSchema.nullable().optional(),
+  }),
+);
+
+export type WorkflowRunStub = z.infer<typeof workflowRunStubSchema>;
+
+export type WorkflowRun = z.infer<typeof workflowRunSchema>;
+
+export type WorkflowRunFull = z.infer<typeof workflowRunFullSchema>;

package/src/workflow/workflow-version.ts

@@ -0,0 +1,68 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { z } from "zod";
+
+import { asId, withAliases } from "../shared/aliases";
+import { baseStubSchema } from "../shared/base";
+import { preprocess } from "../shared/preprocess";
+import { userSchema } from "../user/user";
+
+import { workflowVersionActionSchema } from "./domain";
+import { nullishToNull } from "./helpers";
+import { workflowSchema } from "./workflow";
+const workflowVersionAliasMap = {
+  parentVersionId: "parentVersion",
+  workflowId: "workflow",
+  createdById: "createdBy",
+} as const;
+const workflowVersionStubObjectSchema = baseStubSchema.extend({
+  version: z.coerce.number(),
+  definitionYml: z.string(),
+  checksum: z.string(),
+  message: preprocess(nullishToNull, z.string().nullable()),
+  action: preprocess(nullishToNull, workflowVersionActionSchema.nullable()),
+});
+
+export const workflowVersionStubSchema = workflowVersionStubObjectSchema;
+
+export const workflowVersionSchema = preprocess(
+  (value) => withAliases(value, workflowVersionAliasMap),
+  workflowVersionStubObjectSchema.extend({
+    parentVersion: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
+    workflow: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string(),
+    ),
+    createdBy: preprocess(
+      (value) => (value == null ? null : asId(value)),
+      z.string().nullable(),
+    ),
+  }),
+);
+
+export const workflowVersionFullSchema = workflowVersionStubObjectSchema.extend(
+  {
+    parentVersion: preprocess(
+      nullishToNull,
+      z.lazy(() => workflowVersionSchema).nullable(),
+    ),
+    workflow: z.lazy(() => workflowSchema),
+    createdBy: preprocess(
+      (value) => (value == null ? null : value),
+      z.lazy(() => userSchema).nullable(),
+    ),
+  },
+);
+
+export type WorkflowVersionStub = z.infer<typeof workflowVersionStubSchema>;
+
+export type WorkflowVersion = z.infer<typeof workflowVersionSchema>;
+
+export type WorkflowVersionFull = z.infer<typeof workflowVersionFullSchema>;