@onkeiki/agents 0.1.0

package/src/services/Transport.ts

@@ -0,0 +1,21 @@
+import { Context, Effect } from 'effect'
+import type { MediaPayload, SendResult } from '../types/index.js'
+
+export interface TransportService {
+  readonly send: (opts: {
+    from: string
+    to: string
+    text: string
+    media?: MediaPayload
+  }) => Effect.Effect<SendResult>
+
+  readonly getDeliveryStatus: (messageId: string) => Effect.Effect<{
+    state: 'delivered' | 'failed' | 'pending'
+    error?: string
+  }>
+}
+
+export class Transport extends Context.Tag('@onkeiki/agents/Transport')<
+  Transport,
+  TransportService
+>() {}

package/src/services/index.ts

@@ -0,0 +1,8 @@
+export { Storage, StorageError, type StorageService, type NewMessage, type DeliveryClaim, type UsageEvent, type BillingPeriod, type UsageSummary } from './Storage.js'
+export { Transport, type TransportService } from './Transport.js'
+export { Platform, PlatformError, type PlatformService, type MemoryFact, type BrowseResult, type SandboxExecResult, type HandoffResult, type EscalationResult, type BackgroundJobResult } from './Platform.js'
+export { Steering, type SteeringService, type SteeringDecision, type TurnState } from './Steering.js'
+export { Blackboard, type BlackboardService } from './Blackboard.js'
+export { Observability, ObservabilityError, braintrustExporter, axiomExporter, otelExporter, customExporter, type TraceExporter, type TraceEvent, type SpanEvent, type SpanKind, type SpanStatus } from './Observability.js'
+export { SandboxProvider, type SandboxProviderService, type SandboxHandle, type SandboxExecResult as SandboxProviderExecResult } from './Sandbox.js'
+export { PluginDb, type PluginDbService, type PluginMigration } from './PluginDb.js'

package/src/types/config.ts

