@dxos/assistant 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@dxos/assistant",
-  "version": "0.8.4-main.fffef41",
+  "version": "0.8.4-staging.60fe92afc8",
   "description": "Natural language interface to DXOS",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
   "sideEffects": true,
   "type": "module",
@@ -12,67 +16,55 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     },
     "./extraction": {
       "source": "./src/extraction/index.ts",
       "types": "./dist/types/src/extraction/index.d.ts",
-      "browser": "./dist/lib/browser/extraction/index.mjs",
-      "node": "./dist/lib/node-esm/extraction/index.mjs"
+      "default": "./dist/lib/neutral/extraction/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "types": [
-        "dist/types/src/types/index.d.ts"
-      ],
-      "extraction": [
-        "dist/types/src/extraction/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@automerge/automerge": "3.1.2",
-    "@effect/ai": "0.29.1",
-    "@effect/experimental": "0.56.0",
-    "@effect/platform": "^0.92.1",
-    "@preact/signals-core": "^1.12.1",
+    "@automerge/automerge": "3.3.0-fragments.1",
+    "@effect-atom/atom": "^0.5.3",
+    "@effect-atom/atom-react": "^0.5.0",
+    "@effect/ai": "0.36.0",
+    "@effect/experimental": "0.60.0",
+    "@effect/platform": "0.96.1",
     "@xenova/transformers": "^2.17.2",
     "lodash.defaultsdeep": "^4.6.1",
-    "@dxos/ai": "0.8.4-main.fffef41",
-    "@dxos/async": "0.8.4-main.fffef41",
-    "@dxos/blueprints": "0.8.4-main.fffef41",
-    "@dxos/echo": "0.8.4-main.fffef41",
-    "@dxos/debug": "0.8.4-main.fffef41",
-    "@dxos/echo-db": "0.8.4-main.fffef41",
-    "@dxos/echo-protocol": "0.8.4-main.fffef41",
-    "@dxos/context": "0.8.4-main.fffef41",
-    "@dxos/effect": "0.8.4-main.fffef41",
-    "@dxos/errors": "0.8.4-main.fffef41",
-    "@dxos/functions": "0.8.4-main.fffef41",
-    "@dxos/functions-runtime": "0.8.4-main.fffef41",
-    "@dxos/graph": "0.8.4-main.fffef41",
-    "@dxos/invariant": "0.8.4-main.fffef41",
-    "@dxos/keys": "0.8.4-main.fffef41",
-    "@dxos/live-object": "0.8.4-main.fffef41",
-    "@dxos/node-std": "0.8.4-main.fffef41",
-    "@dxos/schema": "0.8.4-main.fffef41",
-    "@dxos/log": "0.8.4-main.fffef41",
-    "@dxos/types": "0.8.4-main.fffef41",
-    "@dxos/util": "0.8.4-main.fffef41"
+    "@dxos/ai": "0.8.4-staging.60fe92afc8",
+    "@dxos/async": "0.8.4-staging.60fe92afc8",
+    "@dxos/compute": "0.8.4-staging.60fe92afc8",
+    "@dxos/debug": "0.8.4-staging.60fe92afc8",
+    "@dxos/context": "0.8.4-staging.60fe92afc8",
+    "@dxos/echo": "0.8.4-staging.60fe92afc8",
+    "@dxos/echo-client": "0.8.4-staging.60fe92afc8",
+    "@dxos/effect": "0.8.4-staging.60fe92afc8",
+    "@dxos/echo-protocol": "0.8.4-staging.60fe92afc8",
+    "@dxos/errors": "0.8.4-staging.60fe92afc8",
+    "@dxos/functions": "0.8.4-staging.60fe92afc8",
+    "@dxos/graph": "0.8.4-staging.60fe92afc8",
+    "@dxos/log": "0.8.4-staging.60fe92afc8",
+    "@dxos/keys": "0.8.4-staging.60fe92afc8",
+    "@dxos/mcp-client": "0.8.4-staging.60fe92afc8",
+    "@dxos/node-std": "0.8.4-staging.60fe92afc8",
+    "@dxos/types": "0.8.4-staging.60fe92afc8",
+    "@dxos/schema": "0.8.4-staging.60fe92afc8",
+    "@dxos/util": "0.8.4-staging.60fe92afc8",
+    "@dxos/invariant": "0.8.4-staging.60fe92afc8"
   },
   "devDependencies": {
     "@types/lodash.defaultsdeep": "^4.6.6",
-    "effect": "3.18.3"
+    "effect": "3.21.3"
   },
   "peerDependencies": {
-    "effect": "^3.13.3"
+    "effect": "3.21.3"
   },
   "publishConfig": {
     "access": "public"

package/src/extraction/extraction-ner-function/index.ts

@@ -2,5 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './extraction-ner-function';
 export * from './named-entity-recognition';

package/src/extraction/extraction.ts

@@ -4,16 +4,15 @@
 
 import * as Schema from 'effect/Schema';
 
-import { asyncTimeout } from '@dxos/async';
-import { Expando } from '@dxos/echo/internal';
-import { type FunctionDefinition } from '@dxos/functions';
-import { type FunctionExecutor } from '@dxos/functions-runtime';
+import { Operation } from '@dxos/compute';
+import { Obj, Type } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { Message } from '@dxos/types';
 
 export const ExtractionInput = Schema.Struct({
-  message: Message.Message,
-  objects: Schema.optional(Schema.Array(Expando)),
+  message: Type.getSchema(Message.Message),
+  objects: Schema.optional(Schema.Array(Obj.Unknown)),
   options: Schema.optional(
     Schema.Struct({
       timeout: Schema.optional(Schema.Number),
@@ -21,18 +20,15 @@ export const ExtractionInput = Schema.Struct({
     }),
   ),
 });
-export interface ExtractionInput extends Schema.Schema.Type<typeof ExtractionInput> {}
-
+export type ExtractionInput = Schema.Schema.Type<typeof ExtractionInput>;
 export const ExtractionOutput = Schema.Struct({
-  message: Message.Message,
+  message: Type.getSchema(Message.Message),
   timeElapsed: Schema.Number,
 });
-export interface ExtractionOutput extends Schema.Schema.Type<typeof ExtractionOutput> {}
-
-export type ProcessTranscriptMessageParams = {
+export type ExtractionOutput = Schema.Schema.Type<typeof ExtractionOutput>;
+export type ProcessTranscriptMessageProps = {
   input: ExtractionInput;
-  function: FunctionDefinition<ExtractionInput, ExtractionOutput>;
-  executor: FunctionExecutor;
+  function: Operation.Definition<ExtractionInput, ExtractionOutput>;
 
   options?: {
     /**
@@ -49,18 +45,48 @@ export type ProcessTranscriptMessageParams = {
   };
 };
 
-export type ExtractionFunction = FunctionDefinition<ExtractionInput, ExtractionOutput>;
+export type ExtractionFunction = Operation.Definition<ExtractionInput, ExtractionOutput>;
+
+/**
+ * Placeholder for Anthropic-based entity extraction.
+ * Implementation is currently disabled pending restoration of extraction logic.
+ */
+export const extractionAnthropicFunction = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.extraction.anthropic'),
+    name: 'Entity Extraction (Anthropic)',
+    description: 'Extract entities from transcript using Anthropic LLM.',
+    icon: 'ph--text-t--regular',
+  },
+  input: ExtractionInput,
+  output: ExtractionOutput,
+});
+
+/**
+ * Placeholder for NER-based entity extraction.
+ * Implementation is currently disabled pending restoration of extraction logic.
+ */
+export const extractionNerFunction = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.extraction.ner'),
+    name: 'Entity Extraction (NER)',
+    description: 'Extract entities from transcript using Named Entity Recognition.',
+    icon: 'ph--text-t--regular',
+  },
+  input: ExtractionInput,
+  output: ExtractionOutput,
+});
 
 /**
  * Extract entities from the transcript message and add them to the message.
  */
 // TODO(dmaretskyi): Move context to a vector search index.
