import { Agentica, assertHttpLlmApplication } from "@agentica/core";
import OpenAI from "openai";
 
const agent = new Agentica({
  model: "chatgpt",
  vendor: {
    model: "gpt-4o-mini",
    api: new OpenAI({ apiKey: "********" }),
  },
  controllers: [
    {
      protocol: "http",
      name: "shopping",
      application: assertHttpLlmApplication({
        model: "chatgpt",
        document: await fetch(
          "https://shopping-be.wrtn.ai/editor/swagger.json",
        ).then((res) => res.json()),
      }),
      connection: {
        host: "https://shopping-be.wrtn.ai",
        headers: {
          Authorization: "Bearer ********",
        },
      },
    }
  ],
});
await agent.convert("I wanna buy a Macbook.");

import { Agentica, assertHttpLlmApplication } from "@agentica/core";
import ShoppingApi from "@samchon/shopping-api";
import OpenAI from "openai";
 
// Authentication to the shopping backend server
const connection: ShoppingApi.IConnection = {
  host: "https://shopping-be.wrtn.ai",
};
await ShoppingApi.functional.shoppings.customers.authenticate.create(
  connection,
  {
    channel_code: "samchon",
    external_user: null,
    href: window.location.href,
    referrer: window.document.referrer,
  },
);
await ShoppingApi.functional.shoppings.customers.authenticate.activate(
  connection,
  {
    mobile: "010-1234-5678",
    name: "John Doe",
  },
);
 
// Bearer ********
// Nestia SDK injected the Authorization header
console.log(connection.headers?.Authorization);
 
// Agentica with authenticated connection
const agent = new Agentica({
  model: "chatgpt",
  vendor: {
    model: "gpt-4o-mini",
    api: new OpenAI({ apiKey: "********" }),
  },
  controllers: [
    {
      protocol: "http",
      name: "shopping",
      application: assertHttpLlmApplication({
        model: "chatgpt",
        document: await fetch(
          "https://shopping-be.wrtn.ai/editor/swagger.json",
        ).then((res) => res.json()),
      }),
      connection,
    }
  ],
});
await agent.convert("I wanna buy a Macbook.");

import core from "@nestia/core";
import { Controller } from "@nestjs/common";
import { RouteIcon } from "@wrtnio/decorators";
import { tags } from "typia";
 
import { IPage } from "@samchon/shopping-api/lib/structures/common/IPage";
import { IShoppingActorEntity } from "@samchon/shopping-api/lib/structures/shoppings/actors/IShoppingActorEntity";
import { IShoppingSale } from "@samchon/shopping-api/lib/structures/shoppings/sales/IShoppingSale";
 
import { ShoppingSaleProvider } from "../../../../providers/shoppings/sales/ShoppingSaleProvider";
import { IShoppingControllerProps } from "../IShoppingControllerProps";
 
