@statelyai/agent 1.1.6 → 2.0.0-alpha.6

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(),
-  };
-}

package/src/schemas.ts

@@ -1,11 +0,0 @@
-import { ZodType, type SomeZodObject } from 'zod';
-
-export type ZodEventMapping = {
-  // map event types to Zod types
-  [eventType: string]: SomeZodObject;
-};
-
-export type ZodContextMapping = {
-  // map context keys to Zod types
-  [contextKey: string]: ZodType;
-};

package/src/strategies/chain-of-note.ts

@@ -1,155 +0,0 @@
-import { GenerateTextResult, LanguageModel } from 'ai';
-import wiki, { wikiSearchResult, wikiSummary } from 'wikipedia';
-import { assign, fromPromise, setup } from 'xstate';
-import { AnyAgent } from '../types';
-
-const searchWiki = fromPromise(
-  async ({
-    input,
-  }: {
-    input: {
-      query: string;
-      limit?: number;
-    };
-  }) => {
-    const passages = await wiki.search(input.query, {
-      limit: input.limit ?? 5,
-    });
-    return passages;
-  }
-);
-
-const extractSummaries = fromPromise(
-  async ({
-    input,
-  }: {
-    input: {
-      searchResult: wikiSearchResult;
-    };
-  }) => {
-    const summaries = await Promise.all(
-      input.searchResult.results.map(async (result) => {
-        const summary = await wiki.summary(result.title);
-        return {
-          title: result.title,
-          summary,
-        };
-      })
-    );
-    return summaries;
-  }
-);
-
-export const chainOfNote = setup({
-  types: {
-    input: {} as {
-      model: LanguageModel;
-      agent: AnyAgent;
-      prompt: string;
-    },
-    context: {} as {
-      searchResults: wikiSearchResult | null;
-      summaries:
-        | {
-            title: any;
-            summary: wikiSummary;
-          }[]
-        | null;
-      model: LanguageModel;
-      agent: AnyAgent;
-      prompt: string;
-    },
-    output: {} as GenerateTextResult<any>,
-  },
-  actors: {
-    searchWiki,
-    extractSummaries,
-  },
-}).createMachine({
-  initial: 'searching',
-  context: (x) => ({
-    ...x.input,
-    searchResults: null,
-    summaries: null,
-  }),
-  states: {
-    searching: {
-      invoke: {
-        src: 'searchWiki',
-        input: (x) => ({
-          query: x.context.prompt,
-        }),
-        onDone: {
-          actions: assign({
-            searchResults: ({ event }) => event.output,
-          }),
-          target: 'extracting',
-        },
-      },
-    },
-    extracting: {
-      invoke: {
-        src: 'extractSummaries',
-        input: (x) => ({
-          searchResult: x.context.searchResults!,
-        }),
-        onDone: {
-          actions: assign({
-            summaries: ({ event }) => event.output,
-          }),
-          target: 'generating',
-        },
-      },
-    },
-    generating: {},
-  },
-});
-
-// export function chainOfNote() {
-//   return {
-//     generateText: async (x) => {
-//       const passages = await wiki.search(x.prompt!, {
-//         limit: 5,
-//       });
-
-//       const extracts = await Promise.all(
-//         passages.results.map(async (p) => {
-//           const summary = await wiki.summary(p.title);
-//           return summary.extract;
-//         })
-//       );
-//       x.agent?.addMessage({
-//         content: x.prompt!,
-//         id: Date.now() + '',
-//         role: 'user',
-//         timestamp: Date.now(),
-//       });
-//       const result = await generateText({
-//         model: x.model,
-//         system: `Task Description:
-
-// 1. Read the given question and five Wikipedia passages to gather relevant information.
-
-// 2. Write reading notes summarizing the key points from these passages.
-
-// 3. Discuss the relevance of the given question and Wikipedia passages.
-
-// 4. If some passages are relevant to the given question, provide a brief answer based on the passages.
-
-// 5. If no passage is relevant, direcly provide answer without considering the passages.
-
-// Passages: \n${extracts.join('\n')}`,
-//         prompt: `${x.prompt!}`,
-//       });
-
-//       x.agent?.addMessage({
-//         content: result.text,
-//         id: Date.now() + '',
-//         role: 'user',
-//         timestamp: Date.now(),
-//       });
-
-//       return result;
-//     },
-//   } satisfies AgentStrategy;
-// }

