@dxos/assistant 0.8.1 → 0.8.2-main.2f9c567

package/src/ai-service/types.ts

@@ -2,18 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
-import { Tool, Message, type MessageContentBlock, SpaceIdSchema } from '@dxos/artifact';
-import { ObjectId } from '@dxos/echo-schema';
+import { Tool, Message, type MessageContentBlock } from '@dxos/artifact';
+import { type ObjectId } from '@dxos/echo-schema';
 
 import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from './defs';
 
 export const createArtifactElement = (id: ObjectId) => `<artifact id=${id} />`;
 
-export const LLMModel = S.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
+export const LLMModel = Schema.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
 
-export type LLMModel = S.Schema.Type<typeof LLMModel>;
+export type LLMModel = Schema.Schema.Type<typeof LLMModel>;
 
 export const ToolTypes = Object.freeze({
   // TODO(dmaretskyi): Not implemented yet.
@@ -24,38 +24,47 @@ export const ToolTypes = Object.freeze({
 /**
  * Client GPT request.
  */
-export const GenerateRequest = S.Struct({
-  spaceId: S.optional(SpaceIdSchema),
-  threadId: S.optional(ObjectId),
-
+export const GenerateRequest = Schema.Struct({
   /**
    * Preferred model or system default.
    */
-  model: S.optional(LLMModel),
+  model: Schema.optional(LLMModel),
 
   /**
    * Tools available for the LLM.
    */
-  tools: S.optional(S.Array(Tool).pipe(S.mutable)),
+  tools: Schema.optional(Schema.Array(Tool).pipe(Schema.mutable)),
 
   /**
    * System instructions to the LLM.
    */
-  systemPrompt: S.optional(S.String),
+  systemPrompt: Schema.optional(Schema.String),
 
   /**
    * History of messages to include in the context window.
    */
   // TODO(burdon): Rename messages.
-  history: S.optional(S.Array(Message)),
+  history: Schema.optional(Schema.Array(Message)),
 
   /**
    * Current request.
    */
-  prompt: S.optional(Message),
+  prompt: Schema.optional(Message),
 });
+export type GenerateRequest = Schema.Schema.Type<typeof GenerateRequest>;
+
+/**
+ * Non-streaming response.
+ */
+export const GenerateResponse = Schema.Struct({
+  messages: Schema.Array(Message),
 
-export type GenerateRequest = S.Schema.Type<typeof GenerateRequest>;
+  /**
+   * Number of tokens used in the response.
+   */
+  tokenCount: Schema.optional(Schema.Number),
+});
+export type GenerateResponse = Schema.Schema.Type<typeof GenerateResponse>;
 
 /**
  * Server-Sent Events (SSE) stream from the AI service.

package/src/bin/chat.ts

@@ -19,7 +19,7 @@ import {
   createSystemPrompt,
   createTestData,
   Contact,
-  Org,
+  Organization,
   Project,
   Task,
 } from '../testing';
@@ -33,7 +33,7 @@ const dataSource = createTestData();
 
 const cypherTool = createCypherTool(dataSource);
 
-const schemaTypes = [Org, Project, Task, Contact];
+const schemaTypes = [Organization, Project, Task, Contact];
 
 const spaceId = SpaceId.random();
 const threadId = ObjectId.random();
@@ -46,7 +46,6 @@ while (true) {
       message: 'Enter a message:',
     },
   ]);
-  await client.appendMessages([createUserMessage(spaceId, threadId, prompt.message)]);
 
   await runLLM({
     model: DEFAULT_EDGE_MODEL,
@@ -61,6 +60,7 @@ while (true) {
       },
     ],
     client,
+    history: [createUserMessage(spaceId, threadId, prompt.message)],
     logger: createLogger({
       stream: true,
       filter: (e) => {

package/src/conversation/conversation.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 import { describe, test } from 'vitest';
 
 import { createUserMessage, defineTool, ToolResult } from '@dxos/artifact';
@@ -40,8 +40,8 @@ describe.skip('Conversation tests', () => {
     const custodian = defineTool('testing', {
       name: 'custodian',
       description: 'Custodian can tell you the password if you say the magic word',
-      schema: S.Struct({
-        magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+      schema: Schema.Struct({
+        magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
       }),
       execute: async ({ magicWord }) => {
         if (magicWord === 'pretty please') {

package/src/conversation/conversation.ts

@@ -3,7 +3,7 @@
 //
 
 import { type Tool, ToolResult, Message } from '@dxos/artifact';
-import { createStatic, ObjectId } from '@dxos/echo-schema';
+import { create, ObjectId } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -43,10 +43,8 @@ export const runLLM = async (params: CreateLLMConversationParams) => {
   const generate = async () => {
     log('llm generate', { tools: params.tools });
     const beginTs = Date.now();
-    const stream = await params.client.exec({
+    const stream = await params.client.execStream({
       model: params.model,
-      spaceId: params.spaceId,
-      threadId: params.threadId,
       history,
       systemPrompt: params.system,
       tools: params.tools as any,
@@ -88,8 +86,6 @@ export const runLLM = async (params: CreateLLMConversationParams) => {
           log.warn('tool error', { message: toolResult.message });
           const resultMessage: Message = {
             id: ObjectId.random(),
-            spaceId: params.spaceId,
-            threadId: params.threadId,
             role: 'user',
             content: [
               {
@@ -110,8 +106,6 @@ export const runLLM = async (params: CreateLLMConversationParams) => {
           log('tool success', { result: toolResult.result });
           const resultMessage: Message = {
             id: ObjectId.random(),
-            spaceId: params.spaceId,
-            threadId: params.threadId,
             role: 'user',
             content: [
               {
@@ -175,7 +169,7 @@ export const runTools = async ({ message, tools, extensions }: RunToolsOptions):
   const toolCall = toolCalls[0];
   const tool = tools.find((tool) => tool.name === toolCall.name);
   if (!tool) {
-    const resultMessage = createStatic(Message, {
+    const resultMessage = create(Message, {
       role: 'user',
       content: [
         {
@@ -206,7 +200,7 @@ export const runTools = async ({ message, tools, extensions }: RunToolsOptions):
   switch (toolResult.kind) {
     case 'error': {
       log('tool error', { message: toolResult.message });
-      const resultMessage = createStatic(Message, {
+      const resultMessage = create(Message, {
         role: 'user',
         content: [
           {
@@ -227,7 +221,7 @@ export const runTools = async ({ message, tools, extensions }: RunToolsOptions):
 
     case 'success': {
       log('tool success', { result: toolResult.result });
-      const resultMessage = createStatic(Message, {
+      const resultMessage = create(Message, {
         role: 'user',
         content: [
           {

package/src/conversation/types.ts

@@ -2,17 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 import { type Message, type MessageContentBlock } from '@dxos/artifact';
 import { toJsonSchema, JsonSchemaType, ObjectId } from '@dxos/echo-schema';
-import type { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-export const createUserMessage = (spaceId: SpaceId, threadId: ObjectId, text: string): Message => ({
+export const createUserMessage = (text: string): Message => ({
   id: ObjectId.random(),
-  spaceId,
-  threadId,
   role: 'user',
   content: [{ type: 'text', text }],
 });
@@ -20,11 +17,11 @@ export const createUserMessage = (spaceId: SpaceId, threadId: ObjectId, text: st
 /**
  * @deprecated Use {@link LLMTool} instead.
  */
-export const ToolDefinition = S.Struct({
-  name: S.String,
-  description: S.String,
+export const ToolDefinition = Schema.Struct({
+  name: Schema.String,
+  description: Schema.String,
   parameters: JsonSchemaType,
-  execute: S.Any,
+  execute: Schema.Any,
 });
 
 /**
@@ -86,14 +83,14 @@ export const ToolResult = Object.freeze({
   Break: (result: unknown): ToolResult => ({ kind: 'break', result }),
 });
 
-export type DefineToolParams<Params extends S.Schema.AnyNoContext> = {
+export type DefineToolParams<Params extends Schema.Schema.AnyNoContext> = {
   name: string;
   description: string;
   schema: Params;
-  execute: (params: S.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
+  execute: (params: Schema.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
 };
 
-export const defineTool = <Params extends S.Schema.AnyNoContext>({
+export const defineTool = <Params extends Schema.Schema.AnyNoContext>({
   name,
   description,
   schema,
@@ -104,7 +101,7 @@ export const defineTool = <Params extends S.Schema.AnyNoContext>({
     description,
     parameters: toFunctionParameterSchema(schema),
     execute: (params, context) => {
-      const sanitized = S.decodeSync(schema)(params);
+      const sanitized = Schema.decodeSync(schema)(params);
       return execute(sanitized, context);
     },
   };
@@ -113,7 +110,7 @@ export const defineTool = <Params extends S.Schema.AnyNoContext>({
 /**
  * Adapts schems to be able to pass to AI providers.
  */
-const toFunctionParameterSchema = (schema: S.Schema.All) => {
+const toFunctionParameterSchema = (schema: Schema.Schema.All) => {
   const jsonSchema = toJsonSchema(schema);
   log('tool schema', { jsonSchema });
   delete jsonSchema.anyOf;

package/src/cypher/combinators.test.ts

@@ -77,7 +77,7 @@ describe('Cypher Combinators', () => {
   test('match clause', ({ expect }) => {
     testParser(matchClause, 'MATCH (n:Person)');
     testParser(matchClause, 'MATCH (n:Person)-[r:KNOWS]->(m:Person)');
-    testParser(matchClause, 'MATCH (o:Org)-[:HAS_EMPLOYEE]->(e:Employee)');
+    testParser(matchClause, 'MATCH (o:Organization)-[:HAS_EMPLOYEE]->(e:Employee)');
   });
 
   test('where clause', ({ expect }) => {
@@ -116,15 +116,15 @@ describe('Cypher Combinators', () => {
     );
     testParser(
       cypherQuery,
-      'MATCH (o:Org)-[:HAS_EMPLOYEE]->(e:Employee)-[:WORKS_ON]->(p:Project) WHERE o.name = "DXOS" AND p.name = "Composer" RETURN e.name, e.id, p.name, p.id',
+      'MATCH (o:Organization)-[:HAS_EMPLOYEE]->(e:Employee)-[:WORKS_ON]->(p:Project) WHERE o.name = "DXOS" AND p.name = "Composer" RETURN e.name, e.id, p.name, p.id',
     );
     testParser(
       cypherQuery,
-      'MATCH (n:Org {name: "DXOS"})-[:HAS_EMPLOYEE]->(m:Employee)<-[:WORKS_ON]-(p:Project {name: "Composer"}) RETURN m.name AS employee',
+      'MATCH (n:Organization {name: "DXOS"})-[:HAS_EMPLOYEE]->(m:Employee)<-[:WORKS_ON]-(p:Project {name: "Composer"}) RETURN m.name AS employee',
     );
     testParser(
       cypherQuery,
-      "MATCH (org:Org {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
+      "MATCH (org:Organization {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
     );
   });
 });

package/src/cypher/echo-data-source.ts

@@ -2,10 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
+import { type Schema } from 'effect';
+
 import { raise } from '@dxos/debug';
-import { type EchoDatabase, Filter, type ReactiveEchoObject } from '@dxos/echo-db';
-import { type S, getSchemaTypename, StoredSchema, toJsonSchema } from '@dxos/echo-schema';
-import { getSchema } from '@dxos/live-object';
+import { type EchoDatabase, Filter, type AnyLiveObject } from '@dxos/echo-db';
+import { getSchema, getSchemaTypename, StoredSchema, toJsonSchema } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
 import type { DataSource, Node, Relationship } from './query-executor';
@@ -63,7 +64,7 @@ export class EchoDataSource implements DataSource {
     ).flat();
   }
 
-  private async _getAllSchema(): Promise<S.Schema.AnyNoContext[]> {
+  private async _getAllSchema(): Promise<Schema.Schema.AnyNoContext[]> {
     return [
       ...(await this._db.schemaRegistry.query().run()),
       // TODO(dmaretskyi): Remove once we can serialize recursive schema.
@@ -71,7 +72,7 @@ export class EchoDataSource implements DataSource {
     ].filter((schema) => getSchemaTypename(schema) !== StoredSchema.typename);
   }
 
-  private _objectToNode(object: ReactiveEchoObject<any>): Node {
+  private _objectToNode(object: AnyLiveObject<any>): Node {
     const { id, ...properties } = object;
     return {
       id,
@@ -81,7 +82,7 @@ export class EchoDataSource implements DataSource {
     };
   }
 
-  private async _projectRefRelationship(object: ReactiveEchoObject<any>, prop: string): Promise<Relationship[]> {
+  private async _projectRefRelationship(object: AnyLiveObject<any>, prop: string): Promise<Relationship[]> {
     if (!object[prop]) {
       return [];
     }

package/src/cypher/execution-plan.test.ts

@@ -21,7 +21,7 @@ describe('Execution Plan', () => {
   test('complex query', ({ expect }) => {
     const plan = createExecutionPlan(
       parseCypherQuery(
-        "MATCH (org:Org {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
+        "MATCH (org:Organization {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
       ),
     );
     log('', { plan });

package/src/cypher/query-executor.test.ts

@@ -25,7 +25,7 @@ test.skip('run', async ({ expect }) => {
   const result = await executeQuery(
     dataSource,
     `
-      MATCH (org:Org {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'})
+      MATCH (org:Organization {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'})
       RETURN c.name, t.name
     `,
   );

package/src/cypher/schema.test.ts

@@ -7,10 +7,10 @@ import { test } from 'vitest';
 import { toJsonSchema } from '@dxos/echo-schema';
 
 import { formatJsonSchemaForLLM } from './schema';
-import { Contact, Org, Project, Task } from '../testing';
+import { Contact, Organization, Project, Task } from '../testing';
 
-test('Org-Project-Task-Contact schema', async ({ expect }) => {
-  const jsonSchema = [Org, Project, Task, Contact].map((schema) => toJsonSchema(schema));
+test('Organization-Project-Task-Contact schema', async ({ expect }) => {
+  const jsonSchema = [Organization, Project, Task, Contact].map((schema) => toJsonSchema(schema));
   const result = formatJsonSchemaForLLM(jsonSchema);
   // log('result', { result });
   expect(result).toHaveLength(8);

package/src/session/index.ts

@@ -3,3 +3,4 @@
 //
 
 export * from './session';
+export * from './version-pin';

package/src/session/session.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 import { inspect } from 'node:util';
 import { describe, test } from 'vitest';
 
@@ -15,7 +15,8 @@ import {
   type MessageContentBlock,
 } from '@dxos/artifact';
 import { AIServiceEdgeClient } from '@dxos/assistant';
-import { createStatic, EchoObject, ObjectId } from '@dxos/echo-schema';
+import { Type } from '@dxos/echo';
+import { create, ObjectId } from '@dxos/echo-schema';
 import { DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 
@@ -23,14 +24,19 @@ import { AISession } from './session';
 import { AI_SERVICE_ENDPOINT } from '../testing';
 
 // Define a calendar event artifact schema.
-const CalendarEventSchema = S.Struct({
-  title: S.String,
-  startTime: S.String,
-  endTime: S.String,
-  description: S.String,
-}).pipe(EchoObject({ typename: 'example.com/type/CalendarEvent', version: '0.1.0' }));
+const CalendarEventSchema = Schema.Struct({
+  title: Schema.String,
+  startTime: Schema.String,
+  endTime: Schema.String,
+  description: Schema.String,
+}).pipe(
+  Type.def({
+    typename: 'example.com/type/CalendarEvent',
+    version: '0.1.0',
+  }),
+);
 
-type CalendarEvent = S.Schema.Type<typeof CalendarEventSchema>;
+type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
 
 // TODO(burdon): Flaky.
 describe.skip('AISession with Ollama', () => {
@@ -39,7 +45,7 @@ describe.skip('AISession with Ollama', () => {
     // const aiClient = new OllamaClient({
     //   overrides: { model: 'llama3.1:8b' },
     // });
-    const session = new AISession({ operationModel: 'immediate' });
+    const session = new AISession({ operationModel: 'configured' });
 
     const objects = new Set<string>();
 
@@ -53,7 +59,7 @@ describe.skip('AISession with Ollama', () => {
         defineTool('calendar', {
           name: 'query',
           description: 'Query the calendar for events',
-          schema: S.Struct({}),
+          schema: Schema.Struct({}),
           execute: async () => {
             return ToolResult.Success(CALENDAR_EVENTS);
           },
@@ -65,13 +71,13 @@ describe.skip('AISession with Ollama', () => {
       id: 'artifact:dxos.org/plugin/table',
       name: 'Table',
       instructions: 'Use this to create and manage tables. Each table has a unique id.',
-      schema: S.Struct({}),
+      schema: Schema.Struct({}),
       tools: [
         defineTool('table', {
           name: 'create',
           description: 'Create a table',
-          schema: S.Struct({
-            data: S.Array(S.Any).annotations({ description: 'Array of data payloads to add as rows' }),
+          schema: Schema.Struct({
+            data: Schema.Array(Schema.Any).annotations({ description: 'Array of data payloads to add as rows' }),
           }),
           execute: async ({ data }) => {
             log('create table', { data });
@@ -89,12 +95,12 @@ describe.skip('AISession with Ollama', () => {
       name: 'Map',
       instructions:
         'Use this to create and manage maps. Maps source data from tables. Table id is required to create a map.',
-      schema: S.Struct({}),
+      schema: Schema.Struct({}),
       tools: [
         defineTool('map', {
           name: 'create',
           description: 'Create a map',
-          schema: S.Struct({
+          schema: Schema.Struct({
             source: ArtifactId.annotations({
               description: 'The table that will be used as the source of the map',
             }),
@@ -119,7 +125,7 @@ describe.skip('AISession with Ollama', () => {
       id: 'artifact:dxos.org/plugin/script',
       name: 'Script',
       instructions: 'Use this to create and manage scripts',
-      schema: S.Struct({}),
+      schema: Schema.Struct({}),
       tools: [],
     });
 
@@ -140,6 +146,7 @@ describe.skip('AISession with Ollama', () => {
       client: aiClient,
       tools: [],
       artifacts: [calendarArtifact, tableArtifact, mapArtifact, scriptArtifact],
+      requiredArtifactIds: [calendarArtifact.id, tableArtifact.id, mapArtifact.id, scriptArtifact.id],
       history: [],
       generationOptions: {
         model: '@anthropic/claude-3-5-haiku-20241022',
@@ -156,31 +163,31 @@ describe.skip('AISession with Ollama', () => {
 
 // Travel to rome, florence, livorno, siena, madrid for conferences
 const CALENDAR_EVENTS: CalendarEvent[] = [
-  createStatic(CalendarEventSchema, {
+  create(CalendarEventSchema, {
     title: 'Exploring Ancient Ruins in Rome',
     startTime: '2024-01-01T10:00:00Z',
     endTime: '2024-01-01T11:00:00Z',
     description: 'Tech conference at the historic Colosseum with networking opportunities',
   }),
-  createStatic(CalendarEventSchema, {
+  create(CalendarEventSchema, {
     title: 'Renaissance Tech Summit in Florence',
     startTime: '2024-01-01T11:00:00Z',
     endTime: '2024-01-01T12:00:00Z',
     description: 'Discussing AI innovations surrounded by Renaissance art',
   }),
-  createStatic(CalendarEventSchema, {
+  create(CalendarEventSchema, {
     title: 'Travel to Livorno',
     startTime: '2024-01-01T12:00:00Z',
     endTime: '2024-01-01T13:00:00Z',
     description: 'Travel to Livorno',
   }),
-  createStatic(CalendarEventSchema, {
+  create(CalendarEventSchema, {
     title: 'Travel to Siena',
     startTime: '2024-01-01T13:00:00Z',
     endTime: '2024-01-01T14:00:00Z',
     description: 'Travel to Siena',
   }),
-  createStatic(CalendarEventSchema, {
+  create(CalendarEventSchema, {
     title: 'Travel to Madrid',
     startTime: '2024-01-01T14:00:00Z',
     endTime: '2024-01-01T15:00:00Z',