export function ShoppingSaleController<Actor extends IShoppingActorEntity>(
  props: IShoppingControllerProps,
) {
  @Controller(`shoppings/${props.path}/sales`)
  abstract class ShoppingSaleController {
    /**
     * List up every summarized sales.
     *
     * List up every {@link IShoppingSale.ISummary summarized sales}.
     *
     * As you can see, returned sales are summarized, not detailed. It does not
     * contain the SKU (Stock Keeping Unit) information represented by the
     * {@link IShoppingSaleUnitOption} and {@link IShoppingSaleUnitStock} types.
     * If you want to get such detailed information of a sale, use
     * `GET /shoppings/customers/sales/{id}` operation for each sale.
     *
     * > If you're an A.I. chatbot, and the user wants to buy or compose
     * > {@link IShoppingCartCommodity shopping cart} from a sale, please
     * > call the `GET /shoppings/customers/sales/{id}` operation at least once
     * > to the target sale to get detailed SKU information about the sale.
     * > It needs to be run at least once for the next steps.
     *
     * @param input Request info of pagination, searching and sorting
     * @returns Paginated sales with summarized information
     * @tag Sale
     *
     * @author Samchon
     */
    @RouteIcon(
      "https://ecosystem-connector.s3.ap-northeast-2.amazonaws.com/icons/store.svg",
    )
    @core.TypedRoute.Patch()
    public async index(
      @props.AuthGuard() actor: Actor,
      @core.TypedBody() input: IShoppingSale.IRequest,
    ): Promise<IPage<IShoppingSale.ISummary>> {
      return ShoppingSaleProvider.index({
        actor,
        input,
      });
    }
 
    /**
     * Get a sale with detailed information.
     *
     * Get a {@link IShoppingSale sale} with detailed information including
     * the SKU (Stock Keeping Unit) information represented by the
     * {@link IShoppingSaleUnitOption} and {@link IShoppingSaleUnitStock} types.
     *
     * > If you're an A.I. chatbot, and the user wants to buy or compose a
     * > {@link IShoppingCartCommodity shopping cart} from a sale, please call
     * > this operation at least once to the target sale to get detailed SKU
     * > information about the sale.
     * >
     * > It needs to be run at least once for the next steps. In other words,
     * > if you A.I. agent has called this operation to a specific sale, you
     * > don't need to call this operation again for the same sale.
     * >
     * > Additionally, please do not summarize the SKU information. Just show
     * > the every options and stocks in the sale with detailed information.
     *
     * @param id Target sale's {@link IShoppingSale.id}
     * @returns Detailed sale information
     * @tag Sale
     *
     * @author Samchon
     */
    @core.TypedRoute.Get(":id")
    public async at(
      @props.AuthGuard() actor: Actor,
      @core.TypedParam("id") id: string & tags.Format<"uuid">,
    ): Promise<IShoppingSale> {
      return ShoppingSaleProvider.at({
        actor,
        id,
      });
    }
  }
  return ShoppingSaleController;
}

import { tags } from "typia";
 
import { IShoppingPrice } from "../base/IShoppingPrice";
import { IShoppingSaleUnitStockChoice } from "./IShoppingSaleUnitStockChoice";
import { IShoppingSaleUnitStockInventory } from "./IShoppingSaleUnitStockInventory";
 
/**
 * Final component information on units for sale.
 *
 * `IShoppingSaleUnitStock` is a subsidiary entity of {@link IShoppingSaleUnit}
 * that represents a product catalog for sale, and is a kind of final stock that is
 * constructed by selecting all {@link IShoppingSaleUnitSelectableOption options}
 * (variable "select" type) and their
 * {@link IShoppingSaleUnitOptionCandidate candidate} values in the belonging unit.
 * It is the "good" itself that customers actually purchase.
 *
 * - Product Name) MacBook
 *   - Options
 *     - CPU: { i3, i5, i7, i9 }
 *     - RAM: { 8GB, 16GB, 32GB, 64GB, 96GB }
 *     - SSD: { 256GB, 512GB, 1TB }
 *   - Number of final stocks: 4 * 5 * 3 = 60
 *
 * For reference, the total number of `IShoppingSaleUnitStock` records in an
 * attribution unit can be obtained using Cartesian Product. In other words, the
 * value obtained by multiplying all the candidate values that each
 * (variable "select" type) option can have by the number of cases is the total
 * number of final stocks in the unit.
 *
 * Of course, without a single variable "select" type option, the final stocks
 * count in the unit is only 1.
 *
 * @author Samchon
 */
export interface IShoppingSaleUnitStock {
  /**
   * Primary Key.
   */
  id: string & tags.Format<"uuid">;
 
  /**
   * Representative name of the stock.
   */
  name: string;
 
  /**
   * Price of the stock.
   */
  price: IShoppingPrice;
 
  /**
   * Current inventory status of the stock.
   */
  inventory: IShoppingSaleUnitStockInventory;
 
