saeeol 1.1.1 → 1.2.1

package/src/session/message-types.ts

@@ -1,68 +1 @@
-/** User/Assistant 스키마 + Events + Cursor — message-v2.ts에서 분리 */
-
-import { SessionID, MessageID, PartID } from "./schema"
-import { Snapshot } from "@/snapshot"
-import { SyncEvent } from "../sync"
-import { BusEvent } from "@/bus/bus-event"
-import { Effect, Schema, Types } from "effect"
-import { zod } from "@/util/effect-zod"
-import { NonNegativeInt, withStatics } from "@/util/schema"
-import { ModelID, ProviderID } from "@/provider/schema"
-import { _Part } from "./message-parts"
-import { AssistantErrorSchema, AssistantErrorZod, _Format } from "./message-errors"
-export { AssistantErrorSchema, AssistantErrorZod, _Format, _Part as Part }
-export type { AssistantError } from "./message-errors"
-import z from "zod"
-
-const messageBase = { id: MessageID, sessionID: SessionID }
-
-export const EditorContext = Schema.Struct({
-  visibleFiles: Schema.optional(Schema.Array(Schema.String)), openTabs: Schema.optional(Schema.Array(Schema.String)),
-  activeFile: Schema.optional(Schema.String), shell: Schema.optional(Schema.String),
-})
-export type EditorContext = Types.DeepMutable<Schema.Schema.Type<typeof EditorContext>>
-
-export const User = Schema.Struct({
-  ...messageBase, role: Schema.Literal("user"), time: Schema.Struct({ created: NonNegativeInt }), format: Schema.optional(_Format),
-  summary: Schema.optional(Schema.Struct({ title: Schema.optional(Schema.String), body: Schema.optional(Schema.String), diffs: Schema.Array(Snapshot.FileDiff) })),
-  agent: Schema.String, model: Schema.Struct({ providerID: ProviderID, modelID: ModelID, variant: Schema.optional(Schema.String) }),
-  system: Schema.optional(Schema.String), tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)), editorContext: Schema.optional(EditorContext),
-}).annotate({ identifier: "UserMessage" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type User = Types.DeepMutable<Schema.Schema.Type<typeof User>>
-
-export const Assistant = Schema.Struct({
-  ...messageBase, role: Schema.Literal("assistant"), time: Schema.Struct({ created: NonNegativeInt, completed: Schema.optional(NonNegativeInt) }),
-  error: Schema.optional(AssistantErrorSchema), parentID: MessageID, modelID: ModelID, providerID: ProviderID, mode: Schema.String, agent: Schema.String,
-  path: Schema.Struct({ cwd: Schema.String, root: Schema.String }), summary: Schema.optional(Schema.Boolean), cost: Schema.Finite,
-  tokens: Schema.Struct({ total: Schema.optional(NonNegativeInt), input: NonNegativeInt, output: NonNegativeInt, reasoning: NonNegativeInt, cache: Schema.Struct({ read: NonNegativeInt, write: NonNegativeInt }) }),
-  structured: Schema.optional(Schema.Any), variant: Schema.optional(Schema.String), finish: Schema.optional(Schema.String),
-}).annotate({ identifier: "AssistantMessage" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Assistant = Omit<Types.DeepMutable<Schema.Schema.Type<typeof Assistant>>, "error"> & { error?: import("./message-errors").AssistantError }
-
-const _Info = Schema.Union([User, Assistant]).annotate({ discriminator: "role", identifier: "Message" })
-export const Info = Object.assign(_Info, { zod: zod(_Info) as unknown as z.ZodType<User | Assistant> })
-export type Info = User | Assistant
-
-export const WithParts = Schema.Struct({ info: _Info, parts: Schema.Array(_Part) }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type WithParts = { info: Info; parts: import("./message-parts").Part[] }
-
-const UpdatedEventSchema = Schema.Struct({ sessionID: SessionID, info: _Info })
-const RemovedEventSchema = Schema.Struct({ sessionID: SessionID, messageID: MessageID })
-const PartUpdatedEventSchema = Schema.Struct({ sessionID: SessionID, part: _Part, time: NonNegativeInt })
-const PartRemovedEventSchema = Schema.Struct({ sessionID: SessionID, messageID: MessageID, partID: PartID })
-
-export const Event = {
-  Updated: SyncEvent.define({ type: "message.updated", version: 1, aggregate: "sessionID", schema: UpdatedEventSchema }),
-  Removed: SyncEvent.define({ type: "message.removed", version: 1, aggregate: "sessionID", schema: RemovedEventSchema }),
-  PartUpdated: SyncEvent.define({ type: "message.part.updated", version: 1, aggregate: "sessionID", schema: PartUpdatedEventSchema }),
-  PartDelta: BusEvent.define("message.part.delta", Schema.Struct({ sessionID: SessionID, messageID: MessageID, partID: PartID, field: Schema.String, delta: Schema.String })),
-  PartRemoved: SyncEvent.define({ type: "message.part.removed", version: 1, aggregate: "sessionID", schema: PartRemovedEventSchema }),
-}
-
-const Cursor = Schema.Struct({ id: MessageID, time: Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0)) })
-type Cursor = typeof Cursor.Type
-const decodeCursor = Schema.decodeUnknownSync(Cursor)
-export const cursor = {
-  encode(input: Cursor) { return Buffer.from(JSON.stringify(input)).toString("base64url") },
-  decode(input: string) { return decodeCursor(JSON.parse(Buffer.from(input, "base64url").toString("utf8"))) },
-}
+export * from "./message/message-types"

package/src/session/message-v2.ts

@@ -1,73 +1 @@
-export {
-  OutputLengthError,
-  AbortedError,
-  StructuredOutputError,
-  AuthError,
-  APIError,
-  ContextOverflowError,
-  OutputFormatText,
-  OutputFormatJsonSchema,
-  Format,
-  fromError,
-} from "./message-errors"
-export type { OutputFormat } from "./message-errors"
-
-export {
-  SnapshotPart,
-  PatchPart,
-  TextPart,
-  ReasoningPart,
-  FileSource,
-  SymbolSource,
-  ResourceSource,
-  FilePartSource,
-  FilePart,
-  AgentPart,
-  CompactionPart,
-  SubtaskPart,
-  RetryPart,
-  StepStartPart,
-  StepFinishPart,
-  ToolStatePending,
-  ToolStateRunning,
-  ToolStateCompleted,
-  ToolStateError,
-  ToolState,
-  ToolPart,
-  truncateToolOutput,
-  TextPartInput,
-  FilePartInput,
-  AgentPartInput,
-  SubtaskPartInput,
-  Part,
-} from "./message-parts"
-
-export {
-  EditorContext,
-  User,
-  Assistant,
-  Info,
-  WithParts,
-  Event,
-  cursor,
-} from "./message-types"
-
-export {
-  SYNTHETIC_ATTACHMENT_PROMPT,
-  isMedia,
-  stripPartMetadata,
-  stripMessageMetadata,
-  toModelMessagesEffect,
-  toModelMessages,
-} from "./message-transform"
-
-export {
-  page,
-  stream,
-  parts,
-  get,
-  filterCompacted,
-  filterCompactedEffect,
-} from "./message-query"
-
-export * as MessageV2 from "./message-v2"
+export * from "./message/message-v2"

package/src/session/message.ts

@@ -1,192 +1 @@
-import { Schema } from "effect"
-import { SessionID } from "./schema"
-import { ModelID, ProviderID } from "../provider/schema"
-import { zod } from "@/util/effect-zod"
-import { NonNegativeInt, withStatics } from "@/util/schema"
-import { namedSchemaError } from "@/util/named-schema-error"
-
-export const OutputLengthError = namedSchemaError("MessageOutputLengthError", {})
-export const AuthError = namedSchemaError("ProviderAuthError", {
-  providerID: Schema.String,
-  message: Schema.String,
-})
-
-const AuthErrorEffect = Schema.Struct({
-  name: Schema.Literal("ProviderAuthError"),
-  data: Schema.Struct({
-    providerID: Schema.String,
-    message: Schema.String,
-  }),
-})
-
-const OutputLengthErrorEffect = Schema.Struct({
-  name: Schema.Literal("MessageOutputLengthError"),
-  data: Schema.Struct({}),
-})
-
-const UnknownErrorEffect = Schema.Struct({
-  name: Schema.Literal("UnknownError"),
-  data: Schema.Struct({
-    message: Schema.String,
-  }),
-})
-
-export const ToolCall = Schema.Struct({
-  state: Schema.Literal("call"),
-  step: Schema.optional(NonNegativeInt),
-  toolCallId: Schema.String,
-  toolName: Schema.String,
-  args: Schema.Unknown,
-})
-  .annotate({ identifier: "ToolCall" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolCall = Schema.Schema.Type<typeof ToolCall>
-
-export const ToolPartialCall = Schema.Struct({
-  state: Schema.Literal("partial-call"),
-  step: Schema.optional(NonNegativeInt),
-  toolCallId: Schema.String,
-  toolName: Schema.String,
-  args: Schema.Unknown,
-})
-  .annotate({ identifier: "ToolPartialCall" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolPartialCall = Schema.Schema.Type<typeof ToolPartialCall>
-
-export const ToolResult = Schema.Struct({
-  state: Schema.Literal("result"),
-  step: Schema.optional(NonNegativeInt),
-  toolCallId: Schema.String,
-  toolName: Schema.String,
-  args: Schema.Unknown,
-  result: Schema.String,
-})
-  .annotate({ identifier: "ToolResult" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolResult = Schema.Schema.Type<typeof ToolResult>
-
-export const ToolInvocation = Schema.Union([ToolCall, ToolPartialCall, ToolResult])
-  .annotate({ identifier: "ToolInvocation", discriminator: "state" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolInvocation = Schema.Schema.Type<typeof ToolInvocation>
-
-export const TextPart = Schema.Struct({
-  type: Schema.Literal("text"),
-  text: Schema.String,
-})
-  .annotate({ identifier: "TextPart" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type TextPart = Schema.Schema.Type<typeof TextPart>
-
-export const ReasoningPart = Schema.Struct({
-  type: Schema.Literal("reasoning"),
-  text: Schema.String,
-  providerMetadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-})
-  .annotate({ identifier: "ReasoningPart" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>
-
-export const ToolInvocationPart = Schema.Struct({
-  type: Schema.Literal("tool-invocation"),
-  toolInvocation: ToolInvocation,
-})
-  .annotate({ identifier: "ToolInvocationPart" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolInvocationPart = Schema.Schema.Type<typeof ToolInvocationPart>
-
-export const SourceUrlPart = Schema.Struct({
-  type: Schema.Literal("source-url"),
-  sourceId: Schema.String,
-  url: Schema.String,
-  title: Schema.optional(Schema.String),
-  providerMetadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-})
-  .annotate({ identifier: "SourceUrlPart" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type SourceUrlPart = Schema.Schema.Type<typeof SourceUrlPart>
-
-export const FilePart = Schema.Struct({
-  type: Schema.Literal("file"),
-  mediaType: Schema.String,
-  filename: Schema.optional(Schema.String),
-  url: Schema.String,
-})
-  .annotate({ identifier: "FilePart" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type FilePart = Schema.Schema.Type<typeof FilePart>
-
-export const StepStartPart = Schema.Struct({
-  type: Schema.Literal("step-start"),
-})
-  .annotate({ identifier: "StepStartPart" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type StepStartPart = Schema.Schema.Type<typeof StepStartPart>
-
-export const MessagePart = Schema.Union([
-  TextPart,
-  ReasoningPart,
-  ToolInvocationPart,
-  SourceUrlPart,
-  FilePart,
-  StepStartPart,
-])
-  .annotate({ identifier: "MessagePart", discriminator: "type" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type MessagePart = Schema.Schema.Type<typeof MessagePart>
-
-export const Info = Schema.Struct({
-  id: Schema.String,
-  role: Schema.Literals(["user", "assistant"]),
-  parts: Schema.Array(MessagePart),
-  metadata: Schema.Struct({
-    time: Schema.Struct({
-      created: NonNegativeInt,
-      completed: Schema.optional(NonNegativeInt),
-    }),
-    error: Schema.optional(Schema.Union([AuthErrorEffect, UnknownErrorEffect, OutputLengthErrorEffect])),
-    sessionID: SessionID,
-    tool: Schema.Record(
-      Schema.String,
-      Schema.StructWithRest(
-        Schema.Struct({
-          title: Schema.String,
-          snapshot: Schema.optional(Schema.String),
-          time: Schema.Struct({
-            start: NonNegativeInt,
-            end: NonNegativeInt,
-          }),
-        }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-    assistant: Schema.optional(
-      Schema.Struct({
-        system: Schema.Array(Schema.String),
-        modelID: ModelID,
-        providerID: ProviderID,
-        path: Schema.Struct({
-          cwd: Schema.String,
-          root: Schema.String,
-        }),
-        cost: Schema.Finite,
-        summary: Schema.optional(Schema.Boolean),
-        tokens: Schema.Struct({
-          input: NonNegativeInt,
-          output: NonNegativeInt,
-          reasoning: NonNegativeInt,
-          cache: Schema.Struct({
-            read: NonNegativeInt,
-            write: NonNegativeInt,
-          }),
-        }),
-      }),
-    ),
-    snapshot: Schema.optional(Schema.String),
-  }).annotate({ identifier: "MessageMetadata" }),
-})
-  .annotate({ identifier: "Message" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = Schema.Schema.Type<typeof Info>
-
-export * as Message from "./message"
+export * from "./message/message"