-export const processTranscriptMessage = async (params: ProcessTranscriptMessageParams): Promise<ExtractionOutput> => {
+export const processTranscriptMessage = async (params: ProcessTranscriptMessageProps): Promise<ExtractionOutput> => {
   try {
     if (params.options?.timeout && params.options.timeout > 0) {
-      return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);
+      // return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);
     } else {
-      return await params.executor.invoke(params.function, params.input);
+      // return await params.executor.invoke(params.function, params.input);
     }
   } catch (error) {
     if (params.options?.fallbackToRaw) {
@@ -73,4 +99,7 @@ export const processTranscriptMessage = async (params: ProcessTranscriptMessageP
       throw error;
     }
   }
+
+  // TODO(dmaretskyi): Restore extraction logic.
+  return { message: params.input.message, timeElapsed: 0 };
 };

package/src/extraction/index.ts

@@ -3,6 +3,5 @@
 //
 
 export * from './extraction';
-export * from './extraction-llm-function';
 export * from './extraction-ner-function';
 export * from './quotes';

package/src/extraction/quotes.test.ts

@@ -13,7 +13,7 @@ describe('insertReferences', () => {
     };
 
     expect(insertReferences('This is a computational irreducibility test.', quotes)).toBe(
-      'This is a [computational irreducibility](dxn:echo:@:01JTG9JW11XGWJZ32AW8ET93D1) test.',
+      'This is a [computational irreducibility](echo:/01JTG9JW11XGWJZ32AW8ET93D1) test.',
     );
     expect(
       insertReferences(
@@ -21,7 +21,7 @@ describe('insertReferences', () => {
         quotes,
       ),
     ).toBe(
-      "And what I'd like to talk today about is Steven Wolfram's concept of a [computational irreducibility](dxn:echo:@:01JTG9JW11XGWJZ32AW8ET93D1).",
+      "And what I'd like to talk today about is Steven Wolfram's concept of a [computational irreducibility](echo:/01JTG9JW11XGWJZ32AW8ET93D1).",
     );
   });
 });

