@statelyai/agent 1.1.6 → 2.0.0-next.1

package/src/decision.test.ts

@@ -1,179 +0,0 @@
-import { test, expect } from 'vitest';
-import { createAgent, fromDecision, type AIAdapter } from './';
-import { createActor, createMachine, waitFor } from 'xstate';
-import { z } from 'zod';
-import { GenerateTextResult } from 'ai';
-
-const mockToolDecision: AIAdapter['generateText'] = async (arg) => {
-  const keys = Object.keys(arg.tools!);
-
-  if (keys.length > 1) {
-    throw new Error('Expected only 1 choice');
-  }
-
-  if (keys.length === 0) {
-    return {
-      toolResults: [],
-    } as any as GenerateTextResult<any>;
-  }
-
-  return {
-    toolResults: [
-      {
-        result: {
-          type: keys[0],
-        },
-      },
-    ],
-  } as any as GenerateTextResult<any>;
-};
-
-test('fromDecision() makes a decision', async () => {
-  const agent = createAgent({
-    name: 'test',
-    model: {} as any,
-    events: {
-      doFirst: z.object({}),
-      doSecond: z.object({}),
-    },
-    adapter: {
-      generateText: async (arg) => {
-        const keys = Object.keys(arg.tools!);
-
-        if (keys.length !== 1) {
-          throw new Error('Expected only 1 choice');
-        }
-
-        return {
-          toolResults: [
-            {
-              result: {
-                type: keys[0],
-              },
-            },
-          ],
-        } as any as GenerateTextResult<any>;
-      },
-      streamText: {} as any,
-    },
-  });
-
-  const machine = createMachine({
-    initial: 'first',
-    states: {
-      first: {
-        invoke: {
-          src: fromDecision(agent),
-        },
-        on: {
-          doFirst: 'second',
-        },
-      },
-      second: {
-        invoke: {
-          src: fromDecision(agent),
-        },
-        on: {
-          doSecond: 'third',
-        },
-      },
-      third: {},
-    },
-  });
-
-  const actor = createActor(machine);
-
-  actor.start();
-
-  await waitFor(actor, (s) => s.matches('third'));
-
-  expect(actor.getSnapshot().value).toBe('third');
-});
-
-test('interacts with an actor', async () => {
-  const agent = createAgent({
-    name: 'test',
-    model: {} as any,
-    events: {
-      doFirst: z.object({}),
-      doSecond: z.object({}),
-    },
-    adapter: {
-      generateText: mockToolDecision,
-      streamText: {} as any,
-    },
-  });
-
-  const machine = createMachine({
-    initial: 'first',
-    states: {
-      first: {
-        on: {
-          doFirst: 'second',
-        },
-      },
-      second: {
-        on: {
-          doSecond: 'third',
-        },
-      },
-      third: {},
-    },
-  });
-
-  const actor = createActor(machine);
-
-  agent.interact(actor, () => ({
-    goal: 'Some goal',
-  }));
-
-  actor.start();
-
-  await waitFor(actor, (s) => s.matches('third'));
-
-  expect(actor.getSnapshot().value).toBe('third');
-});
-
-test('interacts with an actor (late interaction)', async () => {
-  const agent = createAgent({
-    name: 'test',
-    model: {} as any,
-    events: {
-      doFirst: z.object({}),
-      doSecond: z.object({}),
-    },
-    adapter: {
-      generateText: mockToolDecision,
-      streamText: {} as any,
-    },
-  });
-
-  const machine = createMachine({
-    initial: 'first',
-    states: {
-      first: {
-        on: {
-          doFirst: 'second',
-        },
-      },
-      second: {
-        on: {
-          doSecond: 'third',
-        },
-      },
-      third: {},
-    },
-  });
-
-  const actor = createActor(machine);
-
-  actor.start();
-
-  agent.interact(actor, () => ({
-    goal: 'Some goal',
-  }));
-
-  await waitFor(actor, (s) => s.matches('third'));
-
-  expect(actor.getSnapshot().value).toBe('third');
-});

