refactor!: new package shared-chat-completion

Author: kwaa

docs/content/docs/get-started/tool.mdx

@@ -62,7 +62,7 @@ It accepts parameters as defined above and returns the string (other types may b
 ### Get weather
 
 ```ts twoslash
-import generateText from '@xsai/generate-text'
+import { generateText } from '@xsai/generate-text'
 import { tool } from '@xsai/tool'
 import { description, object, pipe, string } from 'valibot'
 

packages/generate-object/package.json

@@ -24,9 +24,7 @@
   ],
   "scripts": {
     "build": "pkgroll",
-    "build:watch": "pkgroll --watch",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "build:watch": "pkgroll --watch"
   },
   "dependencies": {
     "@typeschema/main": "catalog:",

packages/generate-object/src/index.ts

@@ -1 +1,47 @@
-export { generateObject, generateObject as default, type GenerateObjectOptions, type GenerateObjectResult } from './utils/generate-object'
+import { type Infer, type Schema, toJSONSchema } from '@typeschema/main'
+import { generateText, type GenerateTextOptions, type GenerateTextResult } from '@xsai/generate-text'
+import { clean } from '@xsai/shared'
+
+export interface GenerateObjectOptions<T extends Schema> extends GenerateTextOptions {
+  schema: T
+  schemaDescription?: string
+  schemaName?: string
+}
+
+export interface GenerateObjectResult<T extends Schema> extends Omit<GenerateTextResult, 'text'> {
+  object: Infer<T>
+}
+
+/**
+ * @experimental
+ * WIP, test failed
+ * @remarks Ollama doesn't support this, see {@link https://github.com/ollama/ollama/issues/6473}
+ */
+export const generateObject = async <T extends Schema>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>> =>
+  await generateText(clean({
+    ...options,
+    responseFormat: {
+      jsonSchema: {
+        description: options.schemaDescription,
+        name: options.schemaName ?? 'json_schema',
+        schema: await toJSONSchema(options.schema)
+          .then(json => clean({
+            ...json,
+            $schema: undefined,
+          })),
+        strict: true,
+      },
+      type: 'json_schema',
+    },
+    schema: undefined,
+    schemaDescription: undefined,
+    schemaName: undefined,
+  }))
+    .then(({ finishReason, text, usage }) => ({
+      finishReason,
+      // TODO: import { validate } from '@typeschema/main'
+      object: JSON.parse(text || '{}'),
+      usage,
+    }))
+
+export default generateObject

packages/generate-object/src/utils/generate-object.ts

@@ -29,6 +29,6 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@xsai/shared": "workspace:"
+    "@xsai/shared-chat-completion": "workspace:"
   }
 }

packages/generate-object/test/index.test.ts

@@ -1,2 +1,80 @@
-export type * from './types'
-export { generateText, generateText as default, type GenerateTextOptions, type GenerateTextResponseUsage, type GenerateTextResult } from './utils/generate-text'
+import { type AssistantMessageResponse, chatCompletion, type ChatCompletionOptions, type FinishReason, type Message, type Tool } from '@xsai/shared-chat-completion'
+
+export interface GenerateTextOptions extends ChatCompletionOptions {}
+
+interface GenerateTextResponse {
+  choices: {
+    finish_reason: FinishReason
+    index: number
+    message: AssistantMessageResponse
+  }[]
+  created: number
+  id: string
+  model: string
+  object: 'chat.completion'
+  system_fingerprint: string
+  usage: GenerateTextResponseUsage
+}
+
+export interface GenerateTextResponseUsage {
+  completion_tokens: number
+  prompt_tokens: number
+  total_tokens: number
+}
+
+export interface GenerateTextResult {
+  finishReason: FinishReason
+  text?: string
+  usage: GenerateTextResponseUsage
+}
+
+export const generateText = async (options: GenerateTextOptions): Promise<GenerateTextResult> =>
+  await chatCompletion({
+    ...options,
+    stream: false,
+  })
+    .then(async (res) => {
+      if (!res.ok) {
+        const error = await res.text()
+        throw new Error(`Error(${res.status}): ${error}`)
+      }
+      else {
+        return res.json() as Promise<GenerateTextResponse>
+      }
+    })
+    .then(async ({ choices, usage }) => {
+      const { finish_reason, message } = choices[0]
+
+      if (!!message.content || !message.tool_calls) {
+        return {
+          finishReason: finish_reason,
+          text: message.content,
+          usage,
+        }
+      }
+
+      const toolMessages = []
+
+      for (const toolCall of message.tool_calls) {
+        const tool = (options.tools as Tool[]).find(tool => tool.function.name === toolCall.function.name)!
+        const toolResult = await tool.execute(JSON.parse(toolCall.function.arguments))
+        const toolMessage = {
+          content: toolResult,
+          role: 'tool',
+          tool_call_id: toolCall.id,
+        } satisfies Message
+
+        toolMessages.push(toolMessage)
+      }
+
+      return await generateText({
+        ...options,
+        messages: [
+          ...options.messages,
+          { ...message, content: message.content! },
+          ...toolMessages,
+        ],
+      })
+    })
+
+export default generateText