package/src/extraction/quotes.ts

@@ -4,10 +4,8 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Filter, Query } from '@dxos/echo';
-import { ObjectId } from '@dxos/echo/internal';
-import { type EchoDatabase } from '@dxos/echo-db';
-import { DXN } from '@dxos/keys';
+import { type Database, Filter, Query } from '@dxos/echo';
+import { EID, EntityId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
 export const ReferencedQuotes = Schema.Struct({
@@ -28,10 +26,10 @@ export const ReferencedQuotes = Schema.Struct({
 });
 export type ReferencedQuotes = Schema.Schema.Type<typeof ReferencedQuotes>;
 
-export const findQuotes = async (quotes: string[], db: EchoDatabase): Promise<ReferencedQuotes> => {
+export const findQuotes = async (quotes: string[], db: Database.Database): Promise<ReferencedQuotes> => {
   const references = await Promise.all(
     quotes.map(async (quote) => {
-      const { objects } = await db.query(Query.select(Filter.text(quote, { type: 'vector' }))).run();
+      const objects = await db.query(Query.select(Filter.text(quote, { type: 'vector' }))).run();
       log.info('found quotes in vector index', { objects, quote });
       return objects.length > 0 ? [{ id: objects[0].id.toString(), quote }] : [];
     }),
@@ -45,13 +43,13 @@ export const findQuotes = async (quotes: string[], db: EchoDatabase): Promise<Re
 // TODO(dmaretskyi): Lookup and verifiy ids from provided context.
 export const insertReferences = (text: string, quotes: ReferencedQuotes) => {
   for (const quote of quotes.references) {
-    if (!ObjectId.isValid(quote.id)) {
+    if (!EntityId.isValid(quote.id)) {
       continue;
     }
 
     // Use a case-insensitive regular expression to replace the quote.
     const regex = new RegExp(quote.quote.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
-    text = text.replace(regex, `[${quote.quote}](${DXN.fromLocalObjectId(quote.id).toString()})`);
+    text = text.replace(regex, `[${quote.quote}](${EID.make({ entityId: quote.id })})`);
   }
 
   return text;

package/src/functions/services.ts

@@ -7,72 +7,68 @@ import type * as Toolkit from '@effect/ai/Toolkit';
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
 import * as Record from 'effect/Record';
 import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 
 import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { OpaqueToolkit } from '@dxos/ai';
+import { Operation } from '@dxos/compute';
 import { todo } from '@dxos/debug';
-import { Query } from '@dxos/echo';
-import { DatabaseService } from '@dxos/echo-db';
-import { Function, FunctionDefinition, FunctionInvocationService } from '@dxos/functions';
+import { DXN, Filter, Ref, Registry } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 
-/**
- * Constructs a `ToolResolverService` whose `resolve(id)` looks up tools in the following order:
- *  1. Toolkit: return an existing tool from the provided `toolkit` if one is present under `id`.
- *  2. Functions in DB: query `FunctionType` by `key=id`; if found, deserialize and project to a tool
- *     (propagating any `deployedFunctionId` discovered in the object's metadata).
- *  3. Functions passed in: fall back to a matching `FunctionDefinition` from the `functions` array.
- *
- * If none of the above yield a match, the effect fails with `AiToolNotFoundError`.
- *
- * Requires `DatabaseService` in the environment.
- */
-export const makeToolResolverFromFunctions = (
-  functions: FunctionDefinition.Any[],
-  toolkit: Toolkit.Toolkit<any>,
-): Layer.Layer<ToolResolverService, never, DatabaseService> => {
+import { RefFromLLM } from '../util';
+
+export const makeToolResolverFromOperations = <R = never>({
+  toolkit: extraToolkit = OpaqueToolkit.empty,
+}: { toolkit?: OpaqueToolkit.OpaqueToolkit<never, never, R> } = {}): Layer.Layer<
+  ToolResolverService,
+  never,
+  OpaqueToolkit.OpaqueToolkitProvider | Registry.Service | R
+> => {
   return Layer.effect(
     ToolResolverService,
     Effect.gen(function* () {
-      const dbService = yield* DatabaseService;
+      const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
+      const registry = yield* Registry.Service;
       return {
         resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>
           Effect.gen(function* () {
-            const tool = toolkit.tools[id];
+            const toolkit = OpaqueToolkit.merge(extraToolkit, toolkitProvider.getToolkit());
+
+            const tool = toolkit.toolkit.tools[id];
             if (tool) {
               return tool;
             }
 
-            const {
-              objects: [dbFunction],
-            } = yield* DatabaseService.runQuery(Query.type(Function.Function, { key: id }));
-
-            const functionDef = dbFunction
-              ? FunctionDefinition.deserialize(dbFunction)
-              : functions.find((fn) => fn.key === id);
-
-            if (!functionDef) {
-              return yield* Effect.fail(new AiToolNotFoundError(id));
+            // Normalize to a full DXN key (tool IDs are plain NSIDs, stored keys are full DXNs).
+            const key = DXN.isDXN(id) ? id : `dxn:${id}`;
+            const results = yield* Effect.promise(() =>
+              registry.query(Filter.and(Filter.type(Operation.PersistentOperation), Filter.key(key))).run(),
+            );
+            if (results.length > 0) {
+              return projectFunctionToTool(Operation.deserialize(results[0]));
             }
-
-            return projectFunctionToTool(functionDef);
-          }).pipe(Effect.provideService(DatabaseService, dbService)),
+            return yield* Effect.fail(new AiToolNotFoundError(id));
+          }),
       } satisfies Context.Tag.Service<ToolResolverService>;
     }),
   );
 };
 
-export const makeToolExecutionServiceFromFunctions = (
-  toolkit: Toolkit.Toolkit<any>,
-  handlersLayer: Layer.Layer<Tool.Handler<any>, never, never>,
-): Layer.Layer<ToolExecutionService, never, FunctionInvocationService> => {
-  return Layer.effect(
+export const makeToolExecutionService = <E, R>(opts: {
+  invoke: (tool: Tool.Any, input: unknown) => Effect.Effect<unknown>;
+}): Layer.Layer<ToolExecutionService, never, OpaqueToolkit.OpaqueToolkitProvider> =>
+  Layer.effect(
     ToolExecutionService,
     Effect.gen(function* () {
-      const toolkitHandler = yield* toolkit.pipe(Effect.provide(handlersLayer));
+      const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
+      const toolkit = toolkitProvider.getToolkit();
+
+      const toolkitHandler = yield* toolkit.toolkit.pipe(Effect.provide(toolkit.layer));
       invariant(isHandlerLike(toolkitHandler));
-      const functionInvocationService = yield* FunctionInvocationService;
 
       return {
         handlersFor: (toolkit) => {
@@ -82,16 +78,13 @@ export const makeToolExecutionServiceFromFunctions = (
                 if (Tool.isProviderDefined(tool)) {
                   throw new Error('Attempted to call a provider-defined tool');
                 }
+
                 // TODO(wittjosiah): Everything is `never` here.
                 const { result } = yield* (toolkitHandler.handle as any)(tool.name, input);
                 return result;
               }
 
-              const { definition: functionDef } = Context.get(FunctionToolAnnotation)(tool.annotations as any);
-
-              return yield* functionInvocationService
-                .invokeFunction(functionDef, input as any)
-                .pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
+              return yield* opts.invoke(tool, input).pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
             });
           };
 
@@ -102,36 +95,70 @@ export const makeToolExecutionServiceFromFunctions = (
       };
     }),
   );
+
+export const makeToolExecutionServiceFromOperationInvoker = (): Layer.Layer<
+  ToolExecutionService,
+  never,
+  Operation.Service | OpaqueToolkit.OpaqueToolkitProvider
+> => {
+  return Layer.unwrapEffect(
+    Effect.gen(function* () {
+      const operationInvoker = yield* Operation.Service;
+
+      return makeToolExecutionService({
+        invoke: (tool, input) =>
+          Effect.gen(function* () {
+            const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
+
+            return yield* operationInvoker.invoke(operationDef, input).pipe(Effect.orDie);
+          }),
+      });
+    }),
+  );
 };
 
+export const ToolExecutionServices = Layer.mergeAll(
+  makeToolResolverFromOperations(),
+  makeToolExecutionServiceFromOperationInvoker(),
+);
+
 class FunctionToolAnnotation extends Context.Tag('@dxos/assistant/FunctionToolAnnotation')<
   FunctionToolAnnotation,
-  { definition: FunctionDefinition.Any }
+  { definition: Operation.Definition.Any }
 >() {}
 
-const toolCache = new WeakMap<FunctionDefinition.Any, Tool.Any>();
+export const getOperationFromTool = (tool: Tool.Any): Option.Option<Operation.Definition.Any> => {
+  return Context.getOption(FunctionToolAnnotation)(tool.annotations).pipe(Option.map(({ definition }) => definition));
+};
+
+const toolCache = new WeakMap<Operation.Definition.Any, Tool.Any>();
 
 /**
- * Projects a `FunctionDefinition` into an `AiTool`.
- *
- * @param fn The function definition to project into a tool.
- * @param meta Optional projection metadata.
- * @param meta.deployedFunctionId Backend deployment ID used for remote invocation when present.
- *    This is the EDGE service's function deployment identifier (not the ECHO object ID/DXN and not `FunctionDefinition.key`).
+ * Empty parameters schema annotated with an explicit JSON schema so that
+ * @effect/ai versions that call JSONSchema.fromAST directly (≥0.35.0) still
+ * produce a valid `{type: "object"}` for the Anthropic API instead of the
+ * constEmptyStruct `{anyOf: [{type:"object"},{type:"array"}]}`.
  */
-const projectFunctionToTool = (fn: FunctionDefinition.Any): Tool.Any => {
+const EMPTY_PARAMETERS_SCHEMA = Schema.Struct({}).annotations({
+  [SchemaAST.JSONSchemaAnnotationId]: { type: 'object', properties: {}, required: [], additionalProperties: false },
+});
+
+/**
+ * Projects an `Operation.Definition` into an `AiTool`.
+ */
+const projectFunctionToTool = (fn: Operation.Definition.Any): Tool.Any => {
   if (toolCache.has(fn)) {
     return toolCache.get(fn)!;
   }
 
-  // TODO(burdon): Use and map function.key?
-  // TODO(dmaretskyi): Use function key instead.
-  const tool = Tool.make(makeToolName(fn.name), {
-    description: fn.description,
-    parameters: createStructFieldsFromSchema(fn.inputSchema),
-    // TODO(dmaretskyi): Include output schema.
-    failure: Schema.Any, // TODO(dmaretskyi): Better type for the failure?
-  }).annotate(FunctionToolAnnotation, { definition: fn });
+  const fields = createStructFieldsFromSchema(fn.input);
+  const parametersSchema = Object.keys(fields).length === 0 ? EMPTY_PARAMETERS_SCHEMA : Schema.Struct(fields);
+  const tool = Tool.make(makeToolName(fn.meta.name ?? fn.meta.key), {
+    description: fn.meta.description,
+    failure: Schema.Any,
+  })
+    .setParameters(parametersSchema)
+    .annotate(FunctionToolAnnotation, { definition: fn });
   toolCache.set(fn, tool);
   return tool;
 };
@@ -149,7 +176,9 @@ const makeToolName = (name: string) => {
 const createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<string, Schema.Schema<any, any>> => {
   switch (schema.ast._tag) {
     case 'TypeLiteral':
-      return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(prop.type)]));
+      return Object.fromEntries(
+        schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(mapSchemaTypeForLLM(prop.type))]),
+      );
     case 'VoidKeyword':
       return {};
     default:
@@ -157,6 +186,43 @@ const createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<s
   }
 };
 
+/**
+ * Picks an LLM-friendly schema type for the given schema AST.
+ * The picked schema type decodes to the original schema type.
+ */
+const mapSchemaTypeForLLM = (ast: SchemaAST.AST): SchemaAST.AST => {
+  if (Ref.isRefType(ast)) {
+    const description = ast.annotations.description
+      ? ast.annotations.description + '\n' + RefFromLLM.ast.annotations.description
+      : (RefFromLLM.ast.annotations.description as string);
+    return RefFromLLM.annotations({ description }).ast;
+  } else if (SchemaAST.isTupleType(ast)) {
+    return new SchemaAST.TupleType(
+      ast.elements.map((t) => new SchemaAST.OptionalType(mapSchemaTypeForLLM(t.type), t.isOptional, t.annotations)),
+      ast.rest.map((t) => new SchemaAST.Type(mapSchemaTypeForLLM(t.type), t.annotations)),
+      ast.isReadonly,
+      ast.annotations,
+    );
+  } else if (SchemaAST.isTypeLiteral(ast)) {
+    return new SchemaAST.TypeLiteral(
+      ast.propertySignatures.map(
+        (p) =>
+          new SchemaAST.PropertySignature(
+            p.name,
+            mapSchemaTypeForLLM(p.type),
+            p.isOptional,
+            p.isReadonly,
+            p.annotations,
+          ),
+      ),
+      ast.indexSignatures,
+      ast.annotations,
+    );
+  }
+
+  return ast;
+};
+
 const isHandlerLike = (value: unknown): value is Toolkit.WithHandler<Record<string, Tool.Any>> => {
   return typeof (value as any).tools === 'object' && typeof (value as any).handle === 'function';
 };

package/src/index.ts

@@ -2,11 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './conversation';
-export * from './diff';
-export * from './errors';
-export * from './execution-graph';
 export * from './functions';
+export * from './request';
 export * from './session';
 export * from './templates';
-export * from './types';
+export * from './util';