@lota-sdk/shared 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/shared",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -37,7 +37,8 @@
   "scripts": {
     "lint": "node ../node_modules/oxlint/bin/oxlint --fix -c ../oxlint.config.ts src",
     "format": "bunx oxfmt src",
-    "typecheck": "bunx tsgo --noEmit"
+    "typecheck": "bunx tsgo --noEmit",
+    "test:unit": "bun test ../tests/unit/shared"
   },
   "publishConfig": {
     "access": "public",

package/src/index.ts

@@ -7,9 +7,15 @@ export * from './schemas/common'
 export * from './schemas/document'
 export * from './schemas/error'
 export * from './schemas/execution-plan'
+export * from './schemas/organization'
+export * from './schemas/organization-api'
 export * from './schemas/recent-activity'
 export * from './schemas/repository-structure'
 export * from './schemas/tools'
+export * from './schemas/user'
+export * from './schemas/user-api'
+export * from './schemas/workstream'
+export * from './schemas/workstream-api'
 export * from './utils/assistant-text'
 export * from './utils/markdown-normalization'
 export * from './utils/string'

package/src/schemas/organization-api.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+
+import { recordIdSchema } from './common'
+import { sdkOrganizationSchema } from './organization'
+
+export const createSdkOrganizationRequestSchema = z.object({ name: z.string().trim().min(1).max(100) })
+
+export const upsertSdkOrganizationRequestSchema = z.object({
+  id: recordIdSchema,
+  name: z.string().trim().min(1).max(100),
+})
+
+export const updateSdkOrganizationRequestSchema = z.object({ name: z.string().trim().min(1).max(100) })
+
+export const listSdkOrganizationsResponseSchema = z.object({ organizations: z.array(sdkOrganizationSchema) })
+
+export type CreateSdkOrganizationRequest = z.infer<typeof createSdkOrganizationRequestSchema>
+export type UpsertSdkOrganizationRequest = z.infer<typeof upsertSdkOrganizationRequestSchema>
+export type UpdateSdkOrganizationRequest = z.infer<typeof updateSdkOrganizationRequestSchema>
+export type ListSdkOrganizationsResponse = z.infer<typeof listSdkOrganizationsResponseSchema>

package/src/schemas/organization.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod'
+
+import { recordIdSchema, recordIdStringSchema } from './common'
+
+export const sdkOrganizationSchema = z.object({
+  id: recordIdStringSchema,
+  name: z.string(),
+  regularChatDigestLastWorkstreamCursorCreatedAt: z.iso.datetime().nullable().optional(),
+  regularChatDigestLastWorkstreamCursorId: z.string().nullable().optional(),
+  skillExtractionLastCursorId: z.string().nullable().optional(),
+  skillExtractionLastCursorCreatedAt: z.iso.datetime().nullable().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+})
+
+export const sdkOrganizationRecordSchema = z.object({
+  id: recordIdSchema,
+  name: z.string(),
+  regularChatDigestLastWorkstreamCursorCreatedAt: z.coerce.date().optional(),
+  regularChatDigestLastWorkstreamCursorId: z.string().optional(),
+  skillExtractionLastCursorId: z.string().optional(),
+  skillExtractionLastCursorCreatedAt: z.coerce.date().optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+export type SdkOrganization = z.infer<typeof sdkOrganizationSchema>
+export type SdkOrganizationRecord = z.infer<typeof sdkOrganizationRecordSchema>

package/src/schemas/user-api.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+import { recordIdSchema } from './common'
+import { sdkUserSchema } from './user'
+
+export const upsertSdkUserRequestSchema = z.object({
+  id: recordIdSchema,
+  name: z.string().trim().min(1).max(100),
+  email: z.string().email(),
+})
+
+export const updateSdkUserRequestSchema = z.object({
+  name: z.string().trim().min(1).max(100).optional(),
+  email: z.string().email().optional(),
+})
+
+export const listSdkUsersResponseSchema = z.object({ users: z.array(sdkUserSchema) })
+
+export type UpsertSdkUserRequest = z.infer<typeof upsertSdkUserRequestSchema>
+export type UpdateSdkUserRequest = z.infer<typeof updateSdkUserRequestSchema>
+export type ListSdkUsersResponse = z.infer<typeof listSdkUsersResponseSchema>

package/src/schemas/user.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod'
+
+import { recordIdSchema, recordIdStringSchema } from './common'
+
+export const sdkUserSchema = z.object({
+  id: recordIdStringSchema,
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+})
+
+export const sdkUserRecordSchema = z.object({
+  id: recordIdSchema,
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+export type SdkUser = z.infer<typeof sdkUserSchema>
+export type SdkUserRecord = z.infer<typeof sdkUserRecordSchema>

package/src/schemas/workstream-api.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod'
+
+import { baseChatMessageSchema } from './chat-api'
+import { paginationPageSchema, paginationTakeSchema, recordIdSchema } from './common'
+import { sdkWorkstreamSchema } from './workstream'
+
+export const listSdkWorkstreamsRequestSchema = z.object({
+  userId: recordIdSchema,
+  organizationId: recordIdSchema,
+  mode: z.enum(['direct', 'group']),
+  core: z.boolean().optional(),
+  page: paginationPageSchema.optional(),
+  take: paginationTakeSchema.optional(),
+  includeArchived: z.boolean().default(false),
+})
+
+export const createSdkWorkstreamRequestSchema = z.object({
+  userId: recordIdSchema,
+  organizationId: recordIdSchema,
+  title: z.string().trim().min(1).max(200).optional(),
+  mode: z.enum(['direct', 'group']).default('group'),
+  agentId: z.string().trim().min(1).optional(),
+  core: z.boolean().optional(),
+  coreType: z.string().trim().min(1).optional(),
+})
+
+export const updateSdkWorkstreamRequestSchema = z.object({ title: z.string().trim().min(1).max(200) })
+
+export const listSdkWorkstreamsResponseSchema = z.object({
+  workstreams: z.array(sdkWorkstreamSchema),
+  hasMore: z.boolean(),
+  page: z.number().optional(),
+})
+
+export const getSdkWorkstreamResponseSchema = sdkWorkstreamSchema
+
+export const listSdkWorkstreamMessagesRequestSchema = z.object({
+  before: z.string().trim().min(1).optional(),
+  after: z.string().trim().min(1).optional(),
+  limit: paginationTakeSchema.optional(),
+})
+
+export const listSdkWorkstreamMessagesResponseSchema = z.object({
+  messages: z.array(baseChatMessageSchema),
+  hasMore: z.boolean(),
+  prevCursor: z.string().nullable().optional(),
+  nextCursor: z.string().nullable().optional(),
+})
+
+export const sdkWorkstreamMessageLookupSchema = z.object({
+  workstreamId: recordIdSchema,
+  messageId: z.string().trim().min(1),
+})
+
+export const sdkWorkstreamSendMessageRequestSchema = z.object({
+  workstreamId: recordIdSchema,
+  organizationId: recordIdSchema,
+  userId: recordIdSchema,
+  userName: z.string().trim().min(1),
+  messages: z.array(baseChatMessageSchema).min(1),
+})
+
+export type ListSdkWorkstreamsRequest = z.infer<typeof listSdkWorkstreamsRequestSchema>
+export type CreateSdkWorkstreamRequest = z.infer<typeof createSdkWorkstreamRequestSchema>
+export type UpdateSdkWorkstreamRequest = z.infer<typeof updateSdkWorkstreamRequestSchema>
+export type ListSdkWorkstreamsResponse = z.infer<typeof listSdkWorkstreamsResponseSchema>
+export type GetSdkWorkstreamResponse = z.infer<typeof getSdkWorkstreamResponseSchema>
+export type ListSdkWorkstreamMessagesRequest = z.infer<typeof listSdkWorkstreamMessagesRequestSchema>
+export type ListSdkWorkstreamMessagesResponse = z.infer<typeof listSdkWorkstreamMessagesResponseSchema>
+export type SdkWorkstreamMessageLookup = z.infer<typeof sdkWorkstreamMessageLookupSchema>
+export type SdkWorkstreamSendMessageRequest = z.infer<typeof sdkWorkstreamSendMessageRequestSchema>

package/src/schemas/workstream.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod'
+
+import { recordIdSchema, recordIdStringSchema } from './common'
+
+export const sdkWorkstreamModeSchema = z.enum(['direct', 'group'])
+export const sdkWorkstreamStatusSchema = z.enum(['regular', 'archived'])
+
+export const sdkWorkstreamSchema = z.object({
+  id: recordIdStringSchema,
+  organizationId: recordIdStringSchema,
+  userId: recordIdStringSchema,
+  agentId: z.string().nullable().optional(),
+  mode: sdkWorkstreamModeSchema,
+  core: z.boolean(),
+  coreType: z.string().nullable().optional(),
+  title: z.string(),
+  status: sdkWorkstreamStatusSchema,
+  nameGenerated: z.boolean(),
+  isRunning: z.boolean(),
+  isCompacting: z.boolean(),
+  memoryBlock: z.string().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+})
+
+export const sdkWorkstreamRecordSchema = z.object({
+  id: recordIdSchema,
+  organizationId: recordIdSchema,
+  userId: recordIdSchema,
+  agentId: z.string().nullish(),
+  mode: sdkWorkstreamModeSchema.optional(),
+  core: z.boolean().optional(),
+  coreType: z.string().nullish(),
+  title: z.string().nullish(),
+  status: sdkWorkstreamStatusSchema.nullish(),
+  memoryBlock: z.string().nullish(),
+  memoryBlockSummary: z.string().nullish(),
+  activeRunId: z.string().nullish(),
+  chatSummary: z.string().nullish(),
+  lastCompactedMessageId: z.string().nullish(),
+  nameGenerated: z.boolean().optional(),
+  isCompacting: z.boolean().optional(),
+  state: z.unknown().optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+export const sdkWorkstreamMessageSchema = z.object({
+  id: recordIdStringSchema,
+  workstreamId: recordIdStringSchema,
+  messageId: z.string(),
+  role: z.enum(['system', 'user', 'assistant']),
+  parts: z.array(z.record(z.string(), z.unknown())),
+  metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime().optional(),
+})
+
+export const sdkWorkstreamAttachmentSchema = z.object({
+  id: recordIdStringSchema,
+  attachmentType: z.string(),
+  name: z.string(),
+  contentType: z.string(),
+  storageKey: z.string().nullable().optional(),
+  sizeBytes: z.number().nullable().optional(),
+  url: z.string().nullable().optional(),
+  messageId: recordIdStringSchema,
+  workstreamId: recordIdStringSchema,
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+})
+
+export type SdkWorkstream = z.infer<typeof sdkWorkstreamSchema>
+export type SdkWorkstreamRecord = z.infer<typeof sdkWorkstreamRecordSchema>
+export type SdkWorkstreamMessage = z.infer<typeof sdkWorkstreamMessageSchema>
+export type SdkWorkstreamAttachment = z.infer<typeof sdkWorkstreamAttachmentSchema>