@ag-ui/core 0.0.27

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@ag-ui/core",
+  "author": "Markus Ecker <markus.ecker@gmail.com>",
+  "version": "0.0.27",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "rxjs": "7.8.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "tsup": "^8.0.2",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "test": "jest",
+    "link:global": "pnpm link --global",
+    "unlink:global": "pnpm unlink --global"
+  }
+}

package/src/__tests__/index.test.ts

@@ -0,0 +1,5 @@
+describe("Core package", () => {
+  it("should pass a simple test", () => {
+    expect(true).toBe(true);
+  });
+});

package/src/events.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { MessageSchema, StateSchema } from "./types";
+
+export enum EventType {
+  TEXT_MESSAGE_START = "TEXT_MESSAGE_START",
+  TEXT_MESSAGE_CONTENT = "TEXT_MESSAGE_CONTENT",
+  TEXT_MESSAGE_END = "TEXT_MESSAGE_END",
+  TOOL_CALL_START = "TOOL_CALL_START",
+  TOOL_CALL_ARGS = "TOOL_CALL_ARGS",
+  TOOL_CALL_END = "TOOL_CALL_END",
+  STATE_SNAPSHOT = "STATE_SNAPSHOT",
+  STATE_DELTA = "STATE_DELTA",
+  MESSAGES_SNAPSHOT = "MESSAGES_SNAPSHOT",
+  RAW = "RAW",
+  CUSTOM = "CUSTOM",
+  RUN_STARTED = "RUN_STARTED",
+  RUN_FINISHED = "RUN_FINISHED",
+  RUN_ERROR = "RUN_ERROR",
+  STEP_STARTED = "STEP_STARTED",
+  STEP_FINISHED = "STEP_FINISHED",
+}
+
+const BaseEventSchema = z.object({
+  type: z.nativeEnum(EventType),
+  timestamp: z.number().optional(),
+  rawEvent: z.any().optional(),
+});
+
+export const RunStartedSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.RUN_STARTED),
+  threadId: z.string(),
+  runId: z.string(),
+});
+
+export const RunFinishedSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.RUN_FINISHED),
+  threadId: z.string(),
+  runId: z.string(),
+});
+
+export const RunErrorSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.RUN_ERROR),
+  message: z.string(),
+  code: z.string().optional(),
+});
+
+export const StepStartedSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.STEP_STARTED),
+  stepName: z.string(),
+});
+
+export const StepFinishedSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.STEP_FINISHED),
+  stepName: z.string(),
+});
+
+export const TextMessageStartEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.TEXT_MESSAGE_START),
+  messageId: z.string(),
+  role: z.literal("assistant"),
+});
+
+export const TextMessageContentEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.TEXT_MESSAGE_CONTENT),
+  messageId: z.string(),
+  delta: z.string().refine((s) => s.length > 0, "Delta must not be an empty string"),
+});
+
+export const TextMessageEndEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.TEXT_MESSAGE_END),
+  messageId: z.string(),
+});
+
+export const ToolCallStartEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.TOOL_CALL_START),
+  toolCallId: z.string(),
+  toolCallName: z.string(),
+  parentMessageId: z.string().optional(),
+});
+
+export const ToolCallArgsEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.TOOL_CALL_ARGS),
+  toolCallId: z.string(),
+  delta: z.string(),
+});
+
+export const ToolCallEndEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.TOOL_CALL_END),
+  toolCallId: z.string(),
+});
+
+export const StateSnapshotEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.STATE_SNAPSHOT),
+  snapshot: StateSchema,
+});
+
+export const StateDeltaEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.STATE_DELTA),
+  delta: z.array(z.any()), // JSON Patch (RFC 6902)
+});
+
+export const MessagesSnapshotEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.MESSAGES_SNAPSHOT),
+  messages: z.array(MessageSchema),
+});
+
+export const RawEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.RAW),
+  event: z.any(),
+  source: z.string().optional(),
+});
+
+export const CustomEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.CUSTOM),
+  name: z.string(),
+  value: z.any(),
+});
+
+export const RunStartedEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.RUN_STARTED),
+  threadId: z.string(),
+  runId: z.string(),
+});
+
+export const RunFinishedEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.RUN_FINISHED),
+  threadId: z.string(),
+  runId: z.string(),
+});
+
+export const RunErrorEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.RUN_ERROR),
+  message: z.string(),
+  code: z.string().optional(),
+});
+
+export const StepStartedEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.STEP_STARTED),
+  stepName: z.string(),
+});
+
+export const StepFinishedEventSchema = BaseEventSchema.extend({
+  type: z.literal(EventType.STEP_FINISHED),
+  stepName: z.string(),
+});
+
+export const EventSchemas = z.discriminatedUnion("type", [
+  TextMessageStartEventSchema,
+  TextMessageContentEventSchema,
+  TextMessageEndEventSchema,
+  ToolCallStartEventSchema,
+  ToolCallArgsEventSchema,
+  ToolCallEndEventSchema,
+  StateSnapshotEventSchema,
+  StateDeltaEventSchema,
+  MessagesSnapshotEventSchema,
+  RawEventSchema,
+  CustomEventSchema,
+  RunStartedEventSchema,
+  RunFinishedEventSchema,
+  RunErrorEventSchema,
+  StepStartedEventSchema,
+  StepFinishedEventSchema,
+]);
+
+export type BaseEvent = z.infer<typeof BaseEventSchema>;
+export type TextMessageStartEvent = z.infer<typeof TextMessageStartEventSchema>;
+export type TextMessageContentEvent = z.infer<typeof TextMessageContentEventSchema>;
+export type TextMessageEndEvent = z.infer<typeof TextMessageEndEventSchema>;
+export type ToolCallStartEvent = z.infer<typeof ToolCallStartEventSchema>;
+export type ToolCallArgsEvent = z.infer<typeof ToolCallArgsEventSchema>;
+export type ToolCallEndEvent = z.infer<typeof ToolCallEndEventSchema>;
+export type StateSnapshotEvent = z.infer<typeof StateSnapshotEventSchema>;
+export type StateDeltaEvent = z.infer<typeof StateDeltaEventSchema>;
+export type MessagesSnapshotEvent = z.infer<typeof MessagesSnapshotEventSchema>;
+export type RawEvent = z.infer<typeof RawEventSchema>;
+export type CustomEvent = z.infer<typeof CustomEventSchema>;
+export type RunStartedEvent = z.infer<typeof RunStartedEventSchema>;
+export type RunFinishedEvent = z.infer<typeof RunFinishedEventSchema>;
+export type RunErrorEvent = z.infer<typeof RunErrorEventSchema>;
+export type StepStartedEvent = z.infer<typeof StepStartedEventSchema>;
+export type StepFinishedEvent = z.infer<typeof StepFinishedEventSchema>;