package/src/decision.ts

@@ -1,84 +0,0 @@
-import { AnyActor, AnyMachineSnapshot, fromPromise } from 'xstate';
-import {
-  AnyAgent,
-  AgentDecideOptions,
-  AgentDecisionLogic,
-  AgentDecisionInput,
-  AgentPlanner,
-  AgentPlan,
-} from './types';
-import { simplePlanner } from './planners/simplePlanner';
-
-export async function agentDecide<T extends AnyAgent>(
-  agent: T,
-  options: AgentDecideOptions
-): Promise<AgentPlan<any> | undefined> {
-  const resolvedOptions = {
-    ...agent.defaultOptions,
-    ...options,
-  };
-  const {
-    planner = simplePlanner as AgentPlanner<any>,
-    goal,
-    events = agent.events,
-    state,
-    machine,
-    model = agent.model,
-    ...otherPlanInput
-  } = resolvedOptions;
-
-  const plan = await planner(agent, {
-    model,
-    goal,
-    events,
-    state,
-    machine,
-    ...otherPlanInput,
-  });
-
-  if (plan?.nextEvent) {
-    agent.addPlan(plan);
-    await resolvedOptions.execute?.(plan.nextEvent);
-  }
-
-  return plan;
-}
-
-export function fromDecision(
-  agent: AnyAgent,
-  defaultInput?: AgentDecisionInput
-): AgentDecisionLogic<any> {
-  return fromPromise(async ({ input, self }) => {
-    const parentRef = self._parent;
-    if (!parentRef) {
-      return;
-    }
-
-    const snapshot = parentRef.getSnapshot() as AnyMachineSnapshot;
-    const inputObject = typeof input === 'string' ? { goal: input } : input;
-    const resolvedInput = {
-      ...defaultInput,
-      ...inputObject,
-    };
-    const contextToInclude =
-      resolvedInput.context === true
-        ? // include entire context
-          parentRef.getSnapshot().context
-        : resolvedInput.context;
-    const state = {
-      value: snapshot.value,
-      context: contextToInclude,
-    };
-
-    const plan = await agentDecide(agent, {
-      machine: (parentRef as AnyActor).logic,
-      state,
-      execute: async (event) => {
-        parentRef.send(event);
-      },
-      ...resolvedInput,
-    });
-
-    return plan;
-  }) as AgentDecisionLogic<any>;
-}

package/src/memory.ts

@@ -1,25 +0,0 @@
-import { AgentMemory, AgentMemoryContext } from './types';
-
-export function createAgentMemory(): AgentMemory {
-  const storage = {
-    sessions: {} as Record<string, AgentMemoryContext>,
-  };
-
-  return {
-    append: async (sessionId, key, item) => {
-      storage.sessions[sessionId] =
-        storage.sessions[sessionId] ||
-        ({
-          observations: [],
-          messages: [],
-          plans: [],
-          feedback: [],
-        } satisfies AgentMemoryContext);
-
-      storage.sessions[sessionId]![key].push(item as any);
-    },
-    getAll: async (sessionId, key) => {
-      return storage.sessions[sessionId]?.[key];
-    },
-  };
-}

package/src/planners/shortestPathPlanner.ts

@@ -1,22 +0,0 @@
-import { Agent, AgentPlan, AgentPlanInput, AnyAgent } from '../types';
-import { getShortestPaths } from '@xstate/graph';
-
-export async function simplePlanner<T extends AnyAgent>(
-  agent: T,
-  input: AgentPlanInput<any>
-): Promise<AgentPlan<any> | undefined> {
-  // 1. Determine goal state criteria
-  // e.g. a state where the agent has won a game
-  void 0;
-
-  // 2. Determine possible events that can occur
-  void 0;
-
-  // 3. Get shortest paths from current state to
-  // a state matching the criteria, using
-  // possible events
-  void 0;
-
-  // 4. Return shortest path as a plan
-  return null as any;
-}

package/src/planners/simplePlanner.ts

