@link-assistant/agent 0.0.8

package/src/provider/transform.ts

@@ -0,0 +1,241 @@
+import type { ModelMessage } from "ai"
+import { unique } from "remeda"
+import type { JSONSchema } from "zod/v4/core"
+
+export namespace ProviderTransform {
+  function normalizeMessages(msgs: ModelMessage[], providerID: string, modelID: string): ModelMessage[] {
+    if (modelID.includes("claude")) {
+      return msgs.map((msg) => {
+        if ((msg.role === "assistant" || msg.role === "tool") && Array.isArray(msg.content)) {
+          msg.content = msg.content.map((part) => {
+            if ((part.type === "tool-call" || part.type === "tool-result") && "toolCallId" in part) {
+              return {
+                ...part,
+                toolCallId: part.toolCallId.replace(/[^a-zA-Z0-9_-]/g, "_"),
+              }
+            }
+            return part
+          })
+        }
+        return msg
+      })
+    }
+    if (providerID === "mistral" || modelID.toLowerCase().includes("mistral")) {
+      const result: ModelMessage[] = []
+      for (let i = 0; i < msgs.length; i++) {
+        const msg = msgs[i]
+        const prevMsg = msgs[i - 1]
+        const nextMsg = msgs[i + 1]
+
+        if ((msg.role === "assistant" || msg.role === "tool") && Array.isArray(msg.content)) {
+          msg.content = msg.content.map((part) => {
+            if ((part.type === "tool-call" || part.type === "tool-result") && "toolCallId" in part) {
+              // Mistral requires alphanumeric tool call IDs with exactly 9 characters
+              const normalizedId = part.toolCallId
+                .replace(/[^a-zA-Z0-9]/g, "") // Remove non-alphanumeric characters
+                .substring(0, 9) // Take first 9 characters
+                .padEnd(9, "0") // Pad with zeros if less than 9 characters
+
+              return {
+                ...part,
+                toolCallId: normalizedId,
+              }
+            }
+            return part
+          })
+        }
+
+        result.push(msg)
+
+        // Fix message sequence: tool messages cannot be followed by user messages
+        if (msg.role === "tool" && nextMsg?.role === "user") {
+          result.push({
+            role: "assistant",
+            content: [
+              {
+                type: "text",
+                text: "Done.",
+              },
+            ],
+          })
+        }
+      }
+      return result
+    }
+
+    return msgs
+  }
+
+  function applyCaching(msgs: ModelMessage[], providerID: string): ModelMessage[] {
+    const system = msgs.filter((msg) => msg.role === "system").slice(0, 2)
+    const final = msgs.filter((msg) => msg.role !== "system").slice(-2)
+
+    const providerOptions = {
+      anthropic: {
+        cacheControl: { type: "ephemeral" },
+      },
+      openrouter: {
+        cache_control: { type: "ephemeral" },
+      },
+      bedrock: {
+        cachePoint: { type: "ephemeral" },
+      },
+      openaiCompatible: {
+        cache_control: { type: "ephemeral" },
+      },
+    }
+
+    for (const msg of unique([...system, ...final])) {
+      const shouldUseContentOptions = providerID !== "anthropic" && Array.isArray(msg.content) && msg.content.length > 0
+
+      if (shouldUseContentOptions) {
+        const lastContent = msg.content[msg.content.length - 1]
+        if (lastContent && typeof lastContent === "object") {
+          lastContent.providerOptions = {
+            ...lastContent.providerOptions,
+            ...providerOptions,
+          }
+          continue
+        }
+      }
+
+      msg.providerOptions = {
+        ...msg.providerOptions,
+        ...providerOptions,
+      }
+    }
+
+    return msgs
+  }
+
+  export function message(msgs: ModelMessage[], providerID: string, modelID: string) {
+    msgs = normalizeMessages(msgs, providerID, modelID)
+    if (providerID === "anthropic" || modelID.includes("anthropic") || modelID.includes("claude")) {
+      msgs = applyCaching(msgs, providerID)
+    }
+
+    return msgs
+  }
+
+  export function temperature(_providerID: string, modelID: string) {
+    if (modelID.toLowerCase().includes("qwen")) return 0.55
+    if (modelID.toLowerCase().includes("claude")) return undefined
+    if (modelID.toLowerCase().includes("gemini-3-pro")) return 1.0
+    return 0
+  }
+
+  export function topP(_providerID: string, modelID: string) {
+    if (modelID.toLowerCase().includes("qwen")) return 1
+    return undefined
+  }
+
+  export function options(
+    providerID: string,
+    modelID: string,
+    npm: string,
+    sessionID: string,
+  ): Record<string, any> | undefined {
+    const result: Record<string, any> = {}
+
+    if (providerID === "openai") {
+      result["promptCacheKey"] = sessionID
+    }
+
+    if (modelID.includes("gpt-5") && !modelID.includes("gpt-5-chat")) {
+      if (modelID.includes("codex")) {
+        result["store"] = false
+      }
+
+      if (!modelID.includes("codex") && !modelID.includes("gpt-5-pro")) {
+        result["reasoningEffort"] = "medium"
+      }
+
+      if (modelID.endsWith("gpt-5.1") && providerID !== "azure") {
+        result["textVerbosity"] = "low"
+      }
+
+      if (providerID === "opencode") {
+        result["promptCacheKey"] = sessionID
+        result["include"] = ["reasoning.encrypted_content"]
+        result["reasoningSummary"] = "auto"
+      }
+    }
+    return result
+  }
+
+  export function providerOptions(npm: string | undefined, providerID: string, options: { [x: string]: any }) {
+    switch (npm) {
+      case "@ai-sdk/openai":
+      case "@ai-sdk/azure":
+        return {
+          ["openai" as string]: options,
+        }
+      case "@ai-sdk/amazon-bedrock":
+        return {
+          ["bedrock" as string]: options,
+        }
+      case "@ai-sdk/anthropic":
+        return {
+          ["anthropic" as string]: options,
+        }
+      case "@ai-sdk/gateway":
+        return {
+          ["gateway" as string]: options,
+        }
+      default:
+        return {
+          [providerID]: options,
+        }
+    }
+  }
+
+  export function maxOutputTokens(
+    npm: string,
+    options: Record<string, any>,
+    modelLimit: number,
+    globalLimit: number,
+  ): number {
+    const modelCap = modelLimit || globalLimit
+    const standardLimit = Math.min(modelCap, globalLimit)
+
+    if (npm === "@ai-sdk/anthropic") {
+      const thinking = options?.["thinking"]
+      const budgetTokens = typeof thinking?.["budgetTokens"] === "number" ? thinking["budgetTokens"] : 0
+      const enabled = thinking?.["type"] === "enabled"
+      if (enabled && budgetTokens > 0) {
+        // Return text tokens so that text + thinking <= model cap, preferring 32k text when possible.
+        if (budgetTokens + standardLimit <= modelCap) {
+          return standardLimit
+        }
+        return modelCap - budgetTokens
+      }
+    }
+
+    return standardLimit
+  }
+
+  export function schema(_providerID: string, _modelID: string, schema: JSONSchema.BaseSchema) {
+    /*
+    if (["openai", "azure"].includes(providerID)) {
+      if (schema.type === "object" && schema.properties) {
+        for (const [key, value] of Object.entries(schema.properties)) {
+          if (schema.required?.includes(key)) continue
+          schema.properties[key] = {
+            anyOf: [
+              value as JSONSchema.JSONSchema,
+              {
+                type: "null",
+              },
+            ],
+          }
+        }
+      }
+    }
+
+    if (providerID === "google") {
+    }
+    */
+
+    return schema
+  }
+}