package/src/index.ts

@@ -0,0 +1,8 @@
+// Export all base types and schemas
+export * from "./types";
+
+// Export all event-related types and schemas
+export * from "./events";
+
+// Export all stream-related types and schemas
+export * from "./stream";

package/src/stream.ts

@@ -0,0 +1,25 @@
+import { Observable } from "rxjs";
+import { Message, State, RunAgentInput } from "./types";
+import { BaseEvent } from "./events";
+
+/**
+ * Function type for agent runners that process input and return a stream of results.
+ */
+export type RunAgent = (input: RunAgentInput) => Observable<BaseEvent>;
+
+/**
+ * The transformed state of an agent.
+ */
+export interface AgentState {
+  messages?: Message[];
+  state?: State;
+}
+
+/**
+ * Maps a stream of BaseEvent objects to a stream of AgentState objects.
+ * @returns A function that transforms an Observable<BaseEvent> into an Observable<TransformedState>
+ */
+export type ApplyEvents = (
+  input: RunAgentInput,
+  events$: Observable<BaseEvent>,
+) => Observable<AgentState>;

package/src/types.ts

@@ -0,0 +1,106 @@
+import { z } from "zod";
+
+export const FunctionCallSchema = z.object({
+  name: z.string(),
+  arguments: z.string(),
+});
+
+export const ToolCallSchema = z.object({
+  id: z.string(),
+  type: z.literal("function"),
+  function: FunctionCallSchema,
+});
+
+export const BaseMessageSchema = z.object({
+  id: z.string(),
+  role: z.string(),
+  content: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export const DeveloperMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("developer"),
+  content: z.string(),
+});
+
+export const SystemMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("system"),
+  content: z.string(),
+});
+
+export const AssistantMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("assistant"),
+  content: z.string().optional(),
+  toolCalls: z.array(ToolCallSchema).optional(),
+});
+
+export const UserMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("user"),
+  content: z.string(),
+});
+
+export const ToolMessageSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  role: z.literal("tool"),
+  toolCallId: z.string(),
+});
+
+export const MessageSchema = z.discriminatedUnion("role", [
+  DeveloperMessageSchema,
+  SystemMessageSchema,
+  AssistantMessageSchema,
+  UserMessageSchema,
+  ToolMessageSchema,
+]);
+
+export const RoleSchema = z.union([
+  z.literal("developer"),
+  z.literal("system"),
+  z.literal("assistant"),
+  z.literal("user"),
+  z.literal("tool"),
+]);
+
+export const ContextSchema = z.object({
+  description: z.string(),
+  value: z.string(),
+});
+
+export const ToolSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  parameters: z.any(), // JSON Schema for the tool parameters
+});
+
+export const RunAgentInputSchema = z.object({
+  threadId: z.string(),
+  runId: z.string(),
+  state: z.any(),
+  messages: z.array(MessageSchema),
+  tools: z.array(ToolSchema),
+  context: z.array(ContextSchema),
+  forwardedProps: z.any(),
+});
+
+export const StateSchema = z.any();
+
+export type ToolCall = z.infer<typeof ToolCallSchema>;
+export type FunctionCall = z.infer<typeof FunctionCallSchema>;
+export type DeveloperMessage = z.infer<typeof DeveloperMessageSchema>;
+export type SystemMessage = z.infer<typeof SystemMessageSchema>;
+export type AssistantMessage = z.infer<typeof AssistantMessageSchema>;
+export type UserMessage = z.infer<typeof UserMessageSchema>;
+export type ToolMessage = z.infer<typeof ToolMessageSchema>;
+export type Message = z.infer<typeof MessageSchema>;
+export type Context = z.infer<typeof ContextSchema>;
+export type Tool = z.infer<typeof ToolSchema>;
+export type RunAgentInput = z.infer<typeof RunAgentInputSchema>;
+export type State = z.infer<typeof StateSchema>;
+export type Role = z.infer<typeof RoleSchema>;
+
+export class AGUIError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "esnext",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});