@dxos/plugin-assistant 0.8.2-main.5885341 → 0.8.2-main.5ca3450

package/src/capabilities/react-surface.tsx

@@ -5,9 +5,9 @@
 import React, { useMemo } from 'react';
 
 import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { isInstanceOf, getTypename } from '@dxos/echo-schema';
+import { Type } from '@dxos/echo';
 import { SettingsStore } from '@dxos/local-storage';
-import { fullyQualifiedId, getSpace, isLiveObject, type SpaceId } from '@dxos/react-client/echo';
+import { fullyQualifiedId, getSpace, getTypename, isLiveObject, type SpaceId } from '@dxos/react-client/echo';
 
 import { AssistantDialog, AssistantSettings, ChatContainer, PromptSettings, TemplateContainer } from '../components';
 import { ASSISTANT_PLUGIN, ASSISTANT_DIALOG } from '../meta';
@@ -32,7 +32,7 @@ export default () =>
       id: `${ASSISTANT_PLUGIN}/chat`,
       role: 'article',
       filter: (data): data is { subject: AIChatType; variant: undefined } =>
-        isInstanceOf(AIChatType, data.subject) && data.variant !== 'assistant-chat',
+        Type.instanceOf(AIChatType, data.subject) && data.variant !== 'assistant-chat',
       component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
     }),
     createSurface({
@@ -57,13 +57,13 @@ export default () =>
     createSurface({
       id: `${ASSISTANT_PLUGIN}/template`,
       role: 'article',
-      filter: (data): data is { subject: TemplateType } => isInstanceOf(TemplateType, data.subject),
+      filter: (data): data is { subject: TemplateType } => Type.instanceOf(TemplateType, data.subject),
       component: ({ data, role }) => <TemplateContainer role={role} template={data.subject} />,
     }),
     createSurface({
       id: `${ASSISTANT_PLUGIN}/prompt-settings`,
       role: 'object-settings',
-      filter: (data): data is { subject: TemplateType } => isInstanceOf(TemplateType, data.subject),
+      filter: (data): data is { subject: TemplateType } => Type.instanceOf(TemplateType, data.subject),
       component: ({ data }) => <PromptSettings template={data.subject} />,
     }),
   ]);

package/src/components/PromptSettings.tsx

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Match, type Schema as S } from 'effect';
+import { Match, type Schema } from 'effect';
 import React, { type ChangeEvent, useCallback } from 'react';
 
 import { debounce } from '@dxos/async';
