@autobe/agent 0.0.0

package/src/context/IAutoBeApplicationProps.ts

@@ -0,0 +1,6 @@
+export interface IAutoBeApplicationProps {
+  /**
+   * The reason of the function call.
+   */
+  reason: string;
+}

package/src/context/IAutoBeApplicationResult.ts

@@ -0,0 +1,4 @@
+export interface IAutoBeApplicationResult {
+  success: boolean;
+  description: string;
+}

package/src/factory/transformRouteDocument.ts

@@ -0,0 +1,49 @@
+import { IAutoBeRouteDocument } from "@autobe/interface";
+import { OpenApi } from "@samchon/openapi";
+
+export function transformRouteDocument(
+  route: IAutoBeRouteDocument,
+): OpenApi.IDocument {
+  const paths: Record<string, OpenApi.IPath> = {};
+  for (const op of route.operations) {
+    paths[op.path] ??= {};
+    paths[op.path][op.method] = {
+      parameters: op.parameters.map((p) => ({
+        name: p.name,
+        in: "path",
+        schema: p.schema,
+        description: p.description,
+        required: true,
+      })),
+      requestBody: op.body
+        ? {
+            content: {
+              "application/json": {
+                schema: op.body.schema,
+              },
+            },
+            description: op.description,
+            required: true,
+          }
+        : undefined,
+      responses: op.response
+        ? {
+            [op.method === "post" ? 201 : 200]: {
+              content: {
+                "application/json": {
+                  schema: op.response.schema,
+                },
+              },
+              description: op.description,
+            },
+          }
+        : undefined,
+    };
+  }
+  return {
+    openapi: "3.1.0",
+    paths,
+    components: route.components,
+    "x-samchon-emended-v4": true,
+  };
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from "./AutoBeAgent";
+
+export * from "./context/AutoBeTokenUsage";
+
+export * from "./structures/IAutoBeProps";
+export * from "./structures/IAutoBeConfig";
+export * from "./structures/IAutoBeVendor";
+
+/**
+ * @internal
+ */
+export * as orchestrate from "./orchestrate";

package/src/internal/createAutoBeApplication.ts

@@ -0,0 +1,47 @@
+import { IAgenticaController } from "@agentica/core";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import typia from "typia";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplication } from "../context/IAutoBeApplication";
+import { orchestrateAnalyze } from "../orchestrate/orchestrateAnalyze";
+import { orchestrateInterface } from "../orchestrate/orchestrateInterface";
+import { orchestratePrisma } from "../orchestrate/orchestratePrisma";
+import { orchestrateRealize } from "../orchestrate/orchestrateRealize";
+import { orchestrateTest } from "../orchestrate/orchestrateTest";
+
+export const createAutoBeController = <Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  context: AutoBeContext<Model>;
+}): IAgenticaController.IClass<Model> => {
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "autobe",
+    application,
+    execute: {
+      analyze: orchestrateAnalyze(props.context),
+      prisma: orchestratePrisma(props.context),
+      interface: orchestrateInterface(props.context),
+      test: orchestrateTest(props.context),
+      realize: orchestrateRealize(props.context),
+    },
+  };
+};
+
+const claude = typia.llm.application<IAutoBeApplication, "claude">();
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  gemini: typia.llm.application<IAutoBeApplication, "gemini">(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+  "3.0": typia.llm.application<IAutoBeApplication, "3.0">(),
+};

package/src/internal/createAutoBeState.ts

@@ -0,0 +1,14 @@
+import { AutoBeHistory } from "@autobe/interface";
+
+import { AutoBeState } from "../context/AutoBeState";
+
+export const createAutoBeState = (histories: AutoBeHistory[]): AutoBeState => {
+  const reversed = histories.slice().reverse();
+  return {
+    analyze: reversed.find((h) => h.type === "analyze") ?? null,
+    prisma: reversed.find((h) => h.type === "prisma") ?? null,
+    interface: reversed.find((h) => h.type === "interface") ?? null,
+    test: reversed.find((h) => h.type === "test") ?? null,
+    realize: reversed.find((h) => h.type === "realize") ?? null,
+  };
+};

package/src/internal/transformAgenticaHistory.ts

