alchemylab-opencode 1.0.0

package/packages/opencode/src/session/message.ts

@@ -0,0 +1,191 @@
+import z from "zod"
+import { SessionID } from "./schema"
+import { ModelID, ProviderID } from "../provider/schema"
+import { NamedError } from "@opencode-ai/util/error"
+
+export namespace Message {
+  export const OutputLengthError = NamedError.create("MessageOutputLengthError", z.object({}))
+  export const AuthError = NamedError.create(
+    "ProviderAuthError",
+    z.object({
+      providerID: z.string(),
+      message: z.string(),
+    }),
+  )
+
+  export const ToolCall = z
+    .object({
+      state: z.literal("call"),
+      step: z.number().optional(),
+      toolCallId: z.string(),
+      toolName: z.string(),
+      args: z.custom<Required<unknown>>(),
+    })
+    .meta({
+      ref: "ToolCall",
+    })
+  export type ToolCall = z.infer<typeof ToolCall>
+
+  export const ToolPartialCall = z
+    .object({
+      state: z.literal("partial-call"),
+      step: z.number().optional(),
+      toolCallId: z.string(),
+      toolName: z.string(),
+      args: z.custom<Required<unknown>>(),
+    })
+    .meta({
+      ref: "ToolPartialCall",
+    })
+  export type ToolPartialCall = z.infer<typeof ToolPartialCall>
+
+  export const ToolResult = z
+    .object({
+      state: z.literal("result"),
+      step: z.number().optional(),
+      toolCallId: z.string(),
+      toolName: z.string(),
+      args: z.custom<Required<unknown>>(),
+      result: z.string(),
+    })
+    .meta({
+      ref: "ToolResult",
+    })
+  export type ToolResult = z.infer<typeof ToolResult>
+
+  export const ToolInvocation = z.discriminatedUnion("state", [ToolCall, ToolPartialCall, ToolResult]).meta({
+    ref: "ToolInvocation",
+  })
+  export type ToolInvocation = z.infer<typeof ToolInvocation>
+
+  export const TextPart = z
+    .object({
+      type: z.literal("text"),
+      text: z.string(),
+    })
+    .meta({
+      ref: "TextPart",
+    })
+  export type TextPart = z.infer<typeof TextPart>
+
+  export const ReasoningPart = z
+    .object({
+      type: z.literal("reasoning"),
+      text: z.string(),
+      providerMetadata: z.record(z.string(), z.any()).optional(),
+    })
+    .meta({
+      ref: "ReasoningPart",
+    })
+  export type ReasoningPart = z.infer<typeof ReasoningPart>
+
+  export const ToolInvocationPart = z
+    .object({
+      type: z.literal("tool-invocation"),
+      toolInvocation: ToolInvocation,
+    })
+    .meta({
+      ref: "ToolInvocationPart",
+    })
+  export type ToolInvocationPart = z.infer<typeof ToolInvocationPart>
+
+  export const SourceUrlPart = z
+    .object({
+      type: z.literal("source-url"),
+      sourceId: z.string(),
+      url: z.string(),
+      title: z.string().optional(),
+      providerMetadata: z.record(z.string(), z.any()).optional(),
+    })
+    .meta({
+      ref: "SourceUrlPart",
+    })
+  export type SourceUrlPart = z.infer<typeof SourceUrlPart>
+
+  export const FilePart = z
+    .object({
+      type: z.literal("file"),
+      mediaType: z.string(),
+      filename: z.string().optional(),
+      url: z.string(),
+    })
+    .meta({
+      ref: "FilePart",
+    })
+  export type FilePart = z.infer<typeof FilePart>
+
+  export const StepStartPart = z
+    .object({
+      type: z.literal("step-start"),
+    })
+    .meta({
+      ref: "StepStartPart",
+    })
+  export type StepStartPart = z.infer<typeof StepStartPart>
+
+  export const MessagePart = z
+    .discriminatedUnion("type", [TextPart, ReasoningPart, ToolInvocationPart, SourceUrlPart, FilePart, StepStartPart])
+    .meta({
+      ref: "MessagePart",
+    })
+  export type MessagePart = z.infer<typeof MessagePart>
+
+  export const Info = z
+    .object({
+      id: z.string(),
+      role: z.enum(["user", "assistant"]),
+      parts: z.array(MessagePart),
+      metadata: z
+        .object({
+          time: z.object({
+            created: z.number(),
+            completed: z.number().optional(),
+          }),
+          error: z
+            .discriminatedUnion("name", [AuthError.Schema, NamedError.Unknown.Schema, OutputLengthError.Schema])
+            .optional(),
+          sessionID: SessionID.zod,
+          tool: z.record(
+            z.string(),
+            z
+              .object({
+                title: z.string(),
+                snapshot: z.string().optional(),
+                time: z.object({
+                  start: z.number(),
+                  end: z.number(),
+                }),
+              })
+              .catchall(z.any()),
+          ),
+          assistant: z
+            .object({
+              system: z.string().array(),
+              modelID: ModelID.zod,
+              providerID: ProviderID.zod,
+              path: z.object({
+                cwd: z.string(),
+                root: z.string(),
+              }),
+              cost: z.number(),
+              summary: z.boolean().optional(),
+              tokens: z.object({
+                input: z.number(),
+                output: z.number(),
+                reasoning: z.number(),
+                cache: z.object({
+                  read: z.number(),
+                  write: z.number(),
+                }),
+              }),
+            })
+            .optional(),
+          snapshot: z.string().optional(),
+        })
+        .meta({ ref: "MessageMetadata" }),
+    })
+    .meta({
+      ref: "Message",
+    })
+  export type Info = z.infer<typeof Info>
+}

package/packages/opencode/src/session/overflow.ts

@@ -0,0 +1,22 @@
+import type { Config } from "@/config/config"
+import type { Provider } from "@/provider/provider"
+import { ProviderTransform } from "@/provider/transform"
+import type { MessageV2 } from "./message-v2"
+
+const COMPACTION_BUFFER = 20_000
+
+export function isOverflow(input: { cfg: Config.Info; tokens: MessageV2.Assistant["tokens"]; model: Provider.Model }) {
+  if (input.cfg.compaction?.auto === false) return false
+  const context = input.model.limit.context
+  if (context === 0) return false
+
+  const count =
+    input.tokens.total || input.tokens.input + input.tokens.output + input.tokens.cache.read + input.tokens.cache.write
+
+  const reserved =
+    input.cfg.compaction?.reserved ?? Math.min(COMPACTION_BUFFER, ProviderTransform.maxOutputTokens(input.model))
+  const usable = input.model.limit.input
+    ? input.model.limit.input - reserved
+    : context - ProviderTransform.maxOutputTokens(input.model)
+  return count >= usable
+}