@@ -0,0 +1,531 @@
+import type { Effect, Layer } from 'effect'
+import type { UserProfile } from './user.js'
+import type { InboundMessage, DeliveryStatus } from './message.js'
+import type { Storage, StorageError } from '../services/Storage.js'
+import type { Transport } from '../services/Transport.js'
+import type { AgentKitPlugin } from '../Plugin.js'
+import type { ToolDefinition } from '../Tool.js'
+import type { AlertDefinition } from '../Alert.js'
+import type { TraceExporter } from '../services/Observability.js'
+import type { PluginDbService } from '../services/PluginDb.js'
+
+export type DurationInput = `${number} ${'seconds' | 'minutes' | 'hours'}` | number
+
+export type HarnessConfig = {
+  readonly type: 'flue' | 'hermes'
+  readonly dispatchUrl?: string
+  readonly timeoutMs?: DurationInput
+  readonly connectivity?: 'push' | 'relay'
+}
+
+export type PromptContext = {
+  readonly user: UserProfile
+  readonly now: Date
+  readonly phone: string
+  readonly context: RetrievedContext
+  /** True when this turn carries the user's first-ever message (no prior history). */
+  readonly isFirstInteraction: boolean
+  /** Conversation history given to the model this turn, oldest first. */
+  readonly history: ReadonlyArray<{ readonly content: string; readonly direction: 'inbound' | 'outbound' }>
+  /**
+   * True when the prompt is being rendered once for platform storage
+   * (kit.sync) rather than for a live turn. Omit time-of-day content in that
+   * case — the platform injects a fresh Current Date/Time section per turn.
+   */
+  readonly staticSync?: boolean
+}
+
+/** Turn-loop progress visible to {@link TurnHooks} after each step. */
+export type TurnHookState = {
+  /** 0-based index of the step about to run (prepareStep) or just finished (stopWhen). */
+  readonly step: number
+  /** Tool calls executed so far this turn. */
+  readonly toolCalls: number
+  /** Name of the most recently executed tool, if any. */
+  readonly lastToolName?: string
+  /** Error message from the most recent tool call, when it failed. */
+  readonly lastToolError?: string
+  /** JSON-serialized input of the most recent tool call, if any. */
+  readonly lastToolInput?: string
+  /** Consecutive identical tool failures (same tool, input, and error) ending at the most recent call. 0 when the last call succeeded. */
+  readonly identicalFailureStreak: number
+}
+
+/** What {@link TurnHooks.reviewReply} sees when a candidate final reply is produced. */
+export type TurnReviewState = {
+  /** Tool calls executed this turn, in order. */
+  readonly toolResults: ReadonlyArray<{ readonly name: string; readonly input: unknown; readonly output: unknown }>
+  /** 0-based count of review retries already spent this turn. */
+  readonly attempt: number
+}
+
+/**
+ * Developer hooks into the agent turn loop.
+ */
+export type TurnHooks = {
+  /** Rewrite the final reply before it is returned (sanitizers, length caps, sign-offs). */
+  readonly transformReply?: (reply: string, ctx: PromptContext) => string
+  /** Called before each LLM step; may inject an extra system message for that step only. */
+  readonly prepareStep?: (state: TurnHookState, ctx: PromptContext) => { readonly appendSystem?: string } | undefined
+  /** Extra stop condition checked after each step's tool calls. Return true to end the turn. */
+  readonly stopWhen?: (state: TurnHookState, ctx: PromptContext) => boolean
+  /**
+   * Gate a candidate final reply (called on the post-`transformReply` text —
+   * what would actually be delivered). Return `{ retryWith }` to reject it:
+   * the corrective text is appended as a system message and the turn loop
+   * continues (bounded retries). A rejected reply is never delivered — if
+   * retries run out or the step budget ends on a rejected candidate, the
+   * turn returns an empty reply instead.
+   */
+  readonly reviewReply?: (reply: string, ctx: PromptContext, state: TurnReviewState) => { readonly retryWith?: string } | undefined
+}
+
+export type RetrievedContext = {
+  readonly memorySummary: string | null
+  readonly relevantFacts: ReadonlyArray<{ fact: string; category: string }>
+}
+
+export type ResolveNumberContext = {
+  readonly phone: string
+  readonly user: UserProfile
+  readonly direction: 'inbound' | 'outbound'
+  readonly platform: {
+    readonly getUserMeta: (phone: string, key: string) => Effect.Effect<string | null>
+    readonly setUserMeta: (phone: string, key: string, value: string) => Effect.Effect<void>
+    readonly acquireLine: (opts: AcquireLineOpts) => Effect.Effect<PhoneLine>
+  }
+}
+
+export type AcquireLineOpts = {
+  readonly pool: string
+  readonly strategy: 'least-active' | 'round-robin' | 'random' | 'geo-closest'
+  readonly sticky?: boolean
+  readonly region?: string
+}
+
+export type PhoneLine = {
+  readonly number: string
+  readonly pool: string
+  readonly region: string
+  readonly activeConversations: number
+}
+
+export type MemoryConfig = {
+  readonly enabled: boolean
+  readonly provider: 'supermemory'
+  readonly autoRetrieve?: boolean
+  readonly categories?: ReadonlyArray<string>
+}
+
+export type BrowserConfig = {
+  readonly enabled: boolean
+  readonly handoff?: boolean
+  readonly screenshotDelivery?: boolean
+}
+
+export type SandboxConfig = {
+  readonly enabled: boolean
+  readonly persistent?: boolean
+  readonly maxExecTime?: DurationInput
+}
+
+export type ExecutorConfig = {
+  readonly enabled: boolean
+  readonly maxConcurrent?: number
+  readonly timeout?: DurationInput
+  readonly onComplete?: 'notify' | 'silent'
+}
+
+/**
+ * Executor.sh–backed custom tool support (the `mcp()` plugin). Lets conversation
+ * users connect their own remote MCP servers and OpenAPI specs at runtime.
+ * Requires the Sandbox capability.
+ */
+export type McpConfig = {
+  readonly enabled: boolean
+  /** Max sources (MCP servers + OpenAPI specs) a user can connect. */
+  readonly maxServers?: number
+  /** Whether conversation users may add sources themselves. */
+  readonly userCanAdd?: boolean
+  /**
+   * Developer-declared per-user connections. Each entry names an OpenAPI
+   * provider (e.g. Gmail) that every conversation user authorizes
+   * individually: the agent texts them a fresh connect link, they complete
+   * OAuth in the browser, and the resulting credential lives in that user's
+   * own Executor daemon — never shared across users or exposed to the model.
+   */
+  readonly userConnections?: ReadonlyArray<UserConnectionDefinition>
+}
+
+/**
+ * OAuth app config for a user connection. The client id/secret are named
+ * developer secrets (synced via `secrets`), resolved server-side at connect
+ * time — the values never appear in the agent config or model context.
+ */
+export type UserConnectionOAuth = {
+  readonly authorizationUrl: string
+  readonly tokenUrl: string
+  /** Developer-secret name holding the OAuth client id. */
+  readonly clientIdSecret: string
+  /** Developer-secret name holding the OAuth client secret. */
+  readonly clientSecretSecret: string
+}
+
+/**
+ * The connection's liveness probe: one read-only operation the user's daemon
+ * runs against the real provider to answer "is this credential still alive?".
+ * Without it health falls back to local credential resolution, which cannot
+ * detect a token revoked upstream — declare one for every connection.
+ */
+export type UserConnectionHealthCheck = {
+  /** Operation name as it appears in the spec (e.g. `users.getProfile`). */
+  readonly operation: string
+  /** Pinned arguments the operation needs (e.g. Gmail's `{ userId: "me" }`). */
+  readonly args?: Readonly<Record<string, unknown>>
+  /** Dot-path into the response shown as the connection's identity. */
+  readonly identityField?: string
+}
+
+export type UserConnectionDefinition = {
+  /** Stable connection name, also the Executor source slug (e.g. "gmail"). */
+  readonly name: string
+  /** Shown to the model so it knows when to offer connecting this provider. */
+  readonly description?: string
+  /** Alternate names users may say for THIS connection (e.g. "gcal"). */
+  readonly aliases?: ReadonlyArray<string>
+  /**
+   * The company behind the provider ("google", "microsoft"). Not an alias: two
+   * connections may share a vendor, and a shared vendor word is ambiguous
+   * rather than a match, so it can never silently select one of them.
+   */
+  readonly vendor?: string
+  /**
+   * What this connection lets the agent do, as `domain.verb` ("mail.read",
+   * "calendar.write"). Declaring these lets a caller that says a vendor word
+   * plus what it needs ("google", "calendar") resolve without being asked.
+   */
+  readonly capabilities?: ReadonlyArray<string>
+  /** OpenAPI spec URL registered as the Executor source. */
+  readonly spec: string
+  /** Override for the API base URL when the spec's `servers` entry is wrong. */
+  readonly baseUrl?: string
+  readonly oauth: UserConnectionOAuth
+  readonly healthCheck?: UserConnectionHealthCheck
+}
+
+export type SteeringConfig = {
+  readonly debounceWindow: DurationInput
+  readonly midTurnStrategy: 'interrupt' | 'append' | 'queue'
+  readonly maxBatch: number
+  readonly classify?: (
+    pending: ReadonlyArray<InboundMessage>,
+    incoming: InboundMessage
+  ) => Effect.Effect<'steer' | 'new-turn'>
+}
+
+export type MediaActionConfig = {
+  readonly action: 'transcribe' | 'describe' | 'extract' | 'ignore' | 'pass-url' | 'pass-raw'
+  readonly model?: string
+  readonly prompt?: string
+  readonly maxSize?: string
+  readonly format?: (content: string) => string
+}
+
+export type MediaConfig = {
+  readonly audio: MediaActionConfig
+  readonly image: MediaActionConfig
+  readonly video: MediaActionConfig
+  readonly document: MediaActionConfig
+  readonly fallback: string
+}
+
+export type EscalationRoute = {
+  readonly webhook?: string
+  readonly slack?: { readonly channel: string }
+  readonly email?: string
+}
+
+export type EscalationConfig = {
+  readonly enabled: boolean
+  readonly requireConfirmation?: boolean
+  readonly routes: EscalationRoute
+}
+
+export type EventHandlers = {
+  readonly onInbound?: (msg: InboundMessage) => Effect.Effect<{ proceed: boolean; enrichment?: Record<string, unknown> }>
+  readonly onOutbound?: (msg: { phone: string; text: string; messageId: string }) => Effect.Effect<void>
+  readonly onDeliveryStatus?: (status: DeliveryStatus) => Effect.Effect<void>
+  readonly onNewUser?: (event: { phone: string; firstMessage: string }) => Effect.Effect<void>
+  readonly onOptOut?: (event: { phone: string }) => Effect.Effect<void>
+}
+
+export type ObservabilityConfig = {
+  readonly enabled: boolean
+  readonly exporters: ReadonlyArray<TraceExporter>
+  readonly sampleRate?: number // 0.0 - 1.0, default 1.0 (export all traces)
+  readonly redactInputs?: boolean // Strip PII from span inputs before export
+  readonly redactOutputs?: boolean // Strip PII from span outputs before export
+}
+
+/**
+ * A developer-defined loop template synced to the platform with the agent.
+ * The model creates it with `create_loop { preset: <name> }` — the prompt and
+ * schedule come from this definition, so they never travel through a tool call.
+ */
+export type LoopPresetDefinition = {
+  readonly name: string
+  /** Shown to the model so it knows when to offer this loop. */
+  readonly description: string
+  readonly prompt: string
+  readonly scheduleType: 'once' | 'cron' | 'interval'
+  readonly scheduleExpression: string
+  readonly timezone?: string
+  readonly quiet?: boolean
+}
+
+export type LoopsConfig = {
+  readonly enabled: boolean
+  readonly presets?: ReadonlyArray<LoopPresetDefinition>
+}
+
+/**
+ * A reference to an already-published capability, pinned to an exact version.
+ * `publisher` defaults to `official`. See docs/capabilities.md.
+ */
+export type CapabilityRef = {
+  readonly slug: string
+  readonly version: string
+  readonly publisher?: string
+}
+
+export type CapabilityRuntime = 'render-template' | 'openapi' | 'codemode' | 'mcp' | 'builtin'
+
+/** Host namespaces a capability may declare in `uses` (optionally `name@range`). */
+export type CapabilityNamespace = 'loops' | 'entities' | 'sandbox' | 'browser' | 'mcp' | 'cards' | 'http'
+
+export type CapabilitySecret = {
+  readonly name: string
+  readonly required?: boolean
+  readonly description?: string
+}
+
+export type CapabilityField = {
+  readonly name: string
+  readonly type: string
+  readonly required?: boolean
+  readonly description?: string
+}
+
+/** How a tool runs; `kind` always equals the manifest `runtime`. */
+export type CapabilityToolRun<R extends CapabilityRuntime = CapabilityRuntime> = R extends 'render-template'
+  ? {
+      readonly kind: R
+      /** Name of an entry in the manifest's `templates`. */
+      readonly template: string
+      /** Tool argument sent as plain text if rendering fails (default `fallback_text`). */
+      readonly textFallbackArg?: string
+    }
+  : { readonly kind: R }
+
+/** A tool the installing agent sees; it only ever reads `description` and `inputSchema`. */
+export type CapabilityTool<R extends CapabilityRuntime = CapabilityRuntime> = {
+  readonly name: string
+  readonly description: string
+  readonly inputSchema: Record<string, unknown>
+  readonly run: CapabilityToolRun<R>
+}
+
+export type CapabilityTemplate = {
+  readonly name: string
+  readonly source: string
+  readonly inputSchema?: { readonly fields: ReadonlyArray<CapabilityField> }
+}
+
+/** A durable, per-user table the capability owns (requires `uses: ["entities"]`). */
+export type CapabilityEntity = {
+  readonly name: string
+  readonly description?: string
+  readonly fields?: ReadonlyArray<CapabilityField>
+  readonly maxRowsPerUser?: number
+}
+
+/** The check the platform runs before the agent on every loop tick. */
+export type CapabilityLoopProbe =
+  | { readonly kind: 'execute'; readonly code: string; readonly connections?: 'personal' | 'shared' }
+  | {
+      readonly kind: 'gmail.history' | 'calendar.sync' | 'calendar.upcoming' | 'outlook.delta' | 'outlook-calendar.upcoming'
+      readonly integration?: string
+      readonly connections?: 'personal' | 'shared'
+      readonly leadMinutes?: number
+      readonly labelId?: string | null
+    }
+
+/** When a probe's changes start the agent; anything but `always` needs a `probe`. */
+export type CapabilityLoopTrigger =
+  | { readonly kind: 'always' }
+  | { readonly kind: 'any_change' }
+  | { readonly kind: 'added'; readonly min?: number }
+  | { readonly kind: 'match'; readonly pattern: string; readonly on?: 'added' | 'any' }
+  | { readonly kind: 'model'; readonly question: string; readonly model?: string }
+
+/** A loop installed with the capability (requires `uses: ["loops"]`). */
+export type CapabilityLoop = {
+  readonly name: string
+  readonly description?: string
+  readonly prompt: string
+  readonly scheduleType: 'once' | 'cron' | 'interval'
+  readonly scheduleExpression: string
+  readonly timezone?: string
+  readonly quiet?: boolean
+  readonly requiresConnections?: ReadonlyArray<string>
+  readonly probe?: CapabilityLoopProbe
+  readonly trigger?: CapabilityLoopTrigger
+}
+
+/**
+ * A versioned capability manifest, published privately under the developer's
+ * organization from `agent.capabilities` at sync time. Discriminated on
+ * `runtime`, so every tool's `run.kind` must match it and `templates` only
+ * exist on `render-template`. The platform validates the same shape; see
+ * docs/capabilities.md.
+ */
+export type CapabilityManifest = {
+  [R in CapabilityRuntime]: {
+    /** `[a-z0-9-]`, max 64 chars, unique within the publisher. */
+    readonly slug: string
+    /** Exact semver, e.g. `1.0.0`. */
+    readonly version: string
+    readonly title: string
+    readonly description: string
+    readonly runtime: R
+    readonly uses?: ReadonlyArray<CapabilityNamespace | `${CapabilityNamespace}@${string}`>
+    readonly secrets?: ReadonlyArray<CapabilitySecret>
+    readonly tools?: ReadonlyArray<CapabilityTool<R>>
+    /** Guidance for the installing agent on when to use the tools. */
+    readonly prompt?: string
+    readonly loops?: ReadonlyArray<CapabilityLoop>
+    readonly entities?: ReadonlyArray<string | CapabilityEntity>
+    /** Hosts the `http` namespace may reach, `host` (port 443) or `host:port` (required with `uses: ["http"]`). */
+    readonly http?: { readonly allow: ReadonlyArray<string> }
+  } & (R extends 'render-template' ? { readonly templates?: ReadonlyArray<CapabilityTemplate> } : { readonly templates?: never })
+}[CapabilityRuntime]
+
+export type CapabilityInput = CapabilityRef | CapabilityManifest
+
+export type AgentConfig = {
+  readonly model: string
+  readonly maxSteps: number
+  readonly historyLimit: number
+  readonly systemPrompt: (ctx: PromptContext) => string
+  readonly tools: ReadonlyArray<ToolDefinition<any, any>>
+  readonly alerts?: ReadonlyArray<AlertDefinition>
+  readonly hooks?: TurnHooks
+
+  readonly memory?: MemoryConfig
+  readonly browser?: BrowserConfig
+  readonly sandbox?: SandboxConfig
+  readonly executor?: ExecutorConfig
+  readonly mcp?: McpConfig
+  readonly blackboard?: boolean
+  readonly promptCache?: boolean
+  readonly escalation?: EscalationConfig
+  readonly steering?: SteeringConfig
+  readonly media?: MediaConfig
+  readonly observability?: ObservabilityConfig
+  readonly loops?: LoopsConfig
+  /** Capabilities installed on this agent: refs to published capabilities or full manifests. */
+  readonly capabilities?: ReadonlyArray<CapabilityInput>
+}
+
+/**
+ * A storage adapter bundled with a PluginDb service.
+ * Returned by adapter factories like `PostgresStorage()`.
+ */
+export type StorageBundle = {
+  readonly layer: Layer.Layer<Storage, StorageError>
+  readonly pluginDb: PluginDbService
+}
+
+/**
+ * Channel type identifiers for multi-channel agent support.
+ */
+export type ChannelType = 'sms' | 'telegram' | (string & {})
+
+/**
+ * Telegram channel configuration.
+ */
+export type TelegramChannelConfig = {
+  readonly type: 'telegram'
+  /** Telegram Bot API token. */
+  readonly botToken: string
+  /** Optional: restrict to specific chat IDs. */
+  readonly allowedChatIds?: ReadonlyArray<number>
+}
+
+/**
+ * SMS channel configuration (wraps the legacy resolveNumber pattern).
+ */
+export type SmsChannelConfig = {
+  readonly type: 'sms'
+  /** Resolve which outbound phone line to use for a given context. */
+  readonly resolveNumber: (ctx: ResolveNumberContext) => Effect.Effect<string>
+}
+
+/**
+ * Union of supported channel configurations.
+ */
+export type ChannelConfig = SmsChannelConfig | TelegramChannelConfig
+
+export type AgentKitConfig = {
+  readonly apiKey: string
+  readonly name: string
+  /**
+   * @deprecated Use `channels` array with an SMS channel config instead.
+   * Kept for backward compatibility with SMS-only agents.
+   */
+  readonly resolveNumber?: (ctx: ResolveNumberContext) => Effect.Effect<string>
+  /**
+   * Channel configurations. Each channel handles its own inbound routing
+   * and outbound delivery. If omitted with a `resolveNumber`, a single
+   * SMS channel is implied.
+   *
+   * @example
+   * ```ts
+   * channels: [
+   *   { type: 'sms', resolveNumber: (ctx) => Effect.succeed('+14155551234') },
+   *   { type: 'telegram', botToken: process.env.TG_BOT_TOKEN! },
+   * ]
+   * ```
+   */
+  readonly channels?: ReadonlyArray<ChannelConfig>
+  /**
+   * Storage adapter for a self-run loop. Pass either:
+   * - A raw `Layer` (backward compat, no plugin DB support)
+   * - A `StorageBundle` from a factory like `PostgresStorage()` (includes both storage and pluginDb)
+   * Cloud agents (the default harness) need none: the platform stores history and users.
+   */
+  readonly storage?: Layer.Layer<Storage, StorageError> | StorageBundle
+  readonly agent: AgentConfig
+  /** Select the turn loop implementation. Defaults to the platform Flue harness. */
+  readonly harness?: HarnessConfig
+  readonly events?: EventHandlers
+  /** Secrets to sync to the platform (name → value). Accessible at runtime via ctx.secrets. */
+  readonly secrets?: Readonly<Record<string, string>>
+  /**
+   * Plugins extend the agent with tools, hooks, routes, and layers.
+   * Each plugin is self-contained and composable — capabilities that
+   * were previously part of AgentConfig (memory, browser, sandbox,
+   * steering, etc.) can now be isolated into plugins.
+   *
+   * Order matters: plugins initialize in array order, and each plugin's
+   * `init` sees the config contributions of the plugins before it — so a
+   * plugin that depends on another's config (e.g. `mcp()` requiring an
+   * enabled sandbox) must come after it.
+   */
+  readonly plugins?: ReadonlyArray<AgentKitPlugin>
+}
+
+/**
+ * @deprecated Use {@link AgentKitConfig} instead. Kept for backwards compatibility.
+ */
+export type SmsKitConfig = AgentKitConfig

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './message.js'
+export * from './user.js'
+export * from './config.js'