@@ -17,7 +17,7 @@ export const PromptSettings = ({ template }: { template: TemplateType }) => {
   const handleKindChange = useCallback(
     (value: string) => {
       const kind = Match.type<string>().pipe(
-        Match.withReturnType<S.Schema.Type<typeof TemplateKindSchema>>(),
+        Match.withReturnType<Schema.Schema.Type<typeof TemplateKindSchema>>(),
         Match.when('always', () => ({ include: 'always' })),
         Match.when('schema-matching', () => ({ include: 'schema-matching', typename: '' })),
         Match.when('automatically', () => ({ include: 'automatically', description: '' })),

package/src/components/TemplateEditor/TemplateForm.tsx

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Schema as S } from 'effect';
+import { type Schema } from 'effect';
 import React, { Fragment, useEffect } from 'react';
 
 import { Input, Select, useTranslation } from '@dxos/react-ui';
@@ -15,7 +15,7 @@ import { type TemplateInput, TemplateInputType, type TemplateType } from '../../
 
 export type TemplateFormProps = {
   template: TemplateType;
-  schema?: S.Schema<any, any, any>;
+  schema?: Schema.Schema<any, any, any>;
   commandEditable?: boolean;
 };
 

package/src/components/Thread/Thread.stories.tsx

@@ -10,7 +10,7 @@ import React, { useCallback, useEffect, useState } from 'react';
 import { IntentPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { type Message } from '@dxos/artifact';
-import { ObjectId } from '@dxos/echo-schema';
+import { Type } from '@dxos/echo';
 import { faker } from '@dxos/random';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { withLayout, withSignals, withTheme } from '@dxos/storybook-utils';
@@ -29,9 +29,9 @@ const DefaultStory = ({ messages: _messages, ...props }: ThreadProps) => {
 
   const handleSubmit = useCallback(
     (text: string) => {
-      const request: Message = { id: ObjectId.random(), role: 'user', content: [{ type: 'text', text }] };
+      const request: Message = { id: Type.ObjectId.random(), role: 'user', content: [{ type: 'text', text }] };
       const response: Message = {
-        id: ObjectId.random(),
+        id: Type.ObjectId.random(),
         role: 'assistant',
         content: [{ type: 'text', disposition: 'cot', pending: true, text: faker.lorem.paragraphs(1) }],
       };
@@ -44,7 +44,7 @@ const DefaultStory = ({ messages: _messages, ...props }: ThreadProps) => {
           request,
           response,
           {
-            id: ObjectId.random(),
+            id: Type.ObjectId.random(),
             role: 'assistant',
             content: [{ type: 'text', text: faker.lorem.paragraphs(1) }],
           },
@@ -93,7 +93,7 @@ type Story = StoryObj<ThreadProps>;
 
 const TEST_MESSAGES: Message[] = [
   {
-    id: ObjectId.random(),
+    id: Type.ObjectId.random(),
     role: 'user',
     content: [
       {
@@ -103,7 +103,7 @@ const TEST_MESSAGES: Message[] = [
     ],
   },
   {
-    id: ObjectId.random(),
+    id: Type.ObjectId.random(),
     role: 'assistant',
     content: [
       {
@@ -128,7 +128,7 @@ const TEST_MESSAGES: Message[] = [
     ],
   },
   {
-    id: ObjectId.random(),
+    id: Type.ObjectId.random(),
     role: 'user',
     content: [
       {
@@ -139,7 +139,7 @@ const TEST_MESSAGES: Message[] = [
     ],
   },
   {
-    id: ObjectId.random(),
+    id: Type.ObjectId.random(),
     role: 'assistant',
     content: [
       {
@@ -151,7 +151,7 @@ const TEST_MESSAGES: Message[] = [
     ],
   },
   {
-    id: ObjectId.random(),
+    id: Type.ObjectId.random(),
     role: 'user',
     content: [
       {
@@ -162,7 +162,7 @@ const TEST_MESSAGES: Message[] = [
     ],
   },
   {
-    id: ObjectId.random(),
+    id: Type.ObjectId.random(),
     role: 'assistant',
     content: [
       {

package/src/components/Thread/ThreadContainer.stories.tsx

@@ -18,11 +18,11 @@ import {
 } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Message, type Tool } from '@dxos/artifact';
-import { genericTools, localServiceEndpoints, type IsObject } from '@dxos/artifact-testing';
+import { genericTools, localServiceEndpoints } from '@dxos/artifact-testing';
 import { AIServiceEdgeClient } from '@dxos/assistant';
-import { create, ObjectId } from '@dxos/echo-schema';
+import { DXN, Type } from '@dxos/echo';
+import { create } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { DXN } from '@dxos/keys';
 import { ChessPlugin } from '@dxos/plugin-chess';
 import { ChessType } from '@dxos/plugin-chess/types';
 import { ClientPlugin } from '@dxos/plugin-client';
@@ -43,7 +43,7 @@ import translations from '../../translations';
 const endpoints = localServiceEndpoints;
 
 type RenderProps = {
-  items?: IsObject[];
+  items?: Type.AnyObject[];
   prompts?: string[];
 } & Pick<ThreadProps, 'debug'>;
 
@@ -131,7 +131,7 @@ const DefaultStory = ({ items: _items, prompts = [], ...props }: RenderProps) =>
 
   const handleDelete = useCallback(
     (id: string) => {
-      invariant(ObjectId.isValid(id), 'Invalid message id');
+      invariant(Type.ObjectId.isValid(id), 'Invalid message id');
       void queue?.delete([id]);
     },
     [queue],

package/src/components/Toolbox/Toolbox.tsx

@@ -6,7 +6,7 @@ import React, { useState, useEffect, Fragment, type FC } from 'react';
 
 import { Capabilities, useCapabilities } from '@dxos/app-framework';
 import { parseToolName, type ArtifactDefinition, type Tool } from '@dxos/artifact';
-import { FunctionType } from '@dxos/functions/types';
+import { FunctionType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
 import { type ThemedClassName } from '@dxos/react-ui';

package/src/hooks/index.ts

@@ -5,7 +5,6 @@
 export * from './processor';
 
 export * from './useChatProcessor';
-export * from './useLocalTriggerManager';
 export * from './useMessageQueue';
 export * from './useServices';
 export * from './useTextInputEvents';

package/src/hooks/useChatProcessor.tsx

@@ -7,7 +7,7 @@ import { useEffect, useMemo, useState } from 'react';
 import { Capabilities, useCapabilities, useCapability, useIntentDispatcher } from '@dxos/app-framework';
 import { type AssociatedArtifact, createSystemPrompt, type Tool } from '@dxos/artifact';
 import { DEFAULT_EDGE_MODEL, DEFAULT_OLLAMA_MODEL } from '@dxos/assistant';
-import { FunctionType } from '@dxos/functions/types';
+import { FunctionType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { useConfig } from '@dxos/react-client';
 import { Filter, fullyQualifiedId, type Space, useQuery } from '@dxos/react-client/echo';

package/src/hooks/useContextProvider.ts

@@ -5,10 +5,10 @@
 import { useMemo } from 'react';
 
 import { Capabilities, useCapabilities } from '@dxos/app-framework';
-import type { Space } from '@dxos/client/echo';
-import { getDXN, getLabel, getSchema } from '@dxos/echo-schema';
+import { Filter, type Space } from '@dxos/client/echo';
+import { Type } from '@dxos/echo';
+import { getLabel } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
-import { Filter } from '@dxos/react-client/echo';
 
 export type ContextProvider = {
   query: (params: { query: string }) => Promise<Array<{ uri: string; label: string }>>;
@@ -33,21 +33,21 @@ export const useContextProvider = (space?: Space): ContextProvider | undefined =
           .run();
         return objects
           .map((object) => {
-            log.info('object', { object, label: getLabel(getSchema(object)!, object) });
+            log.info('object', { object, label: getLabel(Type.getSchema(object)!, object) });
             return object;
           })
-          .filter((object) => stringMatch(query, getLabel(getSchema(object)!, object) ?? ''))
-          .filter((object) => !!getDXN(object))
+          .filter((object) => stringMatch(query, getLabel(Type.getSchema(object)!, object) ?? ''))
+          .filter((object) => !!Type.getDXN(object))
           .map((object) => ({
-            uri: getDXN(object)!.toString(),
-            label: getLabel(getSchema(object)!, object) ?? '',
+            uri: Type.getDXN(object)!.toString(),
+            label: getLabel(Type.getSchema(object)!, object) ?? '',
           }));
       },
       resolveMetadata: async ({ uri }) => {
         const object = await space.db.query({ id: uri }).first();
         return {
           uri,
-          label: getLabel(getSchema(object)!, object) ?? '',
+          label: getLabel(Type.getSchema(object)!, object) ?? '',
         };
       },
     };

package/src/tools/function.ts

@@ -5,8 +5,8 @@
 import { defineTool, ToolResult } from '@dxos/artifact';
 import type { Tool } from '@dxos/artifact';
 import { toEffectSchema } from '@dxos/echo-schema';
-import { getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions/types';
-import type { FunctionType } from '@dxos/functions/types';
+import { getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions';
+import type { FunctionType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import type { SpaceId } from '@dxos/react-client/echo';
 import { getMeta } from '@dxos/react-client/echo';

package/src/tools/openapi.ts

@@ -2,11 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema } from 'effect';
 import jsonpointer from 'jsonpointer';
 import { type OpenAPIV2, type OpenAPIV3_1 } from 'openapi-types';
 
 import { ToolResult, type Tool } from '@dxos/artifact';
-import { JsonSchemaType, normalizeSchema, S, toEffectSchema } from '@dxos/echo-schema';
+import { JsonSchemaType, normalizeSchema, toEffectSchema } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { deepMapValues } from '@dxos/util';
@@ -82,7 +83,7 @@ export const createToolsFromApi = async (url: string, options?: CreateToolsFromA
       }
 
       log('inputSchema', { inputSchema });
-      S.validateSync(JsonSchemaType)(inputSchema);
+      Schema.validateSync(JsonSchemaType)(inputSchema);
 
       const description = methodItem.description ?? methodItem.summary;
       if (!description) {
@@ -200,7 +201,7 @@ const callApiEndpoint = async (endpoint: EndpointDescriptor, input: any) => {
 
         // Client-side validation
         const effectSchema = toEffectSchema(parameter.schema);
-        S.validateSync(effectSchema)(value);
+        Schema.validateSync(effectSchema)(value);
 
         if (body) {
           throw new Error(`Duplicate body parameter: ${parameter.name}`);

package/src/types/service.ts

@@ -2,78 +2,80 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Schema } from 'effect';
+
 import { ComputeGraph } from '@dxos/conductor';
-import { Ref, S, TypedObject, type Ref$ } from '@dxos/echo-schema';
-import { FunctionType } from '@dxos/functions/types';
-
-const ApiAuthorizationKey = S.Struct({
-  type: S.Literal('api-key'),
-  key: S.String,
-  placement: S.Union(
-    S.Struct({
-      type: S.Literal('authorization-header'),
+import { Ref, TypedObject, type Ref$ } from '@dxos/echo-schema';
+import { FunctionType } from '@dxos/functions';
+
+const ApiAuthorizationKey = Schema.Struct({
+  type: Schema.Literal('api-key'),
+  key: Schema.String,
+  placement: Schema.Union(
+    Schema.Struct({
+      type: Schema.Literal('authorization-header'),
     }),
-    S.Struct({
-      type: S.Literal('query'),
-      name: S.String,
+    Schema.Struct({
+      type: Schema.Literal('query'),
+      name: Schema.String,
     }),
   ),
 });
 
-const ApiAuthorizationOauth = S.Struct({
-  type: S.Literal('oauth'),
-  clientId: S.String,
-  clientSecret: S.String,
-  tokenUrl: S.String,
-  grantType: S.String,
+const ApiAuthorizationOauth = Schema.Struct({
+  type: Schema.Literal('oauth'),
+  clientId: Schema.String,
+  clientSecret: Schema.String,
+  tokenUrl: Schema.String,
+  grantType: Schema.String,
 });
 
-export const ApiAuthorization = S.Union(ApiAuthorizationKey, ApiAuthorizationOauth);
-export type ApiAuthorization = S.Schema.Type<typeof ApiAuthorization>;
+export const ApiAuthorization = Schema.Union(ApiAuthorizationKey, ApiAuthorizationOauth);
+export type ApiAuthorization = Schema.Schema.Type<typeof ApiAuthorization>;
 
-const ServiceInterfaceFunction = S.Struct({
-  kind: S.Literal('function'),
+const ServiceInterfaceFunction = Schema.Struct({
+  kind: Schema.Literal('function'),
   fn: Ref(FunctionType) as Ref$<FunctionType>,
 });
 
-const ServiceInterfaceWorkflow = S.Struct({
-  kind: S.Literal('workflow'),
+const ServiceInterfaceWorkflow = Schema.Struct({
+  kind: Schema.Literal('workflow'),
   workflow: Ref(ComputeGraph) as Ref$<ComputeGraph>,
 });
 
-const ServiceInterfaceApi = S.Struct({
-  kind: S.Literal('api'),
+const ServiceInterfaceApi = Schema.Struct({
+  kind: Schema.Literal('api'),
 
   /**
    * URL to fetch the openapi schema.
    */
-  schemaUrl: S.optional(S.String),
+  schemaUrl: Schema.optional(Schema.String),
 
   /**
    * Inlined openapi schema.
    */
-  schema: S.optional(S.Any),
+  schema: Schema.optional(Schema.Any),
 
   /**
    * Authorization configuration if required.
    */
-  authorization: S.optional(ApiAuthorization),
+  authorization: Schema.optional(ApiAuthorization),
 });
 
-const ServiceInterface = S.Union(ServiceInterfaceFunction, ServiceInterfaceWorkflow, ServiceInterfaceApi);
-export type ServiceInterface = S.Schema.Type<typeof ServiceInterface>;
+const ServiceInterface = Schema.Union(ServiceInterfaceFunction, ServiceInterfaceWorkflow, ServiceInterfaceApi);
+export type ServiceInterface = Schema.Schema.Type<typeof ServiceInterface>;
 
 export class ServiceType extends TypedObject({ typename: 'dxos.org/type/ServiceType', version: '0.1.0' })({
-  serviceId: S.String,
-  name: S.optional(S.String),
-  description: S.optional(S.String),
-  category: S.optional(S.String),
-  enabled: S.optional(S.Boolean),
+  serviceId: Schema.String,
+  name: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  category: Schema.optional(Schema.String),
+  enabled: Schema.optional(Schema.Boolean),
 
   /**
    * Entries exposed: functions, workflows, and APIs.
    */
-  interfaces: S.optional(S.Array(ServiceInterface)),
+  interfaces: Schema.optional(Schema.Array(ServiceInterface)),
 }) {}
 
 //

package/src/types/template.ts

@@ -2,9 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { S, TypedObject } from '@dxos/echo-schema';
+import { Schema } from 'effect';
 
-// TODO(burdon): Change to S.Literal (and discriminated union).
+import { TypedObject } from '@dxos/echo-schema';
+
+// TODO(burdon): Change to Schema.Literal (and discriminated union).
 export enum TemplateInputType {
   VALUE = 0,
   PASS_THROUGH = 1,
@@ -16,41 +18,41 @@ export enum TemplateInputType {
   SCHEMA = 7,
 }
 
-export const TemplateInputSchema = S.mutable(
-  S.Struct({
-    name: S.String,
-    type: S.optional(S.Enums(TemplateInputType)),
-    value: S.optional(S.String),
+export const TemplateInputSchema = Schema.mutable(
+  Schema.Struct({
+    name: Schema.String,
+    type: Schema.optional(Schema.Enums(TemplateInputType)),
+    value: Schema.optional(Schema.String),
   }),
 );
 
-export type TemplateInput = S.Schema.Type<typeof TemplateInputSchema>;
+export type TemplateInput = Schema.Schema.Type<typeof TemplateInputSchema>;
 
 export const TemplateKinds = ['always', 'schema-matching', 'automatically', 'manual'] as const;
 export type TemplateKind = (typeof TemplateKinds)[number];
 
-export const TemplateKindSchema = S.Union(
-  S.Struct({
-    include: S.Literal('always'),
+export const TemplateKindSchema = Schema.Union(
+  Schema.Struct({
+    include: Schema.Literal('always'),
   }),
-  S.Struct({
-    include: S.Literal('schema-matching'),
-    typename: S.String,
+  Schema.Struct({
+    include: Schema.Literal('schema-matching'),
+    typename: Schema.String,
   }),
-  S.Struct({
-    include: S.Literal('automatically'),
-    description: S.String,
+  Schema.Struct({
+    include: Schema.Literal('automatically'),
+    description: Schema.String,
   }),
-  S.Struct({
-    include: S.Literal('manual'),
+  Schema.Struct({
+    include: Schema.Literal('manual'),
   }),
 );
 
-export type TemplateKindType = S.Schema.Type<typeof TemplateKindSchema>;
+export type TemplateKindType = Schema.Schema.Type<typeof TemplateKindSchema>;
 export class TemplateType extends TypedObject({ typename: 'dxos.org/type/Template', version: '0.1.0' })({
-  name: S.optional(S.String),
-  kind: S.mutable(TemplateKindSchema),
-  source: S.String,
-  inputs: S.optional(S.mutable(S.Array(TemplateInputSchema))),
-  command: S.optional(S.String),
+  name: Schema.optional(Schema.String),
+  kind: Schema.mutable(TemplateKindSchema),
+  source: Schema.String,
+  inputs: Schema.optional(Schema.mutable(Schema.Array(TemplateInputSchema))),
+  command: Schema.optional(Schema.String),
 }) {}

package/src/types/types.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
+import { Schema } from 'effect';
 
 import { AIChatType } from './chat';
 import { TemplateType } from './template';
@@ -11,21 +11,21 @@ import { ASSISTANT_PLUGIN } from '../meta';
 export namespace AssistantAction {
   const ASSISTANT_ACTION = `${ASSISTANT_PLUGIN}/action`;
 
-  export class CreateChat extends S.TaggedClass<CreateChat>()(`${ASSISTANT_ACTION}/create-chat`, {
-    input: S.Struct({
-      spaceId: S.optional(S.String),
-      name: S.optional(S.String),
+  export class CreateChat extends Schema.TaggedClass<CreateChat>()(`${ASSISTANT_ACTION}/create-chat`, {
+    input: Schema.Struct({
+      spaceId: Schema.optional(Schema.String),
+      name: Schema.optional(Schema.String),
     }),
-    output: S.Struct({
+    output: Schema.Struct({
       object: AIChatType,
     }),
   }) {}
 
-  export class CreateTemplate extends S.TaggedClass<CreateTemplate>()(`${ASSISTANT_ACTION}/create-template`, {
-    input: S.Struct({
-      name: S.optional(S.String),
+  export class CreateTemplate extends Schema.TaggedClass<CreateTemplate>()(`${ASSISTANT_ACTION}/create-template`, {
+    input: Schema.Struct({
+      name: Schema.optional(Schema.String),
     }),
-    output: S.Struct({
+    output: Schema.Struct({
       object: TemplateType,
     }),
   }) {}
@@ -33,14 +33,14 @@ export namespace AssistantAction {
 
 export const LLM_PROVIDERS = ['edge', 'ollama', 'lmstudio'] as const;
 
-export const AssistantSettingsSchema = S.mutable(
-  S.Struct({
-    llmProvider: S.optional(S.Literal(...LLM_PROVIDERS)),
-    edgeModel: S.optional(S.String),
-    ollamaModel: S.optional(S.String),
-    lmstudioModel: S.optional(S.String),
-    customPrompts: S.optional(S.Boolean),
+export const AssistantSettingsSchema = Schema.mutable(
+  Schema.Struct({
+    llmProvider: Schema.optional(Schema.Literal(...LLM_PROVIDERS)),
+    edgeModel: Schema.optional(Schema.String),
+    ollamaModel: Schema.optional(Schema.String),
+    lmstudioModel: Schema.optional(Schema.String),
+    customPrompts: Schema.optional(Schema.Boolean),
   }),
 );
 
-export type AssistantSettingsProps = S.Schema.Type<typeof AssistantSettingsSchema>;
+export type AssistantSettingsProps = Schema.Schema.Type<typeof AssistantSettingsSchema>;