@dxos/plugin-assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/src/hooks/invocation-handler.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { sleep } from '@dxos/async';
+import { getObjectCore, ResultFormat } from '@dxos/echo-db';
+import { type AnyObjectData } from '@dxos/echo-schema';
+import { FunctionType, getUserFunctionUrlInMetadata } from '@dxos/functions/types';
+import { type FunctionTrigger } from '@dxos/functions/types';
+import { invariant } from '@dxos/invariant';
+import { DXN, LOCAL_SPACE_TAG } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { type Client, type Config } from '@dxos/react-client';
+import { type Space } from '@dxos/react-client/echo';
+
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1_000;
+
+const callFunction = async (funcUrl: string, trigger: any, data: any) => {
+  const body = { event: 'trigger', trigger, data };
+
+  let retryCount = 0;
+  while (retryCount < MAX_RETRIES) {
+    log.info('exec', { funcUrl, body, retryCount });
+    const response = await fetch(funcUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    const data = await response.text();
+    log.info('response', { status: response.status, body: data });
+    if (response.status === 409) {
+      retryCount++;
+      await sleep(RETRY_DELAY * Math.min(retryCount, 2));
+      continue;
+    }
+
+    return { status: response.status, data };
+  }
+  return { status: 500 };
+};
+
+export const invokeFunction = async (client: Client, space: Space, trigger: FunctionTrigger, data: any) => {
+  try {
+    invariant(trigger.spec);
+    invariant(trigger.function);
+
+    const script = await space.db.query({ id: trigger.function }, { format: ResultFormat.Plain }).first();
+    const { objects: functions } = await space.db
+      .query({ __typename: FunctionType.typename }, { format: ResultFormat.Plain })
+      .run();
+    const func = functions.find((fn) => referenceEquals(fn.source, trigger.function!)) as AnyObjectData | undefined;
+    const funcSlug = func && getUserFunctionUrlInMetadata(func.__meta);
+    if (!funcSlug) {
+      log.warn('function not deployed', { scriptId: script.id, name: script.name });
+      return 404;
+    }
+
+    const funcUrl = getFunctionUrl(client.config, funcSlug, space.id);
+    const triggerData: AnyObjectData = {
+      ...getObjectCore(trigger).toPlainObject(),
+      // TODO: Remove when functions can query by DXN.
+      promptId: trigger.meta?.prompt?.id,
+    };
+    // TODO: Remove when functions can add objects and easily modify collections (push, splice).
+    return (await callFunction(funcUrl, triggerData, data)).status;
+  } catch (err) {
+    return 400;
+  }
+};
+
+const getFunctionUrl = (config: Config, slug: string, spaceId?: string) => {
+  const baseUrl = new URL('functions/', config.values.runtime?.services?.edge?.url);
+
+  // Leading slashes cause the URL to be treated as an absolute path.
+  const relativeUrl = slug.replace(/^\//, '');
+  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
+  spaceId && url.searchParams.set('spaceId', spaceId);
+  url.protocol = 'https';
+  return url.toString();
+};
+
+// TODO(dmaretskyi): Factor out.
+
+type ReferenceLike = { '/': string } | string;
+
+const referenceEquals = (a: ReferenceLike, b: ReferenceLike): boolean => {
+  const aDXN = toDXN(a);
+  const bDXN = toDXN(b);
+  return aDXN.toString() === bDXN.toString();
+};
+
+const toDXN = (ref: ReferenceLike): DXN => {
+  if (typeof ref === 'string') {
+    if (ref.startsWith('dxn:')) {
+      return DXN.parse(ref);
+    } else {
+      return new DXN(DXN.kind.ECHO, [LOCAL_SPACE_TAG, ref]);
+    }
+  }
+
+  invariant(typeof ref['/'] === 'string');
+  return DXN.parse(ref['/']);
+};

package/src/hooks/processor.ts

@@ -9,7 +9,7 @@ import { type ArtifactDefinition, type Message, type MessageContentBlock, type T
 import { type AIServiceClient, AISession, DEFAULT_EDGE_MODEL, type GenerateRequest } from '@dxos/assistant';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { getVersion, type Space } from '@dxos/react-client/echo';
+import { type Space } from '@dxos/react-client/echo';
 
 // TODO(burdon): Factor out.
 declare global {
@@ -99,7 +99,7 @@ export class ChatProcessor {
    * Make GPT request.
    */
   async request(message: string, options: RequestOptions = {}): Promise<Message[]> {
-    this._session = new AISession({ operationModel: 'configured' });
+    this._session = new AISession({ operationModel: 'immediate' });
 
     // Message complete.
     this._session.message.on((message) => {
@@ -125,39 +125,17 @@ export class ChatProcessor {
         client: this._ai,
         history: options.history ?? [],
         artifacts: this._artifacts ?? [],
-        requiredArtifactIds: this._artifacts?.map((artifact) => artifact.id) ?? [],
         tools: this._tools ?? [],
         prompt: message,
         systemPrompt: this._options.systemPrompt,
         extensions: this._extensions,
-        artifactDiffResolver: async (artifacts) => {
-          const space = this._extensions?.space;
-          if (!space) {
-            return new Map();
-          }
-          const versions = new Map();
-          await Promise.all(
-            artifacts.map(async (artifact) => {
-              const {
-                objects: [object],
-              } = await space.db.query({ id: artifact.id }).run();
-              if (!object) {
-                return;
-              }
-              versions.set(artifact.id, {
-                version: getVersion(object),
-                diff: `Current state: ${JSON.stringify(object)}`,
-              });
-            }),
-          );
-          return versions;
-        },
         generationOptions: {
           model: this._options.model,
         },
       });
 
-      log('completed', { messages });
+      log.info('completed', { messages });
+
       options.onComplete?.(this._pending.value);
     } catch (err) {
       log.catch(err);

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';
+import { FunctionType } from '@dxos/functions/types';
 import { log } from '@dxos/log';
 import { useConfig } from '@dxos/react-client';
 import { Filter, fullyQualifiedId, type Space, useQuery } from '@dxos/react-client/echo';
@@ -15,7 +15,7 @@ import { isNonNullable } from '@dxos/util';
 
 import { AssistantCapabilities } from '../capabilities';
 import { ChatProcessor, type ChatProcessorOptions } from '../hooks';
-import { convertFunctionToTool, createToolsFromService } from '../tools';
+import { covertFunctionToTool, createToolsFromService } from '../tools';
 import { type AIChatType, type AssistantSettingsProps, ServiceType } from '../types';
 
 type UseChatProcessorProps = {
@@ -33,8 +33,7 @@ export const useChatProcessor = ({
   chat,
   space,
   settings,
-  // part = 'deck',
-  part,
+  part = 'deck',
   associatedArtifact,
 }: UseChatProcessorProps): ChatProcessor => {
   const aiClient = useCapability(AssistantCapabilities.AiClient);
@@ -43,7 +42,7 @@ export const useChatProcessor = ({
   const { dispatchPromise: dispatch } = useIntentDispatcher();
 
   // Services.
-  const services = useQuery(space, Filter.type(ServiceType));
+  const services = useQuery(space, Filter.schema(ServiceType));
   const [serviceTools, setServiceTools] = useState<Tool[]>([]);
   useEffect(() => {
     log('creating service tools...');
@@ -55,7 +54,7 @@ export const useChatProcessor = ({
 
   // Tools and context.
   const config = useConfig();
-  const functions = useQuery(space, Filter.type(FunctionType));
+  const functions = useQuery(space, Filter.schema(FunctionType));
   const chatId = useMemo(() => (chat ? fullyQualifiedId(chat) : undefined), [chat]);
   const [tools, extensions] = useMemo(() => {
     log('creating tools...');
@@ -63,7 +62,7 @@ export const useChatProcessor = ({
       ...globalTools.flat(),
       ...serviceTools,
       ...functions
-        .map((fn) => convertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
+        .map((fn) => covertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
         .filter(isNonNullable),
     ];
     const extensions = { space, dispatch, pivotId: chatId, part };
@@ -91,7 +90,7 @@ export const useChatProcessor = ({
   const processor = useMemo(() => {
     log('creating processor...', { settings });
     return new ChatProcessor(aiClient.value, tools, artifactDefinitions, extensions, { model, systemPrompt });
-  }, [aiClient.value, tools, artifactDefinitions, extensions, model, systemPrompt]);
+  }, [aiClient.value, tools, extensions, model, systemPrompt]);
 
   return processor;
 };

package/src/hooks/useContextProvider.ts

@@ -2,14 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { Schema } from 'effect';
 import { useMemo } from 'react';
 
 import { Capabilities, useCapabilities } from '@dxos/app-framework';
-import { Filter, type Space } from '@dxos/client/echo';
-import { Type } from '@dxos/echo';
-import { type BaseEchoObject, getDXN, getLabel } from '@dxos/echo-schema';
+import type { Space } from '@dxos/client/echo';
+import { getDXN, getLabel, getSchema } 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 }>>;
@@ -30,28 +29,25 @@ export const useContextProvider = (space?: Space): ContextProvider | undefined =
       query: async ({ query }) => {
         const artifactSchemas = artifactDefinitions.map((artifact) => artifact.schema);
         const { objects } = await space.db
-          .query(Filter.or(...artifactSchemas.map((schema) => Filter.type(schema as Schema.Schema<BaseEchoObject>))))
+          .query(Filter.or(...artifactSchemas.map((schema) => Filter.schema(schema))))
           .run();
-        return (
-          objects
-            .map((object) => {
-              log.info('object', { object, label: getLabel(Type.getSchema(object)!, object) });
-              return object;
-            })
-            .filter((object) => stringMatch(query, getLabel(Type.getSchema(object)!, object) ?? ''))
-            // TODO(dmaretskyi): `Type.getDXN` (at the point of writing) didn't work here as it was schema-only.
-            .filter((object) => !!getDXN(object))
-            .map((object) => ({
-              uri: getDXN(object as any)!.toString(),
-              label: getLabel(Type.getSchema(object)!, object) ?? '',
-            }))
-        );
+        return objects
+          .map((object) => {
+            log.info('object', { object, label: getLabel(getSchema(object)!, object) });
+            return object;
+          })
+          .filter((object) => stringMatch(query, getLabel(getSchema(object)!, object) ?? ''))
+          .filter((object) => !!getDXN(object))
+          .map((object) => ({
+            uri: getDXN(object)!.toString(),
+            label: getLabel(getSchema(object)!, object) ?? '',
+          }));
       },
       resolveMetadata: async ({ uri }) => {
         const object = await space.db.query({ id: uri }).first();
         return {
           uri,
-          label: getLabel(Type.getSchema(object)!, object) ?? '',
+          label: getLabel(getSchema(object)!, object) ?? '',
         };
       },
     };

package/src/hooks/useLocalTriggerManager.ts

@@ -0,0 +1,82 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import { Mutex } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { createSubscriptionTrigger, type TriggerFactory } from '@dxos/functions';
+import { FunctionTrigger } from '@dxos/functions/types';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { useClient } from '@dxos/react-client';
+import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
+
+import { invokeFunction } from './invocation-handler';
+
+const registerTriggersMutex = new Mutex();
+
+export const useLocalTriggerManager = (space: Space) => {
+  const client = useClient();
+
+  // TODO(burdon): Factor out, creating context for plugin (runs outside of component).
+  const [registry] = useState(new Map<string, Context>());
+  const triggers = useQuery(space, Filter.schema(FunctionTrigger));
+  useEffect(() => {
+    setTimeout(async () => {
+      // Mark-and-sweep removing disabled triggers.
+      await registerTriggersMutex.executeSynchronized(async () => {
+        const deprecated = new Set(Array.from(registry.keys()));
+        log('triggers', {
+          deprecated,
+          all: triggers.map((t) => t.id),
+          enabled: triggers.filter((t) => t.enabled).map((t) => t.id),
+        });
+
+        for (const trigger of triggers) {
+          if (trigger.enabled) {
+            if (registry.has(trigger.id)) {
+              deprecated.delete(trigger.id);
+              continue;
+            }
+            log.info('activating trigger', trigger.id);
+
+            const ctx = new Context();
+            registry.set(trigger.id, ctx);
+            const triggerSpec = trigger.spec;
+            invariant(triggerSpec);
+
+            let triggerFactory: TriggerFactory<any>;
+            if (triggerSpec.type === 'subscription') {
+              triggerFactory = createSubscriptionTrigger;
+            } else {
+              log.info('unsupported trigger', { type: triggerSpec.type });
+              continue;
+            }
+
+            await triggerFactory(ctx, space, trigger.spec, (data: any) => {
+              return invokeFunction(client, space, trigger, data);
+            });
+          }
+        }
+
+        for (const id of deprecated) {
+          const ctx = registry.get(id);
+          if (ctx) {
+            await ctx.dispose();
+            registry.delete(id);
+          }
+        }
+      });
+    });
+  }, [JSON.stringify(triggers)]);
+
+  useEffect(() => {
+    return () => {
+      for (const ctx of registry.values()) {
+        void ctx.dispose();
+      }
+    };
+  }, []);
+};

package/src/hooks/useMessageQueue.ts

@@ -5,7 +5,7 @@
 import { useMemo } from 'react';
 
 import { type Message } from '@dxos/artifact';
-import { createQueueDxn } from '@dxos/echo-schema';
+import { DXN, QueueSubspaceTags } from '@dxos/keys';
 import { getSpace, useQueue } from '@dxos/react-client/echo';
 
 import { type AIChatType } from '../types';
@@ -14,7 +14,7 @@ export const useMessageQueue = (chat?: AIChatType) => {
   const space = getSpace(chat);
   const queueDxn = useMemo(() => {
     const dxn = space && chat?.assistantChatQueue.dxn;
-    return dxn ? createQueueDxn(space.id) : undefined;
+    return dxn ? new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, space.id, dxn.parts.at(-1)!]) : undefined;
   }, [space, chat?.assistantChatQueue.dxn]);
 
   return useQueue<Message>(queueDxn);

package/src/testing/test-services.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { create } from '@dxos/echo-schema';
+import { createStatic } from '@dxos/echo-schema';
 
 import {
   type ApiAuthorization,
@@ -54,7 +54,7 @@ const VISUAL_CROSSING_CREDENTIALS: ApiAuthorization = {
 //  - e.g., https://github.com/konfig-sdks/openapi-examples/blob/main/xkcd/openapi.yaml
 
 const TEST_SERVICES: ServiceType[] = [
-  create(ServiceType, {
+  createStatic(ServiceType, {
     serviceId: 'amadeus.com/service/FlightSearch',
     name: 'Amadeus Flight Search',
     description: 'Search for local and international flights.',
@@ -68,7 +68,7 @@ const TEST_SERVICES: ServiceType[] = [
     ],
   }),
 
-  create(ServiceType, {
+  createStatic(ServiceType, {
     serviceId: 'amadeus.com/service/HotelSearch',
     name: 'Amadeus Hotel Search',
     description: 'Search for local and international hotels.',
@@ -82,7 +82,7 @@ const TEST_SERVICES: ServiceType[] = [
     ],
   }),
 
-  create(ServiceType, {
+  createStatic(ServiceType, {
     serviceId: 'visualcrossing.com/service/Weather',
     name: 'Visual Crossing Weather',
     description: 'Search for global weather forecasts.',
@@ -97,7 +97,7 @@ const TEST_SERVICES: ServiceType[] = [
   }),
 
   // TODO(burdon): Needs auth.
-  create(ServiceType, {
+  createStatic(ServiceType, {
     serviceId: 'abstractapi.com/service/GeoLocation',
     name: 'Abstract GeoLocation',
     description: 'Get the location of any IP address.',
@@ -115,7 +115,7 @@ const TEST_SERVICES: ServiceType[] = [
   //
 
   ...Array.from({ length: 20 }, (_, i) =>
-    create(ServiceType, {
+    createStatic(ServiceType, {
       serviceId: `example.com/service/test-${i}`,
       name: `Test ${i}`,
       description: `Test ${i}`,

package/src/tools/function.ts

@@ -5,13 +5,13 @@
 import { defineTool, ToolResult } from '@dxos/artifact';
 import type { Tool } from '@dxos/artifact';
 import { toEffectSchema } from '@dxos/echo-schema';
-import { getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions';
-import type { FunctionType } from '@dxos/functions';
+import { getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions/types';
+import type { FunctionType } from '@dxos/functions/types';
 import { log } from '@dxos/log';
 import type { SpaceId } from '@dxos/react-client/echo';
 import { getMeta } from '@dxos/react-client/echo';
 
-export const convertFunctionToTool = (
+export const covertFunctionToTool = (
   fn: FunctionType,
   edgeUrl: string,
   spaceId?: SpaceId | undefined,
@@ -24,7 +24,9 @@ export const convertFunctionToTool = (
   if (!existingFunctionUrl) {
     return undefined;
   }
-  const url = getInvocationUrl(existingFunctionUrl, edgeUrl, { spaceId });
+  const url = getInvocationUrl(existingFunctionUrl, edgeUrl, {
+    spaceId,
+  });
 
   return defineTool('user-function', {
     name: fn.name,

package/src/tools/openapi.ts

@@ -2,12 +2,11 @@
 // 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, toEffectSchema } from '@dxos/echo-schema';
+import { JsonSchemaType, normalizeSchema, S, toEffectSchema } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { deepMapValues } from '@dxos/util';
@@ -83,7 +82,7 @@ export const createToolsFromApi = async (url: string, options?: CreateToolsFromA
       }
 
       log('inputSchema', { inputSchema });
-      Schema.validateSync(JsonSchemaType)(inputSchema);
+      S.validateSync(JsonSchemaType)(inputSchema);
 
       const description = methodItem.description ?? methodItem.summary;
       if (!description) {
@@ -201,7 +200,7 @@ const callApiEndpoint = async (endpoint: EndpointDescriptor, input: any) => {
 
         // Client-side validation
         const effectSchema = toEffectSchema(parameter.schema);
-        Schema.validateSync(effectSchema)(value);
+        S.validateSync(effectSchema)(value);
 
         if (body) {
           throw new Error(`Duplicate body parameter: ${parameter.name}`);

package/src/translations.ts

@@ -9,7 +9,7 @@ export default [
   {
     'en-US': {
       [AIChatType.typename]: {
-        'typename label': 'Assistant',
+        'typename label': 'AI Chat',
         'object name placeholder': 'AI Chat',
       },
       [TemplateType.typename]: {
@@ -19,8 +19,8 @@ export default [
       [ASSISTANT_PLUGIN]: {
         'templates label': 'Templates',
 
-        'open ambient chat label': 'Open Assistant',
-        'assistant chat label': 'Assistant',
+        'open ambient chat label': 'Open AI chat',
+        'assistant chat label': 'AI chat',
         'plugin name': 'Assistant',
         'object placeholder': 'New prompt',
         'create object label': 'Create prompt',
@@ -29,7 +29,6 @@ export default [
         'command placeholder': 'Enter slash command...',
         'template placeholder': 'Enter template...',
         'value placeholder': 'Enter value...',
-        'prompt rules label': 'Prompt Rules',
         'typename placeholder': 'Enter typename of objects which this template is for',
         'description placeholder': 'Enter description of when this template should be used',
         'select preset template placeholder': 'Select preset',
@@ -47,7 +46,7 @@ export default [
 
         'settings default label': 'Default',
         'settings custom prompts label': 'Use custom prompts',
-        'settings llm provider label': 'LLM provider',
+        'settings llm provider label': 'Enable Ollama integration',
         'settings edge llm model label': 'Remote language model',
         'settings ollama llm model label': 'Ollama language model',
       },

package/src/types/service.ts

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