@@ -1,139 +0,0 @@
-import { type CoreTool, tool } from 'ai';
-import {
-  AgentPlan,
-  AgentPlanInput,
-  ObservedState,
-  PromptTemplate,
-  TransitionData,
-  AnyAgent,
-} from '../types';
-import { getAllTransitions } from '../utils';
-import { AnyStateMachine } from 'xstate';
-import { defaultTextTemplate } from '../templates/defaultText';
-import { getMessages } from '../text';
-
-function getTransitions(
-  state: ObservedState,
-  machine: AnyStateMachine
-): TransitionData[] {
-  if (!machine) {
-    return [];
-  }
-
-  const resolvedState = machine.resolveState(state);
-  return getAllTransitions(resolvedState);
-}
-
-const simplePlannerPromptTemplate: PromptTemplate<any> = (data) => {
-  return `
-${defaultTextTemplate(data)}
-
-Make at most one tool call to achieve the above goal. If the goal cannot be achieved with any tool calls, do not make any tool call.
-  `.trim();
-};
-
-export async function simplePlanner<T extends AnyAgent>(
-  agent: T,
-  input: AgentPlanInput<any>
-): Promise<AgentPlan<any> | undefined> {
-  // Get all of the possible next transitions
-  const transitions: TransitionData[] = input.machine
-    ? getTransitions(input.state, input.machine)
-    : Object.entries(input.events).map(([eventType, { description }]) => ({
-        eventType,
-        description,
-      }));
-
-  // Only keep the transitions that match the event types that are in the event mapping
-  // TODO: allow for custom filters
-  const filter = (eventType: string) =>
-    Object.keys(input.events).includes(eventType);
-
-  // Mapping of each event type (e.g. "mouse.click")
-  // to a valid function name (e.g. "mouse_click")
-  const functionNameMapping: Record<string, string> = {};
-
-  const toolTransitions = transitions
-    .filter((t) => {
-      return filter(t.eventType);
-    })
-    .map((t) => {
-      const name = t.eventType.replace(/\./g, '_');
-      functionNameMapping[name] = t.eventType;
-
-      return {
-        type: 'function',
-        eventType: t.eventType,
-        description: t.description,
-        name,
-      } as const;
-    });
-
-  // Convert the transition data to a tool map that the
-  // Vercel AI SDK can use
-  const toolMap: Record<string, CoreTool<any, any>> = {};
-  for (const toolTransitionData of toolTransitions) {
-    const toolZodType = input.events?.[toolTransitionData.eventType];
-
-    if (!toolZodType) {
-      continue;
-    }
-
-    toolMap[toolTransitionData.name] = tool({
-      description: toolZodType?.description ?? toolTransitionData.description,
-      parameters: toolZodType,
-      execute: async (params: Record<string, any>) => {
-        const event = {
-          type: toolTransitionData.eventType,
-          ...params,
-        };
-
-        return event;
-      },
-    });
-  }
-
-  if (!Object.keys(toolMap).length) {
-    // No valid transitions for the specified tools
-    return undefined;
-  }
-
-  // Create a prompt with the given context and goal.
-  // The template is used to ensure that a single tool call at most is made.
-  const prompt = simplePlannerPromptTemplate({
-    context: input.state.context,
-    goal: input.goal,
-  });
-
-  const messages = await getMessages(agent, prompt, input);
-
-  const result = await agent.generateText({
-    toolChoice: 'required',
-    ...input,
-    prompt,
-    messages,
-    tools: toolMap,
-  });
-
-  const singleResult = result.toolResults[0];
-
-  if (!singleResult) {
-    // TODO: retries?
-    console.warn('No tool call results returned');
-    return undefined;
-  }
-
-  return {
-    goal: input.goal,
-    state: input.state,
-    execute: async (state) => {
-      if (JSON.stringify(state) === JSON.stringify(input.state)) {
-        return singleResult.result;
-      }
-      return undefined;
-    },
-    nextEvent: singleResult.result,
-    sessionId: agent.sessionId,
-    timestamp: Date.now(),
-  };
-}