@dxos/assistant 0.8.4-main.84f28bd → 0.8.4-main.9735255

package/src/session/toolkit.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
+import * as Effect from 'effect/Effect';
+
+import { type AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { type Blueprint } from '@dxos/blueprints';
+import { isTruthy } from '@dxos/util';
+
+export type CreateToolkitProps = {
+  toolkit?: Toolkit.Any;
+  blueprints?: readonly Blueprint.Blueprint[];
+};
+
+/**
+ * Build a combined toolkit from the blueprint tools and the provided toolkit.
+ */
+export const createToolkit = ({
+  toolkit: toolkitProp,
+  blueprints = [],
+}: CreateToolkitProps): Effect.Effect<
+  Toolkit.WithHandler<any>,
+  AiToolNotFoundError,
+  ToolResolverService | ToolExecutionService | Tool.HandlersFor<any>
+> =>
+  Effect.gen(function* () {
+    const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap(({ tools }) => tools));
+    const blueprintToolHandler = yield* blueprintToolkit.toContext(ToolExecutionService.handlersFor(blueprintToolkit));
+
+    const toolkit = Toolkit.merge(...[toolkitProp, blueprintToolkit].filter(isTruthy));
+    return yield* toolkit.pipe(Effect.provide(blueprintToolHandler)) as any as Effect.Effect<
+      Toolkit.WithHandler<any>,
+      never,
+      Tool.HandlersFor<any>
+    >;
+  });

package/src/session/version-pin.ts

@@ -2,12 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { type MessageContentBlock } from '@dxos/ai';
-import { type ObjectVersion } from '@dxos/echo-db';
-import { getVersion } from '@dxos/echo-db';
-import { ObjectId, type BaseEchoObject } from '@dxos/echo-schema';
+import { type Obj } from '@dxos/echo';
+import { type ObjectVersion, getVersion } from '@dxos/echo-db';
+import { ObjectId } from '@dxos/keys';
+import { type ContentBlock } from '@dxos/types';
 
 // TODO(dmaretskyi): Extract.
 const ObjectVersionSchema = Schema.Unknown as Schema.Schema<ObjectVersion>;
@@ -15,7 +15,7 @@ const ObjectVersionSchema = Schema.Unknown as Schema.Schema<ObjectVersion>;
 const VersionPinSchema = Schema.Struct({
   // TODO(dmaretskyi): Use Ref when those support encoding.
   objectId: ObjectId,
-  // TODO(dmaretskyi): Could be opaque
+  // TODO(dmaretskyi): Could be opaque.
   version: ObjectVersionSchema,
 });
 
