@statelyai/agent 0.0.2 → 0.0.4

package/src/{openai.ts → adapters/openai.ts}

@@ -1,24 +1,15 @@
-import OpenAI from 'openai';
+import type OpenAI from 'openai';
 import {
   AnyEventObject,
   ObservableActorLogic,
   Observer,
   PromiseActorLogic,
-  Values,
   fromObservable,
   fromPromise,
-  setup,
+  isMachineSnapshot,
   toObserver,
 } from 'xstate';
-import { getAllTransitions } from './utils';
-import {
-  ContextSchema,
-  EventSchemas,
-  ConvertContextToJSONSchema,
-  ConvertToJSONSchemas,
-  createEventSchemas,
-} from './utils';
-import { FromSchema } from 'json-schema-to-ts';
+import { getAllTransitions } from '../utils';
 import { ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
 import {
   ChatCompletionCreateParamsBase,
@@ -34,6 +25,7 @@ import {
  */
 export function fromChatCompletion<TInput>(
   openai: OpenAI,
+  agentSettings: OpenAIAdapterOutput<any>,
   inputFn: (
     input: TInput
   ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming
@@ -44,7 +36,7 @@ export function fromChatCompletion<TInput>(
       const params: ChatCompletionCreateParamsNonStreaming =
         typeof openAiInput === 'string'
           ? {
-              model: 'gpt-3.5-turbo-1106',
+              model: agentSettings.model,
               messages: [
                 {
                   role: 'user',
@@ -66,8 +58,9 @@ export function fromChatCompletion<TInput>(
  * @param openai The OpenAI instance to use.
  * @param inputFn A function that maps arbitrary input to OpenAI chat completion input.
  */
-export function fromChatCompletionStream<TInput>(
+export function fromChatStream<TInput>(
   openai: OpenAI,
+  agentSettings: OpenAIAdapterOutput<any>,
   inputFn: (
     input: TInput
   ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming
@@ -81,7 +74,7 @@ export function fromChatCompletionStream<TInput>(
         const resolvedParams: ChatCompletionCreateParamsBase =
           typeof openAiInput === 'string'
             ? {
-                model: 'gpt-3.5-turbo-1106',
+                model: agentSettings.model,
                 messages: [
                   {
                     role: 'user',
@@ -126,13 +119,29 @@ export function fromChatCompletionStream<TInput>(
  */
 export function fromEventChoice<TInput>(
   openai: OpenAI,
-  machineTypes: { schemas: { context: ContextSchema; events: EventSchemas } },
+  agentSettings: OpenAIAdapterOutput<any>,
   inputFn: (
     input: TInput
-  ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming
+  ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming,
+  options?: {
+    /**
+     * Immediately execute sending the event to the parent actor.
+     * @default false
+     */
+    execute?: boolean;
+  }
 ) {
   return fromPromise<AnyEventObject[] | undefined, TInput>(
-    async ({ input, self }) => {
+    async ({ input, self, system }) => {
+      const parentSnapshot = self._parent?.getSnapshot();
+
+      if (!parentSnapshot || !isMachineSnapshot(parentSnapshot)) {
+        return undefined;
+      }
+
+      const schemas = parentSnapshot.machine.schemas as any;
+      const eventSchemaMap = schemas.events ?? {};
+
       const transitions = getAllTransitions(self._parent!.getSnapshot());
       const functionNameMapping: Record<string, string> = {};
       const tools = transitions
@@ -147,12 +156,10 @@ export function fromEventChoice<TInput>(
             function: {
               name,
               description:
-                t.description ??
-                machineTypes.schemas.events[t.eventType]?.description,
+                t.description ?? eventSchemaMap[t.eventType]?.description,
               parameters: {
                 type: 'object',
-                properties:
-                  machineTypes.schemas.events[t.eventType]?.properties ?? {},
+                properties: eventSchemaMap[t.eventType]?.properties ?? {},
               },
             },
           } as const;
@@ -162,7 +169,7 @@ export function fromEventChoice<TInput>(
       const completionParams: ChatCompletionCreateParamsNonStreaming =
         typeof openAiInput === 'string'
           ? {
-              model: 'gpt-4-1106-preview',
+              model: agentSettings.model,
               messages: [
                 {
                   role: 'user',
@@ -179,12 +186,19 @@ export function fromEventChoice<TInput>(
       const toolCalls = completion.choices[0]?.message.tool_calls;
 
       if (toolCalls) {
-        return toolCalls.map((tc) => {
+        const events = toolCalls.map((tc) => {
           return {
             type: functionNameMapping[tc.function.name],
             ...JSON.parse(tc.function.arguments),
           };
         });
+
+        if (options?.execute) {
+          events.forEach((event) => {
+            // @ts-ignore
+            system._relay(self, self._parent, event);
+          });
+        }
       }
 
       return undefined;
@@ -192,29 +206,35 @@ export function fromEventChoice<TInput>(
   );
 }
 
-interface CreateAgentOutput<
+interface OpenAIAdapterOutput<
   T extends {
     model: ChatCompletionCreateParamsBase['model'];
-    context: ContextSchema;
-    events: EventSchemas;
   }
 > {
   model: T['model'];
-  schemas: T;
-  types: {
-    context: FromSchema<ConvertContextToJSONSchema<T['context']>>;
-    events: FromSchema<Values<ConvertToJSONSchemas<T['events']>>>;
-  };
+  /**
+   * Determines which event to send to the parent state machine actor based on the prompt.
+   */
   fromEventChoice: <TInput>(
-    inputFn: (input: TInput) => string | ChatCompletionCreateParamsNonStreaming
-  ) => PromiseActorLogic<
-    FromSchema<Values<ConvertToJSONSchemas<T['events']>>>[] | undefined,
-    TInput
-  >;
-  fromChatCompletion: <TInput>(
+    inputFn: (input: TInput) => string | ChatCompletionCreateParamsNonStreaming,
+    options?: {
+      /**
+       * Immediately execute sending the event to the parent actor.
+       * @default true
+       */
+      execute?: boolean;
+    }
+  ) => PromiseActorLogic<AnyEventObject[] | undefined, TInput>;
+  /**
+   * Creates promise actor logic that resolves with a chat completion.
+   */
+  fromChat: <TInput>(
     inputFn: (input: TInput) => string | ChatCompletionCreateParamsNonStreaming
   ) => PromiseActorLogic<OpenAI.Chat.Completions.ChatCompletion, TInput>;
-  fromChatCompletionStream: <TInput>(
+  /**
+   * Creates observable actor logic that emits a chat completion stream.
+   */
+  fromChatStream: <TInput>(
     inputFn: (input: TInput) => string | ChatCompletionCreateParamsStreaming
   ) => ObservableActorLogic<
     OpenAI.Chat.Completions.ChatCompletionChunk,
@@ -222,29 +242,19 @@ interface CreateAgentOutput<
   >;
 }
 
-export function createAgent<
+export function createOpenAIAdapter<
   T extends {
     model: ChatCompletionCreateParamsBase['model'];
-    context: ContextSchema;
-    events: EventSchemas;
   }
->(openai: OpenAI, settings: T): CreateAgentOutput<T> {
-  const obj: CreateAgentOutput<T> = {
+>(openai: OpenAI, settings: T): OpenAIAdapterOutput<T> {
+  const agentSettings: OpenAIAdapterOutput<T> = {
     model: settings.model,
-    schemas: {
-      context: {
-        type: 'object',
-        properties: settings.context,
-        additionalProperties: false,
-      },
-      events: createEventSchemas(settings.events),
-    } as any,
-    types: {} as any,
-    fromEventChoice: (input) => fromEventChoice(openai, obj, input) as any,
-    fromChatCompletion: (input) => fromChatCompletion(openai, input),
-    fromChatCompletionStream: (input) =>
-      fromChatCompletionStream(openai, input),
+    fromEventChoice: (input) =>
+      // @ts-ignore infinitely deep
+      fromEventChoice(openai, agentSettings, input, { execute: true }) as any,
+    fromChat: (input) => fromChatCompletion(openai, agentSettings, input),
+    fromChatStream: (input) => fromChatStream(openai, agentSettings, input),
   };
 
-  return obj as any;
+  return agentSettings;
 }

package/src/agent.ts

@@ -0,0 +1,8 @@
+import { ActorOptions, AnyStateMachine, createActor } from 'xstate';
+
+export function createAgent<T extends AnyStateMachine>(
+  ...args: Parameters<typeof createActor<T>>
+) {
+  const [machine, options] = args;
+  return createActor(machine, options);
+}

package/src/index.ts

@@ -1,6 +1,3 @@
-export {
-  fromChatCompletion,
-  fromChatCompletionStream,
-  fromEventChoice,
-  createAgent,
-} from './openai';
+export { createSchemas } from './schemas';
+export { createAgent } from './agent';
+export { createOpenAIAdapter } from './adapters/openai';

package/src/schemas.ts

@@ -0,0 +1,38 @@
+import { Values } from 'xstate';
+import {
+  ContextSchema,
+  EventSchemas,
+  ConvertContextToJSONSchema,
+  ConvertToJSONSchemas,
+  createEventSchemas,
+} from './utils';
+import { FromSchema } from 'json-schema-to-ts';
+
+export function createSchemas<
+  TContextSchema extends ContextSchema,
+  TEventSchemas extends EventSchemas
+>({
+  context,
+  events,
+}: {
+  context: TContextSchema;
+  events: TEventSchemas;
+}): {
+  context: ConvertContextToJSONSchema<TContextSchema>;
+  events: ConvertToJSONSchemas<TEventSchemas>;
+  types: {
+    context: FromSchema<ConvertContextToJSONSchema<TContextSchema>>;
+    events: FromSchema<Values<ConvertToJSONSchemas<TEventSchemas>>>;
+  };
+} {
+  return {
+    context: {
+      type: 'object',
+      properties: context,
+      additionalProperties: false,
+      required: Object.keys(context),
+    },
+    events: createEventSchemas(events),
+    types: {} as any,
+  };
+}

package/dist/index.d.mts

@@ -1,3 +0,0 @@
-declare function helloWorld(): string;
-
-export { helloWorld };

package/dist/index.mjs

@@ -1,7 +0,0 @@
-// src/index.ts
-function helloWorld() {
-  return "Hello World!";
-}
-export {
-  helloWorld
-};