  /**
   * List of choices.
   *
   * Which candidate values being chosen for each option.
   */
  choices: IShoppingSaleUnitStockChoice[];
}
export namespace IShoppingSaleUnitStock {
  /**
   * Invert information from the cart.
   */
  export interface IInvert {
    /**
     * Primary Key.
     */
    id: string & tags.Format<"uuid">;
 
    /**
     * Representative name of the stock.
     */
    name: string;
 
    /**
     * Price of the stock.
     */
    price: IShoppingPrice;
 
    /**
     * Quantity of the stock in the cart.
     */
    quantity: number & tags.Type<"uint32"> & tags.Minimum<1>;
 
    /**
     * Current inventory status of the stock.
     */
    inventory: IShoppingSaleUnitStockInventory;
 
    /**
     * List of choices.
     *
     * Which values being written for each option.
     */
    choices: IShoppingSaleUnitStockChoice.IInvert[];
  }
 
  /**
   * Creation information of the stock.
   */
  export interface ICreate {
    /**
     * Representative name of the stock.
     */
    name: string;
 
    /**
     * Price of the stock.
     */
    price: IShoppingPrice;
 
    /**
     * Initial inventory quantity.
     */
    quantity: number & tags.Type<"uint32"> & tags.Minimum<1>;
 
    /**
     * List of choices.
     *
     * Which candidate values being chosen for each option.
     */
    choices: IShoppingSaleUnitStockChoice.ICreate[];
  }
}

import { tags } from "typia";
 
import { IShoppingSaleUnitOptionCandidate } from "./IShoppingSaleUnitOptionCandidate";
 
/**
 * Individual option information on units for sale.
 *
 * `IShoppingSaleUnitSelectableOption` is a subsidiary entity of
 * {@link IShoppingSaleUnit} that represents individual products in the
 * {@link IShoppingSale sale}, and is an entity designed to represent individual
 * selectable option information for the unit.
 *
 * - Examples of Options
 *   - selectable options
 *     - Computer: CPU, RAM, SSD, etc.
 *     - Clothes: size, color, style, etc.
 *   - descriptive options
 *     - Engrave
 *     - Simple question
 *
 * If the {@link variable} property value is `true`, the final stock that the
 * {@link IShoppingCustomer customer} will purchase changes depending on the
 * selection of the {@link IShoppingSaleUnitOptionCandidate candidate value}.
 *
 * Conversely, if it is a type other than "select", or if the {@link variable}
 * property value is "false", , this is an option that has no meaning beyond
 * simple information transfer. Therefore, no matter what value the customer
 * chooses when purchasing it, the option in this case does not affect the
 * {@link IShoppingSaleUnitStock final stock}.
 *
 * @author Samchon
 */
export interface IShoppingSaleUnitSelectableOption
  extends IShoppingSaleUnitSelectableOption.IInvert {
  /**
   * List of candidate values.
   */
  candidates: IShoppingSaleUnitOptionCandidate[] & tags.MinItems<1>;
}
export namespace IShoppingSaleUnitSelectableOption {
  export interface IInvert {
    /**
     * Primary Key.
     */
    id: string & tags.Format<"uuid">;
 
    /**
     * Discriminant for the type of selectable option.
     */
    type: "select";
 
    /**
     * Represents the name of the option.
     */
    name: string;
 
    /**
     * Whether the option is variable or not.
     *
     * When type of current option is "select", this attribute means whether
     * selecting different candidate value affects the final stock or not.
     */
    variable: boolean;
  }
 
  /**
   * Creation information of the selectable option.
   */
  export interface ICreate {
    /**
     * Discriminant for the type of selectable option.
     */
    type: "select";
 
    /**
     * Represents the name of the option.
     */
    name: string;
 
    /**
     * Whether the option is variable or not.
     *
     * When type of current option is "select", this attribute means whether
     * selecting different candidate value affects the final stock or not.
     */
    variable: boolean;
 
    /**
     * List of candidate values.
     */
    candidates: IShoppingSaleUnitOptionCandidate.ICreate[] & tags.MinItems<1>;
  }
}