package/src/types/message.ts

@@ -0,0 +1,60 @@
+import { Schema } from 'effect'
+
+export const Direction = Schema.Literal('inbound', 'outbound')
+export type Direction = typeof Direction.Type
+
+export const InboundMessage = Schema.Struct({
+  phone: Schema.String,
+  chatId: Schema.String,
+  messageId: Schema.String,
+  text: Schema.String,
+  mediaUrl: Schema.optional(Schema.String),
+  mediaMimeType: Schema.optional(Schema.String),
+  timestamp: Schema.Date,
+})
+export type InboundMessage = typeof InboundMessage.Type
+
+export const OutboundMessage = Schema.Struct({
+  phone: Schema.String,
+  chatId: Schema.String,
+  text: Schema.String,
+  mediaUrl: Schema.optional(Schema.String),
+  externalMessageId: Schema.optional(Schema.String),
+})
+export type OutboundMessage = typeof OutboundMessage.Type
+
+export const StoredMessage = Schema.Struct({
+  id: Schema.String,
+  phone: Schema.String,
+  chatId: Schema.String,
+  direction: Direction,
+  content: Schema.String,
+  mediaUrl: Schema.optional(Schema.String),
+  mediaMimeType: Schema.optional(Schema.String),
+  externalMessageId: Schema.optional(Schema.String),
+  createdAt: Schema.Date,
+})
+export type StoredMessage = typeof StoredMessage.Type
+
+export const MediaPayload = Schema.Struct({
+  url: Schema.optional(Schema.String),
+  base64: Schema.optional(Schema.String),
+  mimeType: Schema.String,
+  filename: Schema.optional(Schema.String),
+})
+export type MediaPayload = typeof MediaPayload.Type
+
+export const SendResult = Schema.Struct({
+  chatId: Schema.String,
+  messageId: Schema.String,
+})
+export type SendResult = typeof SendResult.Type
+
+export const DeliveryStatus = Schema.Struct({
+  messageId: Schema.String,
+  phone: Schema.String,
+  state: Schema.Literal('delivered', 'failed', 'pending'),
+  error: Schema.optional(Schema.String),
+  timestamp: Schema.Date,
+})
+export type DeliveryStatus = typeof DeliveryStatus.Type

package/src/types/user.ts

@@ -0,0 +1,17 @@
+import { Schema } from 'effect'
+
+export const UserProfile = Schema.Struct({
+  phone: Schema.String,
+  timezone: Schema.NullOr(Schema.String),
+  currency: Schema.NullOr(Schema.String),
+  metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+  firstSeenAt: Schema.Date,
+})
+export type UserProfile = typeof UserProfile.Type
+
+export const Subscriber = Schema.Struct({
+  phone: Schema.String,
+  chatId: Schema.String,
+  preferences: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+})
+export type Subscriber = typeof Subscriber.Type