package/src/server/project.ts

@@ -0,0 +1,48 @@
+import { Hono } from "hono"
+import { describeRoute } from "hono-openapi"
+import { resolver } from "hono-openapi"
+import { Instance } from "../project/instance"
+import { Project } from "../project/project"
+
+export const ProjectRoute = new Hono()
+  .get(
+    "/",
+    describeRoute({
+      description: "List all projects",
+      operationId: "project.list",
+      responses: {
+        200: {
+          description: "List of projects",
+          content: {
+            "application/json": {
+              schema: resolver(Project.Info.array()),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      const projects = await Project.list()
+      return c.json(projects)
+    },
+  )
+  .get(
+    "/current",
+    describeRoute({
+      description: "Get the current project",
+      operationId: "project.current",
+      responses: {
+        200: {
+          description: "Current project",
+          content: {
+            "application/json": {
+              schema: resolver(Project.Info),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      return c.json(Instance.project)
+    },
+  )

package/src/server/server.ts

@@ -0,0 +1,249 @@
+import { Log } from "../util/log"
+import { describeRoute, validator, resolver } from "hono-openapi"
+import { Hono } from "hono"
+import { cors } from "hono/cors"
+import { stream } from "hono/streaming"
+import { Session } from "../session"
+import z from "zod"
+import { NamedError } from "../util/error"
+import { MessageV2 } from "../session/message-v2"
+import { Instance } from "../project/instance"
+import { SessionPrompt } from "../session/prompt"
+import { Storage } from "../storage/storage"
+import type { ContentfulStatusCode } from "hono/utils/http-status"
+import { lazy } from "../util/lazy"
+
+const ERRORS = {
+  400: {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: resolver(
+          z
+            .object({
+              data: z.any(),
+              errors: z.array(z.record(z.string(), z.any())),
+              success: z.literal(false),
+            })
+            .meta({
+              ref: "BadRequestError",
+            }),
+        ),
+      },
+    },
+  },
+  404: {
+    description: "Not found",
+    content: {
+      "application/json": {
+        schema: resolver(Storage.NotFoundError.Schema),
+      },
+    },
+  },
+} as const
+
+function errors(...codes: number[]) {
+  return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))
+}
+
+export namespace Server {
+  const log = Log.create({ service: "server" })
+
+  const app = new Hono()
+  export const App = lazy(() =>
+    app
+      .onError((err, c) => {
+        log.error("failed", {
+          error: err,
+        })
+        if (err instanceof NamedError) {
+          let status: ContentfulStatusCode
+          if (err instanceof Storage.NotFoundError) status = 404
+          else status = 500
+          return c.json(err.toObject(), { status })
+        }
+        const message = err instanceof Error && err.stack ? err.stack : err.toString()
+        return c.json(new NamedError.Unknown({ message }).toObject(), {
+          status: 500,
+        })
+      })
+      .use(async (c, next) => {
+        log.info("request", {
+          method: c.req.method,
+          path: c.req.path,
+        })
+        const timer = log.time("request", {
+          method: c.req.method,
+          path: c.req.path,
+        })
+        await next()
+        timer.stop()
+      })
+      .use(cors())
+      .get("/health", (c) => {
+        return c.json({ status: "ok" })
+      })
+      .post(
+        "/session",
+        describeRoute({
+          description: "Create a new session",
+          operationId: "session.create",
+          responses: {
+            200: {
+              description: "Created session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        validator("json", z.object({ title: z.string().optional() }).optional()),
+        async (c) => {
+          const body = c.req.valid("json") || {}
+          const session = await Session.create({
+            title: body.title,
+          })
+          return c.json(session)
+        },
+      )
+      .get(
+        "/session",
+        describeRoute({
+          description: "List all sessions",
+          operationId: "session.list",
+          responses: {
+            200: {
+              description: "List of sessions",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info.array()),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          const sessions = await Session.list()
+          return c.json(sessions)
+        },
+      )
+      .get(
+        "/session/:id",
+        describeRoute({
+          description: "Get a session",
+          operationId: "session.get",
+          responses: {
+            200: {
+              description: "Session info",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+            ...errors(404),
+          },
+        }),
+        validator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          const session = await Session.get(c.req.valid("param").id)
+          return c.json(session)
+        },
+      )
+      .post(
+        "/session/:id/message",
+        describeRoute({
+          description: "Create and send a new message to a session",
+          operationId: "session.prompt",
+          responses: {
+            200: {
+              description: "Created message",
+              content: {
+                "application/json": {
+                  schema: resolver(
+                    z.object({
+                      info: MessageV2.Assistant,
+                      parts: MessageV2.Part.array(),
+                    }),
+                  ),
+                },
+              },
+            },
+            ...errors(400, 404),
+          },
+        }),
+        validator(
+          "param",
+          z.object({
+            id: z.string().meta({ description: "Session ID" }),
+          }),
+        ),
+        validator("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
+        async (c) => {
+          c.status(200)
+          c.header("Content-Type", "application/json")
+          return stream(c, async (stream) => {
+            const sessionID = c.req.valid("param").id
+            const body = c.req.valid("json")
+            const msg = await SessionPrompt.prompt({ ...body, sessionID })
+            stream.write(JSON.stringify(msg))
+          })
+        },
+      )
+      .get(
+        "/session/:id/message",
+        describeRoute({
+          description: "List messages for a session",
+          operationId: "session.messages",
+          responses: {
+            200: {
+              description: "List of messages",
+              content: {
+                "application/json": {
+                  schema: resolver(MessageV2.WithParts.array()),
+                },
+              },
+            },
+            ...errors(400, 404),
+          },
+        }),
+        validator(
+          "param",
+          z.object({
+            id: z.string().meta({ description: "Session ID" }),
+          }),
+        ),
+        validator(
+          "query",
+          z.object({
+            limit: z.coerce.number().optional(),
+          }),
+        ),
+        async (c) => {
+          const query = c.req.valid("query")
+          const messages = await Session.messages({
+            sessionID: c.req.valid("param").id,
+            limit: query.limit,
+          })
+          return c.json(messages)
+        },
+      ),
+  )
+
+  export function listen(opts: { port: number; hostname: string }) {
+    const server = Bun.serve({
+      port: opts.port,
+      hostname: opts.hostname,
+      idleTimeout: 0,
+      fetch: App().fetch,
+    })
+    return server
+  }
+}