@@ -27,22 +27,22 @@ export interface VersionPin extends Schema.Schema.Type<typeof VersionPinSchema>
 
 export const VersionPin: typeof VersionPinSchema & {
   DISPOSITION: 'version-pin';
-  fromObject: (object: BaseEchoObject) => VersionPin;
-  createBlock: (pin: VersionPin) => MessageContentBlock;
+  fromObject: (object: Obj.Unknown) => VersionPin;
+  createBlock: (pin: VersionPin) => ContentBlock.Any;
 } = class extends VersionPinSchema {
   static readonly DISPOSITION = 'version-pin';
-  static fromObject(object: BaseEchoObject): VersionPin {
+  static fromObject(object: Obj.Unknown): VersionPin {
     return VersionPin.make({
       objectId: object.id,
       version: getVersion(object),
     });
   }
 
-  static createBlock(pin: VersionPin): MessageContentBlock {
+  static createBlock(pin: VersionPin): ContentBlock.Any {
     return {
-      type: 'json',
+      _tag: 'json',
       disposition: VersionPin.DISPOSITION,
-      json: JSON.stringify(pin),
+      data: JSON.stringify(pin),
     };
   }
 };

package/src/templates/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './system';

package/src/templates/instructions/format.tpl

@@ -0,0 +1,61 @@
+{{! System Core }}
+
+## Input Formats
+
+### Blueprints
+
+You may be provided with Blueprint definitions that include specific instructions and tools for a given set of tasks.
+Blue print instructions will be enclosed in a <blueprint> tag.
+
+### Context objects
+
+You may be provided with references to objects that are relevant to the current prompt.
+Objects will be in the form of a <object> tag with a <dxn> element that is the unique key of the object required by many tools.
+The <typename> element is the type of the object.
+
+<object>
+  <dxn>object-id</dxn>
+  <typename>example.com/type/TypeName</typename>
+</object>
+
+## Response Formats
+
+It is very important to respond in the correct format.
+You response must be valid Markdown.
+In some cases you should respond with well-formed XML tags along with the content.
+Code snippets should use 2-space indents.
+
+{{#if cot}}
+Before responding, explain your reasoning and include your detailed chain-of-thought enclosed in a <cot> tag.
+The <cot> tag should be the first thing in your response.
+{{/if}}
+
+## Block references
+
+You can reply with a block reference for objects if you have the DXN. For example:
+
+<object>
+  <dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn>
+</object>
+<object>
+  <dxn>dxn:echo:@:01K24XPK464FSCKVQJAB2H662M</dxn>
+</object>
+
+### Suggestions
+
+Each suggestion must in the form of a proposed action enclosed in a <suggestion> tag.
+Example: <suggestion>Show on a map</suggestion>
+Do not use bullets when listing suggestions.
+
+### Multiple choice questions
+
+You may ask multiple choice questions by wrapping consise options inside <option> tags inside a well formed <select> tag.
+Example: <select><option>Yes</option><option>No</option></select>
+
+## Toolkit
+
+If the user asks for a list of tools, then just emit a single self-closing <toolkit/> tag instead of listing the tools.
+
+## Context
+
+The current date and time is {{DATETIME}}.

package/src/templates/instructions/system.tpl

@@ -0,0 +1,48 @@
+{{! System Prompt }}
+
+- You are a helpful assistant called Kai. 
+- Your name is Kai and you are powered by different language models.
+- You were created by DXOS and operate inside of Composer and on the DXOS EDGE network.
+- In your initial greeting state your name and make some suggestions based on the current context objects.
+- You are an advanced AI assistant capable of creating and managing artifacts from provided data and tools.
+- Your task is to process user commands and questions and decide how best to respond.
+- In general be concise and direct.
+- Follow all instructions carefully.
+
+## Planning
+
+- Analyze the structure and type of the content in the user's message.
+- Determine if you complete the task using the available blueprint definitions?
+- If you can't complete the task using the available blueprint definitions, query the list of available blueprint definitions using the appropriate tool.
+- Identify which blueprint definitions are relevant to the user's request.
+- Evaluate the potential benefits of creating an artifact vs. normal processing for each identified element.
+- Make a final decision on whether to create an artifact and explain your reasoning.
+- Are the required blueprint definitions already available?
+- If not, select which blueprint definition(s) will be the most relevant and require them using the require_artifact_definitions tool.
+- The require'd artifact tools will be available for use after require.
+- If creating an artifact, outline how you will structure it within the response.
+- Decide if the artifact needs to be shown to the user.
+- Call the show tool to show the artifact to the user.
+- Your reasoning must include: whether to use artifacts or not, to create one or query, whether to show the artifact to the user, and how to structure the response.
+
+## Blueprints and Artifacts
+
+- Determine if the interaction involves an artifact. Prefer artifacts for tables, lists, spreadsheets, kanbans, games, images, and other structured data.
+- Determine if the user is explicitly talking about creating a new artifact, or wants to use an existing artifact.
+- If it is ambiguous, query for existing artifacts first and then decide.
+- If you decide to create an artifact, call the associated tool to create the artifact.
+- Artifacts are stored in the database. Tools are used to create and query artifacts.
+- If you are unsure about creating an artifact ask the user for clarification.
+- Artifacts are mutable objects that can change over the course of the conversation.
+- Always re-query the artifact using the tool (like query or inspect) to get the latest state of the artifact before answering the user.
+- You must never generate the id of the artifact; only recall the ids that are already in the history.
+- Artifacts are created by requiring the specific artifact using the require_artifact tool and creating it by calling the associated tool.
+- You can add suggested actions at the end of your response.
+- Suggested actions should be very concise and start with a verb and be phrased as a command to an agent -- not a question to the user.
+- Suggested actions must be in the form of a user instruction that you can follow.
+- Suggested actions could include actions that create artifacts.
+- After creating an artifact use a tool to add it to the chat context.
+
+## Context
+
+Today is {{DATETIME}}.

package/src/templates/system.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import defaultsDeep from 'lodash.defaultsdeep';
+
+import { type ModelCapabilities } from '@dxos/ai';
+import { Template } from '@dxos/blueprints';
+
+import FORMAT from './instructions/format.tpl?raw';
+import SYSTEM from './instructions/system.tpl?raw';
+
+/**
+ * System template variables.
+ */
+export type SystemPromptOptions = ModelCapabilities & {
+  DATETIME: string;
+};
+
+/**
+ * Base system prompt.
+ * NOTE: This contains protocol instructions that can not be dynamically edited.
+ */
+export const createSystemPrompt = (options: Partial<SystemPromptOptions> = {}) =>
+  Template.process<SystemPromptOptions>(
+    FORMAT,
+    defaultsDeep(options, {
+      DATETIME: new Date().toISOString(),
+    }),
+  );
+
+export const templates = {
+  /** Editable system prompt.*/
+  system: Template.make({
+    /**
+     * NOTE: We are forbidden from accessing randomness at model level in cloudflare, so we have to have pre-generated ids.
+     */
+    id: '01K2J2FZWH39F55CS7B26GP1Q3',
+    source: SYSTEM,
+  }),
+};

package/src/testing/index.ts

@@ -1,11 +1,5 @@
 //
-// Copyright 2025 DXOS.org
+// Copyright 2026 DXOS.org
 //
 
-import type { SearchResponse } from 'exa-js';
-
-import Search1 from './exa-search-1748337321991';
-import Search2 from './exa-search-1748337331526';
-import Search3 from './exa-search-1748337344119';
-
-export const SEARCH_RESULTS: SearchResponse<any>[] = [Search1, Search2, Search3];
+export * from './layer';

package/src/testing/layer.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Layer from 'effect/Layer';
+import * as Match from 'effect/Match';
+
+import { AiService, type ModelName } from '@dxos/ai';
+import { TestAiService } from '@dxos/ai/testing';
+import type { Type } from '@dxos/echo';
+import { CredentialsService, type FunctionDefinition, type ServiceCredential, TracingService } from '@dxos/functions';
+import { TracingServiceExt, TriggerDispatcher, TriggerStateStore } from '@dxos/functions-runtime';
+import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
+
+import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '../functions';
+import { GenericToolkit } from '../session';
+
+interface TestLayerOptions {
+  aiServicePreset?: 'direct' | 'edge-local' | 'edge-remote';
+  model?: ModelName;
+  functions?: FunctionDefinition.Any[];
+  toolkits?: GenericToolkit.GenericToolkit[];
+  types?: Type.Entity.Any[];
+  credentials?: ServiceCredential[];
+  /*
+   * Tracing configuration.
+   * @default 'noop'
+   */
+  tracing?: 'noop' | 'console' | 'pretty';
+}
+
+export const AssistantTestLayer = ({
+  aiServicePreset = 'direct',
+  model = '@anthropic/claude-opus-4-0',
+  functions = [],
+  toolkits = [],
+  types = [],
+  credentials = [],
+  tracing = 'noop',
+}: TestLayerOptions) =>
+  Layer.mergeAll(
+    AiService.model(model),
+    makeToolResolverFromFunctions(functions, GenericToolkit.merge(...toolkits).toolkit as any),
+    makeToolExecutionServiceFromFunctions(
+      GenericToolkit.merge(...toolkits).toolkit as any,
+      GenericToolkit.merge(...toolkits).layer as any,
+    ),
+  ).pipe(
+    Layer.provideMerge(
+      FunctionInvocationServiceLayerTest({
+        functions,
+      }),
+    ),
+    Layer.provideMerge(
+      Layer.mergeAll(
+        TestAiService({ preset: aiServicePreset }),
+        TestDatabaseLayer({
+          spaceKey: 'fixed',
+          types,
+        }),
+        CredentialsService.configuredLayer(credentials),
+        Match.value(tracing).pipe(
+          Match.when('noop', () => TracingService.layerNoop),
+          Match.when('console', () => TracingServiceExt.layerLogInfo()),
+          Match.when('pretty', () => TracingServiceExt.layerConsolePrettyPrint()),
+          Match.exhaustive,
+        ),
+      ),
+    ),
+  );
+
+interface TestLayerWithTriggersOptions extends TestLayerOptions {}
+
+export const AssistantTestLayerWithTriggers = (options: TestLayerWithTriggersOptions) =>
+  Layer.mergeAll(
+    AssistantTestLayer(options),
+    TriggerDispatcher.layer({ timeControl: 'manual', startingTime: new Date('2025-09-05T15:01:00.000Z') }),
+  ).pipe(Layer.provideMerge(TriggerStateStore.layerMemory));

package/src/types/artifact.ts

@@ -0,0 +1,82 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { type Err, Type } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { EncodedReference } from '@dxos/echo-protocol';
+import { DXN, LOCAL_SPACE_TAG, type ObjectId, type SpaceId } from '@dxos/keys';
+import { trim } from '@dxos/util';
+
+/**
+ * @deprecated
+ */
+export const createArtifactElement = (id: ObjectId) => `<artifact id=${id} />`;
+
+/**
+ * A model-friendly way to reference an object.
+ * Supports vairous formats that will be normalized to a DXN.
+ *
+ * @deprecated Use `RefFromLLM` instead.
+ */
+// TODO(burdon): Rename RefFromLLM? -- yes -dm
+export const ArtifactId: Schema.Schema<string> & {
+  toDXN: (reference: ArtifactId, owningSpaceId?: SpaceId) => DXN;
+  resolve: <S extends Type.Entity.Any>(
+    schema: S,
+    ref: ArtifactId,
+  ) => Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Database.Service>;
+} = class extends Schema.String.annotations({
+  // TODO(dmaretskyi): This section gets overriden.
+  description: trim`
+    The ID of the referenced object. Formats accepted:
+    - DXN (dxn:echo:@:XXXXX). DXNs can be prepended with an @ symbol for compatibility with in-text references.
+    - space ID, object ID tuple (spaceID:objectID)
+    - Only object ID that is assumed to be in the current space (XXXXX)
+  `,
+  examples: ['dxn:echo:@:XXXXX', '@dxn:echo:@:XXXXX', 'spaceID:objectID', 'XXXXX'],
+}) {
+  static toDXN(reference: ArtifactId, owningSpaceId?: SpaceId): DXN {
+    // Allow @dxn: prefix for compatibility with in-text references.
+    if (reference.startsWith('@dxn:')) {
+      return DXN.parse(reference.slice(1));
+    } else if (reference.startsWith('dxn:')) {
+      return DXN.parse(reference);
+    } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {
+      const [spaceId, objectId] = reference.split(':');
+      // This is a workaround because the current Filter API doesn't work with fully qualified Echo DXNs.
+      // We check if the space ID is the same as the owning space and then use LOCAL_SPACE_TAG for local references.
+      // TODO(dmaretskyi): Fix this in the Echo and Filter API to properly handle fully qualified DXNs.
+      return new DXN(DXN.kind.ECHO, [spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId, objectId]);
+    } else if (/^[A-Z0-9]+$/.test(reference)) {
+      return DXN.fromLocalObjectId(reference);
+    } else {
+      throw new Error(`Unable to parse object reference: ${reference}`);
+    }
+  }
+
+  /**
+   * Resolves an artifact ID to an object.
+   */
+  static resolve<S extends Type.Entity.Any>(
+    schema: S,
+    ref: ArtifactId,
+  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Database.Service> {
+    const dxn = ArtifactId.toDXN(ref);
+    return Database.Service.resolve(dxn, schema);
+  }
+};
+
+export type ArtifactId = Schema.Schema.Type<typeof ArtifactId>;
+
+/**
+ * Schema that decodes ECHO reference object from an LLM-friendly input.
+ */
+export const RefFromLLM = Schema.transform(ArtifactId, Type.Ref(Type.Obj), {
+  decode: (fromA, fromI) => EncodedReference.fromDXN(ArtifactId.toDXN(fromA)),
+  encode: (toI, toA) => EncodedReference.toDXN(toI).toString(),
+  strict: false,
+});

package/src/types/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './artifact';

package/src/typings.d.ts

@@ -2,6 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
+declare module '*?raw' {
+  const content: string;
+  export default content;
+}
+
 declare module '*.tpl?raw' {
   const content: string;
   export default content;

package/dist/types/bin/chat.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=chat.d.ts.map

package/dist/types/bin/chat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../bin/chat.ts"],"names":[],"mappings":""}

package/dist/types/src/blueprint/blueprint.d.ts

@@ -1,41 +0,0 @@
-import { Schema } from 'effect';
-import { Type } from '@dxos/echo';
-/**
- * Blueprint schema defines the structure for AI assistant blueprints.
- * Blueprints contain instructions, tools, and artifacts that guide the AI's behavior.
- */
-export declare const Blueprint: Type.obj<Schema.Struct<{
-    /**
-     * Global registry ID.
-     * NOTE: Once a blueprint has been cloned from the registry, its stored definition may converge,
-     * but the `key` property refers to the original registry entry.
-     */
-    key: Schema.SchemaClass<string, string, never>;
-    /**
-     * Human-readable name of the blueprint.
-     */
-    name: Schema.SchemaClass<string, string, never>;
-    /**
-     * Description of the blueprint's purpose and functionality.
-     */
-    description: Schema.optional<typeof Schema.String>;
-    /**
-     * Instructions that guide the AI assistant's behavior and responses.
-     * These are system prompts or guidelines that the AI should follow.
-     */
-    instructions: Schema.SchemaClass<string, string, never>;
-    /**
-     * Array of tools that the AI assistant can use when this blueprint is active.
-     */
-    tools: Schema.Array$<Schema.SchemaClass<string, string, never>>;
-    /**
-     * Array of artifacts that the AI assistant can create or modify.
-     */
-    artifacts: Schema.Array$<typeof Schema.String>;
-}>>;
-/**
- * TypeScript type for Blueprint.
- */
-export interface Blueprint extends Schema.Schema.Type<typeof Blueprint> {
-}
-//# sourceMappingURL=blueprint.d.ts.map

package/dist/types/src/blueprint/blueprint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blueprint.d.ts","sourceRoot":"","sources":["../../../../src/blueprint/blueprint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGlC;;;GAGG;AACH,eAAO,MAAM,SAAS;IACpB;;;;OAIG;;IAMH;;OAEG;;IAKH;;OAEG;;IAKH;;;OAGG;;IAKH;;OAEG;;IAKH;;OAEG;;GAaJ,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC;CAAG"}

package/dist/types/src/blueprint/index.d.ts

@@ -1,3 +0,0 @@
-export * from './blueprint';
-export * from './registry';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/blueprint/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/blueprint/index.ts"],"names":[],"mappings":"AAIA,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/types/src/blueprint/registry.d.ts

@@ -1,7 +0,0 @@
-import { type Blueprint } from './blueprint';
-export declare class BlueprintRegistry {
-    private readonly _blueprints;
-    constructor(_blueprints: Blueprint[]);
-    query(): Blueprint[];
-}
-//# sourceMappingURL=registry.d.ts.map

package/dist/types/src/blueprint/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/blueprint/registry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,SAAS,EAAE;IAIrD,KAAK,IAAI,SAAS,EAAE;CAGrB"}

package/dist/types/src/context/binder.d.ts

@@ -1,34 +0,0 @@
-import { type ReadonlySignal } from '@preact/signals-core';
-import { type Type, type Ref } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
-import { ComplexSet } from '@dxos/util';
-import { type Blueprint } from '../blueprint';
-/**
- * Manages bindings of blueprints and objects to a conversation.
- */
-export declare class ContextBinder {
-    private readonly _queue;
-    constructor(_queue: Queue);
-    /**
-     * Reactive query of all bindings.
-     */
-    readonly bindings: ReadonlySignal<Bindings>;
-    readonly blueprints: ReadonlySignal<Ref.Ref<Blueprint>[]>;
-    readonly objects: ReadonlySignal<Ref.Ref<Type.Expando>[]>;
-    /**
-     * Asynchronous query of all bindings.
-     */
-    query(): Promise<Bindings>;
-    bind(props: BindingProps): Promise<void>;
-    unbind(props: BindingProps): Promise<void>;
-    private _reduce;
-}
-export type BindingProps = Partial<{
-    blueprints: Ref.Ref<Blueprint>[];
-    objects: Ref.Ref<Type.Expando>[];
-}>;
-export declare class Bindings {
-    blueprints: ComplexSet<Ref.Ref<Blueprint>>;
-    objects: ComplexSet<Ref.Ref<Type.Expando>>;
-}
-//# sourceMappingURL=binder.d.ts.map

package/dist/types/src/context/binder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binder.d.ts","sourceRoot":"","sources":["../../../../src/context/binder.ts"],"names":[],"mappings":"AAIA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGrE,OAAO,EAAO,KAAK,IAAI,EAAE,KAAK,GAAG,EAAiB,MAAM,YAAY,CAAC;AACrE,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;GAEG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,KAAK;IAE1C;;OAEG;IAEH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAqD;IAGhG,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAuD;IAChH,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAoD;IAE7G;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,QAAQ,CAAC;IAM1B,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxC,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBhD,OAAO,CAAC,OAAO;CAahB;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC;IACjC,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;IACjC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;CAClC,CAAC,CAAC;AAEH,qBAAa,QAAQ;IACnB,UAAU,iCAAmE;IAC7E,OAAO,oCAAsE;CAC9E"}

package/dist/types/src/context/binding.d.ts

@@ -1,38 +0,0 @@
-import { Schema } from 'effect';
-import { Type } from '@dxos/echo';
-/**
- * Thread message that binds or unbinds contextual objects to a conversation.
- */
-export declare const ContextBinding: Type.obj<Schema.Struct<{
-    blueprints: Schema.Struct<{
-        added: Schema.Array$<Type.ref<Type.obj<Schema.Struct<{
-            key: Schema.SchemaClass<string, string, never>;
-            name: Schema.SchemaClass<string, string, never>;
-            description: Schema.optional<typeof Schema.String>;
-            instructions: Schema.SchemaClass<string, string, never>;
-            tools: Schema.Array$<Schema.SchemaClass<string, string, never>>;
-            artifacts: Schema.Array$<typeof Schema.String>;
-        }>>>>;
-        removed: Schema.Array$<Type.ref<Type.obj<Schema.Struct<{
-            key: Schema.SchemaClass<string, string, never>;
-            name: Schema.SchemaClass<string, string, never>;
-            description: Schema.optional<typeof Schema.String>;
-            instructions: Schema.SchemaClass<string, string, never>;
-            tools: Schema.Array$<Schema.SchemaClass<string, string, never>>;
-            artifacts: Schema.Array$<typeof Schema.String>;
-        }>>>>;
-    }>;
-    objects: Schema.Struct<{
-        added: Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-            [x: string]: any;
-            id: string;
-        }, never>>>;
-        removed: Schema.Array$<Type.ref<Schema.Schema<Type.Expando, {
-            [x: string]: any;
-            id: string;
-        }, never>>>;
-    }>;
-}>>;
-export interface ContextBinding extends Schema.Schema.Type<typeof ContextBinding> {
-}
-//# sourceMappingURL=binding.d.ts.map

package/dist/types/src/context/binding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../../src/context/binding.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGlC;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgB1B,CAAC;AAEF,MAAM,WAAW,cAAe,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,cAAc,CAAC;CAAG"}

package/dist/types/src/context/index.d.ts

@@ -1,3 +0,0 @@
-export * from './binder';
-export * from './binding';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/context/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/context/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}

package/dist/types/src/research/exa.d.ts

@@ -1,7 +0,0 @@
-type CreateExaToolOptions = {
-    apiKey: string;
-};
-export declare const createExaTool: ({ apiKey }: CreateExaToolOptions) => import("@dxos/ai").ExecutableTool;
-export declare const createMockExaTool: () => import("@dxos/ai").ExecutableTool;
-export {};
-//# sourceMappingURL=exa.d.ts.map

package/dist/types/src/research/exa.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exa.d.ts","sourceRoot":"","sources":["../../../../src/research/exa.ts"],"names":[],"mappings":"AAYA,KAAK,oBAAoB,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,YAAY,oBAAoB,sCAuB7D,CAAC;AAEF,eAAO,MAAM,iBAAiB,yCAkC7B,CAAC"}