@@ -0,0 +1,54 @@
+import { AgenticaOperation, MicroAgenticaHistory } from "@agentica/core";
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeHistory,
+  AutoBeUserMessageHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+export function transformAgenticaHistory<
+  Model extends ILlmSchema.Model,
+>(props: {
+  operations: readonly AgenticaOperation<Model>[];
+  history: AutoBeHistory;
+}): MicroAgenticaHistory<Model> | null {
+  if (props.history.type === "userMessage")
+    return {
+      ...props.history,
+      toJSON: () => props.history as AutoBeUserMessageHistory,
+    };
+  else if (props.history.type === "assistantMessage")
+    return {
+      ...props.history,
+      toJSON: () => props.history as AutoBeAssistantMessageHistory,
+    };
+
+  const operation: AgenticaOperation<Model> | undefined = props.operations.find(
+    (op) => op.function.name === props.history.type,
+  );
+  if (operation === undefined) return null;
+  const partial = {
+    id: props.history.id,
+    type: "execute" as const,
+    arguments: {
+      reason: props.history.reason,
+    },
+    value: {
+      success:
+        props.history.type === "analyze" || props.history.type === "interface"
+          ? true
+          : props.history.result.type === "success",
+      description: props.history.description,
+    },
+  };
+  return {
+    ...partial,
+    protocol: operation.protocol as "class",
+    operation: operation as AgenticaOperation.Class<Model>,
+    toJSON: () => ({
+      ...partial,
+      protocol: operation.protocol as "class",
+      operation: operation.toJSON(),
+    }),
+  };
+}

package/src/orchestrate/index.ts

@@ -0,0 +1,5 @@
+export { orchestrateAnalyze as analyze } from "./orchestrateAnalyze";
+export { orchestrateInterface as interface } from "./orchestrateInterface";
+export { orchestratePrisma as prisma } from "./orchestratePrisma";
+export { orchestrateTest as test } from "./orchestrateTest";
+export { orchestrateRealize as realize } from "./orchestrateRealize";

package/src/orchestrate/orchestrateAnalyze.ts

@@ -0,0 +1,21 @@
+import {
+  AutoBeAnalyzeHistory,
+  AutoBeAssistantMessageHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+/**
+ * @todo Kakasoo
+ */
+export const orchestrateAnalyze =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory> => {
+    ctx;
+    props;
+    return null!;
+  };

package/src/orchestrate/orchestrateInterface.ts

@@ -0,0 +1,21 @@
+import {
+  AutoBeAnalyzeHistory,
+  AutoBeAssistantMessageHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+/**
+ * @todo Samchon
+ */
+export const orchestrateInterface =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory> => {
+    ctx;
+    props;
+    return null!;
+  };

package/src/orchestrate/orchestratePrisma.ts

@@ -0,0 +1,21 @@
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBePrismaHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+/**
+ * @todo Michael
+ */
+export const orchestratePrisma =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBePrismaHistory> => {
+    ctx;
+    props;
+    return null!;
+  };

package/src/orchestrate/orchestrateRealize.ts

@@ -0,0 +1,18 @@
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeRealizeHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+export const orchestrateRealize =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
+    ctx;
+    props;
+    return null!;
+  };

package/src/orchestrate/orchestrateTest.ts

@@ -0,0 +1,18 @@
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeTestHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+export const orchestrateTest =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory> => {
+    ctx;
+    props;
+    return null!;
+  };

package/src/structures/IAutoBeConfig.ts

@@ -0,0 +1,25 @@
+export interface IAutoBeConfig {
+  /**
+   * Locale of the A.I. chatbot.
+   *
+   * If you configure this property, the A.I. chatbot will conversate with
+   * the given locale. You can get the locale value by
+   *
+   * - Browser: `navigator.language`
+   * - NodeJS: `process.env.LANG.split(".")[0]`
+   *
+   * @default your_locale
+   */
+  locale?: string;
+
+  /**
+   * Timezone of the A.I. chatbot.
+   *
+   * If you configure this property, the A.I. chatbot will consider the
+   * given timezone. You can get the timezone value by
+   * `Intl.DateTimeFormat().resolvedOptions().timeZone`.
+   *
+   * @default your_timezone
+   */
+  timezone?: string;
+}

package/src/structures/IAutoBeProps.ts

@@ -0,0 +1,13 @@
+import { AutoBeHistory, IAutoBeCompiler } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { IAutoBeConfig } from "./IAutoBeConfig";
+import { IAutoBeVendor } from "./IAutoBeVendor";
+
+export interface IAutoBeProps<Model extends ILlmSchema.Model> {
+  model: Model;
+  vendor: IAutoBeVendor;
+  compiler: IAutoBeCompiler;
+  histories?: AutoBeHistory[] | undefined;
+  config?: IAutoBeConfig | undefined;
+}

package/src/structures/IAutoBeVendor.ts

@@ -0,0 +1,3 @@
+import { IAgenticaVendor } from "@agentica/core";
+
+export type IAutoBeVendor = IAgenticaVendor;