package/src/templates/defaultText.ts

@@ -1,18 +0,0 @@
-import { PromptTemplate } from '../types';
-import { wrapInXml } from '../utils';
-
-export const defaultTextTemplate: PromptTemplate<any> = (data) => {
-  const preamble = [
-    data.context
-      ? wrapInXml('context', JSON.stringify(data.context))
-      : undefined,
-  ]
-    .filter(Boolean)
-    .join('\n');
-
-  return `
-${preamble}
-
-${data.goal}
-  `.trim();
-};

package/src/text.ts

@@ -1,241 +0,0 @@
-import type { CoreMessage, CoreTool, GenerateTextResult } from 'ai';
-import {
-  AgentGenerateTextOptions,
-  AgentGenerateTextResult,
-  AgentStreamTextOptions,
-  AgentStreamTextResult,
-  AnyAgent,
-} from './types';
-import { defaultTextTemplate } from './templates/defaultText';
-import {
-  ObservableActorLogic,
-  Observer,
-  PromiseActorLogic,
-  fromObservable,
-  fromPromise,
-  toObserver,
-} from 'xstate';
-import { randomId } from './utils';
-
-/**
- * Gets an array of messages from the given prompt, based on the agent and options.
- *
- * @param agent
- * @param prompt
- * @param options
- * @returns
- */
-export async function getMessages(
-  agent: AnyAgent,
-  prompt: string,
-  options: Omit<AgentGenerateTextOptions, 'prompt'>
-): Promise<CoreMessage[]> {
-  let messages: CoreMessage[] = [];
-  if (typeof options.messages === 'function') {
-    messages = await options.messages(agent);
-  } else if (options.messages) {
-    messages = options.messages;
-  }
-
-  messages = messages.concat({
-    role: 'user',
-    content: prompt,
-  });
-
-  return messages;
-}
-
-export async function agentGenerateText<T extends AnyAgent>(
-  agent: T,
-  options: AgentGenerateTextOptions
-): Promise<AgentGenerateTextResult> {
-  const resolvedOptions = {
-    ...agent.defaultOptions,
-    ...options,
-    correlationId: options.correlationId ?? randomId(),
-  };
-  // Generate a correlation ID if one is not provided
-  const template = resolvedOptions.template ?? defaultTextTemplate;
-  // TODO: check if messages was provided instead
-  const id = randomId();
-  const goal =
-    typeof resolvedOptions.prompt === 'string'
-      ? resolvedOptions.prompt
-      : await resolvedOptions.prompt(agent);
-
-  const promptWithContext = template({
-    goal,
-    context: resolvedOptions.context,
-  });
-
-  const messages = await getMessages(agent, promptWithContext, resolvedOptions);
-
-  agent.addMessage({
-    id,
-    role: 'user',
-    content: promptWithContext,
-    timestamp: Date.now(),
-    correlationId: resolvedOptions.correlationId,
-    parentCorrelationId: resolvedOptions.parentCorrelationId,
-  });
-
-  const result = await agent.adapter.generateText({
-    ...resolvedOptions,
-    prompt: undefined,
-    messages,
-  });
-
-  agent.addMessage({
-    content: result.text,
-    id,
-    role: 'assistant',
-    timestamp: Date.now(),
-    responseId: id,
-    result,
-    correlationId: resolvedOptions.correlationId,
-    parentCorrelationId: resolvedOptions.parentCorrelationId,
-  });
-
-  return {
-    ...result,
-    parentCorrelationId: resolvedOptions.parentCorrelationId,
-    correlationId: resolvedOptions.correlationId,
-  };
-}
-
-export async function agentStreamText(
-  agent: AnyAgent,
-  options: AgentStreamTextOptions
-): Promise<AgentStreamTextResult> {
-  const resolvedOptions = {
-    ...agent.defaultOptions,
-    ...options,
-    correlationId: options.correlationId ?? randomId(),
-  };
-  const template = resolvedOptions.template ?? defaultTextTemplate;
-
-  const id = randomId();
-  const goal =
-    typeof resolvedOptions.prompt === 'string'
-      ? resolvedOptions.prompt
-      : await resolvedOptions.prompt(agent);
-
-  const promptWithContext = template({
-    goal,
-    context: resolvedOptions.context,
-  });
-
-  const messages = await getMessages(agent, promptWithContext, resolvedOptions);
-
-  agent.addMessage({
-    role: 'user',
-    content: promptWithContext,
-    id,
-    timestamp: Date.now(),
-    correlationId: resolvedOptions.correlationId,
-    parentCorrelationId: resolvedOptions.parentCorrelationId,
-  });
-
-  const result = await agent.adapter.streamText({
-    ...resolvedOptions,
-    prompt: undefined,
-    messages,
-    onFinish: async (res) => {
-      agent.addMessage({
-        role: 'assistant',
-        result: {
-          text: res.text,
-          finishReason: res.finishReason,
-          logprobs: undefined,
-          responseMessages: [],
-          toolCalls: [],
-          toolResults: [],
-          usage: res.usage,
-          warnings: res.warnings,
-          rawResponse: res.rawResponse,
-          roundtrips: [], // TODO: how do we get this information?,
-          steps: res.steps,
-          response: res.response,
-          experimental_providerMetadata: res.experimental_providerMetadata,
-        },
-        content: res.text,
-        id: randomId(),
-        timestamp: Date.now(),
-        responseId: id,
-        correlationId: resolvedOptions.correlationId,
-        parentCorrelationId: resolvedOptions.parentCorrelationId,
-      });
-    },
-  });
-
-  return {
-    ...result,
-    textStream: result.textStream,
-    fullStream: result.fullStream,
-    parentCorrelationId: resolvedOptions.parentCorrelationId,
-    correlationId: resolvedOptions.correlationId,
-  } as unknown as AgentStreamTextResult; // TODO: fix
-}
-
-export function fromTextStream<T extends AnyAgent>(
-  agent: T,
-  defaultOptions?: AgentStreamTextOptions
-): ObservableActorLogic<
-  { textDelta: string },
-  Omit<AgentStreamTextOptions, 'context'> & {
-    context?: AgentStreamTextOptions['context'];
-  }
-> {
-  return fromObservable(({ input }) => {
-    const observers = new Set<Observer<{ textDelta: string }>>();
-
-    // TODO: check if messages was provided instead
-
-    (async () => {
-      const result = await agentStreamText(agent, {
-        ...defaultOptions,
-        ...input,
-        context: input.context,
-      });
-
-      for await (const part of result.fullStream) {
-        if (part.type === 'text-delta') {
-          observers.forEach((observer) => {
-            observer.next?.(part);
-          });
-        }
-      }
-    })();
-
-    return {
-      subscribe: (...args: any[]) => {
-        const observer = toObserver(...args);
-        observers.add(observer);
-
-        return {
-          unsubscribe: () => {
-            observers.delete(observer);
-          },
-        };
-      },
-    };
-  });
-}
-
-export function fromText<T extends AnyAgent>(
-  agent: T,
-  defaultOptions?: AgentGenerateTextOptions
-): PromiseActorLogic<
-  GenerateTextResult<Record<string, CoreTool<any, any>>>,
-  Omit<AgentGenerateTextOptions, 'context'> & {
-    context?: AgentGenerateTextOptions['context'];
-  }
-> {
-  return fromPromise(async ({ input }) => {
-    return await agentGenerateText(agent, {
-      ...input,
-      ...defaultOptions,
-      context: input.context,
-    });
-  });
-}