ObjectScript SDK

Set provider = ##class(%AI.Provider).Create("openai", {
    "api_key": "..."
})

Set provider = ##class(%AI.Provider).Create("anthropic", {
    "api_key": "..."
})

Set provider = ##class(%AI.Provider).Create("gemini", {
    "api_key": "..."
})

Set provider = ##class(%AI.Provider).Create("vertex", {
    "project_id": "your-project-id"
    "region": "us-east5",
    "service_account_path": "/path/to/service_account.json"
})

Set provider = ##class(%AI.Provider).Create("bedrock", {
    "region": "us-east-1"
})

Set provider = ##class(%AI.Provider).Create("bedrock", {
    "region": "us-east-1",
    "bearer_token": "..."
})

Set provider = ##class(%AI.Provider).Create("bedrock", {
    "region": "us-east-1"
})

Set provider = ##class(%AI.Provider).Create("meta", {
    "api_key": "..."
})

Set provider = ##class(%AI.Provider).Create("xai", {
    "api_key": "..."
})

Set provider = ##class(%AI.Provider).Create("nim", {
    "base_url": "http://localhost:8000/v1"
})

Set provider = ##class(%AI.Provider).Create("deepseek", {
    "api_key": "..."
})

Set provider = ##class(%AI.Provider).Create("kimi", {
    "api_key": "...",
})

Set provider = ##class(%AI.Provider).Create("openrouter", {
    "api_key": "...",
})

Set agent.Model = "gpt-4"
Set agent.SystemPrompt = "You are a helpful assistant."
Set agent.Temperature = 0.7
Set agent.MaxIterations = 15

// Create provider
set config = ##class(%DynamicObject).%New()
set key = $SYSTEM.Util.GetEnviron("OPENAI_API_KEY")
do config.%Set("api_key", key)
set provider = ##class(%AI.Provider).Create("openai", config)

// Create agent
Set agent = ##class(%AI.Agent).%New(provider)
Set agent.Model = "gpt-4"
Set agent.SystemPrompt = "You are a helpful assistant."

// Create session from agent
Set session = agent.CreateSession()

Set session = ##class(%AI.Agent.Session).Create(
    provider,                   // %AI.Provider instance
    "gpt-4",                    // model
    "You are helpful.",         // system prompt
    toolsJson,                  // (optional) tool schemas from agent.ToolManager.%Discover()
    config                      // (optional) config object with session properties
)

set response = agent.Chat(session, "Is zero even?")
w response.Content

Yes, zero is considered an even number.

set response = agent.Chat(session, "What about positive or negative?")
w response.Content

Zero is neither positive nor negative.

SET tinyPng = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk" _ "+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="

SET content = ##class(%AI.LLM.ContentPart).Build(
    ##class(%AI.LLM.ContentPart).Text("Describe what you see in this image in one sentence."),
    ##class(%AI.LLM.ContentPart).ImageData(tinyPng, "image/png")
)

WRITE "Sending inline base64 image...", !, !
SET response = agent.ChatWithContent(session, content)
WRITE response.Content

The image appears to be a small, solid light-green square with no discernible objects or details.

ClassMethod CreateContentPart(imagePath As %String, prompt As %String) As %AI.LLM.ContentPart
{
    // Read and encode image in Base64
    Set stream = ##class(%Stream.FileBinary).%New()
    Do stream.LinkToFile(imagePath)
    Set bytes = stream.Read(stream.Size)
    Set base64 = $SYSTEM.Encryption.Base64Encode(bytes)
    Set extension = $piece(imagePath, ".", *)

    // Construct the ContentPart
    SET contentPart = ##class(%AI.LLM.ContentPart).Build(
        ##class(%AI.LLM.ContentPart).Text(prompt),
        ##class(%AI.LLM.ContentPart).ImageData(base64, "image/" _ extension)
    )

    Return contentPart
}

set contentPart = ##class(Sample.MultiModal).CreateContentPart("/img/example.png", "Describe the image.")
Set response = agent.ChatWithContent(session, contentPart)
Write response.Content

The image shows a close-up of a beaver with wet brown fur sitting near the water or on a log, set against a softly blurred green-and-gold natural background.

Set content = ##class(%AI.LLM.ContentPart).Build(
##class(%AI.LLM.ContentPart).Text("What do you see in this image?"),
##class(%AI.LLM.ContentPart).ImageURL("https://example.com/image.jpg"))

Class Sample.GetServerTime Extends %AI.Tool
{

Property Name As %String [ InitialExpression = "GetServerTime" ];

Property Description As %String(MAXLEN = "") [ InitialExpression = "Gets the current server time." ];

ClassMethod GetServerTime() As %String
{
    Return $ZTIME($PIECE($HOROLOG,",",2),1)
}
}

Class Sample.CountFiles Extends %AI.Tool
{

Property Name As %String [ InitialExpression = "CountFiles" ];

Property Description As %String(MAXLEN = "") [ InitialExpression = "Returns the number of files in a directory." ];

ClassMethod CountFiles(path As %String) As %Integer
{
    Set dir = ##class(%File).NormalizeDirectory(path)
    Set res = ##class(%ResultSet).%New("%File:FileSet")
    Do res.Execute(dir, "*", , 0)
    Set count = 0
    While res.Next() { Set count = count + 1 }
    Return count
}
}

Class Sample.SampleToolset Extends %AI.ToolSet
{

XData Definition [ MimeType = application/xml ]
{
<ToolSet Name="SampleToolset">
    <Description>General utilities</Description>
    
    <!-- Include separately defined %AI.Tool classes -->
    <Include Class="Sample.GetServerTime" />
    <Include Class="Sample.CountFiles" />
</ToolSet>
}
}

SET sc = agent.UseToolSet("Sample.SampleToolset")

Class Sample.SampleToolset Extends %AI.ToolSet
{

XData Definition [ MimeType = application/xml ]
{
<ToolSet Name="SampleToolset">
    <Description>General utilities</Description>
    
    <!-- Include separately defined %AI.Tool classes -->
    <Include Class="Sample.GetServerTime" />
    <Include Class="Sample.CountFiles" />

    <!-- Include a method defined inside this %AI.ToolSet -->
    <Tool Name="GetServerDate" Method="GetDate"/>
</ToolSet>
}

ClassMethod GetDate() As %String
{
    Return $ZDATE($PIECE($HOROLOG,",",1),1)
}
}

<Tool Name="GetServerDate" Method="GetDate">
	<Description>Returns the server date of the InterSystems IRIS instance.</Description>
</Tool>

Class Sample.DataTools Extends %AI.ToolSet
{
    /// Delegates to Patient.SearchByName and returns JSON
    Method SearchPatients(name As %String) As %String
    {
        Set results = ##class(MyApp.Patient).SearchByName(name)

        Set output = []
        While results.%Next() {
            Do output.%Push({
                "id": (results.ID),
                "name": (results.Name),
                "dob": (results.DOB)
            })
        }

        Return output.%ToJSON()
    }
}

Class Sample.Notepad Extends %AI.Tool
{

Property Name As %String [ InitialExpression = "Notepad" ];

Property Description As %String(MAXLEN = "") [ InitialExpression = "A notepad." ];

Property Notes As %String(MAXLEN = "");

/// Store a note for later retrieval in this session.
Method Remember(note As %String(DESCRIPTION="The note to store")) As %String
{
        Set ..Notes = ..Notes _ note _ $C(10)
        Return "Noted."
}

/// Recall all notes stored in this session.
Method Recall() As %String
{
        Return $SELECT(..Notes = "": "No notes stored yet.", 1: ..Notes)
}

/// Clear all stored notes.
Method Forget() As %String
{
        Set ..Notes = ""
        Return "Notes cleared."
}

}

SET response = agent.Chat(session, "Make a note to buy eggs.")
SET response = agent.Chat(session, "Note the weather (chilly).")
SET response = agent.Chat(session, "I forgot the milk, so add a note for that.")
SET response = agent.Chat(session, "What do my notes say?")

WRITE response.Content

Here are your notes:

1. Buy eggs
2. The weather is chilly
3. Buy milk

| ID |      Name      |       Email       |
| -- | -------------- | ----------------- |
| 1  | Alice Johnson  | [email protected] |
| 2  | Bob Smith      | [email protected]   |
| 3  | Carol White    | [email protected] |
| 4  | April May      | [email protected] |

DO $SYSTEM.SQL.Execute("CREATE TABLE users.customers (ID INTEGER IDENTITY, Name VARCHAR(100), Email VARCHAR(255))")

DO $SYSTEM.SQL.Execute("INSERT INTO users.customers VALUES ('Alice Johnson', '[email protected]')")
DO $SYSTEM.SQL.Execute("INSERT INTO users.customers VALUES ('Bob Smith', '[email protected]')")
DO $SYSTEM.SQL.Execute("INSERT INTO users.customers VALUES ('Carol White', '[email protected]')")
DO $SYSTEM.SQL.Execute("INSERT INTO users.customers VALUES ('April May', '[email protected]')")

// Enable Smart Discovery
agent.ToolMgr.EnableSmartDiscovery()

/// Find businesses within the radius (in miles) of the specified address
Method FindNearby(address As MyApp.Address, radiusMiles As %Float) As %DynamicArray { ... }

Class MyApp.Address Extends %RegisteredObject
{
    Property Street As %String;
    Property City As %String;
    Property ZipCode As %String;
}

{
    "type": "object",
    "properties": {
      "Street": {"type": "string"},
      "City":   {"type": "string"},
      "ZipCode": {"type": "string"}
    }
}

Include %AI

/// Sample authorization policy that restricts file access to allowed paths
/// This example demonstrates how to implement security policies for file operations
Class Sample.AI.Policies.PathSanitizerPolicy Extends %AI.Policy.Authorization
{

/// List of allowed path prefixes
Property AllowedPath As list Of %String(MAXLEN = "");

/// If true, deny access to paths not in AllowedPath list
Property Strict As %Boolean;

Method %CanExecute(tool As %String, call As %DynamicObject, metadata As %DynamicObject) As %Status
{
    // Parse arguments
    Set args = {}.%FromJSON(call.arguments)

    // Check for path parameter
    If args.%IsDefined("path") {
        Set path = args.path
        Set allowed = 0

        // Check if path starts with an allowed prefix
        For i=1:1:..AllowedPath.Count() {
            Set allowedPrefix = ..AllowedPath.GetAt(i)
            If $EXTRACT(path, 1, $LENGTH(allowedPrefix)) = allowedPrefix {
                Set allowed = 1
                Quit
            }
        }

        If 'allowed && ..Strict {
            Return $$$ERROR($$$AICoreToolAccessDenied, "Path not in allowed list: "_path)
        }

        // Sanitize path (remove relative components)
        Set sanitized = ##class(%File).NormalizeFilename(path)
        If sanitized '= path {
            Set args.path = sanitized
            Set call.arguments = args.%ToJSON()
        }
    }

    Return $$$OK
}

}

Class MyApp.DatabaseAudit Extends %AI.Policy.Audit
{
    Method %LogExecution(call, metadata, result, duration, status)
    {
        Set log = ##class(MyApp.ToolAuditLog).%New()
        Set log.Timestamp = $ZDATETIME($HOROLOG, 3)
        Set log.ToolName = call.name
        Set log.Arguments = call.arguments.%ToJSON()
        Set log.Success = $$$ISOK(status)
        Set log.DurationMs = duration
        Set resultJson = result.%ToJSON()
        Set log.ResultSize = $LENGTH(resultJson)

        If $$$ISOK(status) {
            Set log.ResultPreview = $EXTRACT(resultJson, 1, 200)
        } Else {
            Set log.Error = $SYSTEM.Status.GetErrorText(status)
        }

        Do log.%Save()
    }
}

Include %AI

/// Dynamic tool discovery from compiled class queries.
///
/// Scans one or more ObjectScript classes for SqlProc class queries and makes each one
/// callable as an agent tool without any compile-time registration.
/// Demonstrates both halves of %AI.Policy.Discovery:
///
///   %Resolve  -- query %Dictionary.CompiledQuery for all metadata in one pass,
///                build tool specs from FormalSpec (parameters) and ResultSetReturnsSchema,
///                reusing %AI.Tool.Schema and %AI.Tools.SQL helpers
///   %Execute  -- dispatch to %PrepareClassQuery + %Execute via variadic args,
///                then format results via %AI.Tools.SQL.FormatResultSet
///
/// Tool names are prefixed with the last class-name segment, e.g.:
///   Sample.AI.Orders.Order + SearchByStatus -> Order_SearchByStatus
///
Class Sample.AI.Policies.ClassQueryDiscovery Extends %AI.Policy.Discovery
{

/// Comma-separated list of fully-qualified class names to scan.
Property Classes As %String(MAXLEN = "");

/// Maximum rows returned per query call.
Property MaxRows As %Integer [ InitialExpression = 100 ];

/// Internal dispatch table: toolname -> {class, query, params}
/// params is a $LIST of parameter names in declaration order.
Property ToolMap As %DynamicObject [ Internal ];

Method %OnNew(classes As %String, maxRows As %Integer = 100) As %Status [ Internal ]
{
    Set ..Classes = classes
    Set ..MaxRows = maxRows
    Set ..ToolMap = {}
    Return $$$OK
}

// ---------------------------------------------------------------------------
// %Resolve
// ---------------------------------------------------------------------------

Method %Resolve(catalog As %DynamicArray) As %Status
{
    Set ..ToolMap = {}
    For i = 1:1:$LENGTH(..Classes, ",") {
        Set cls = $ZSTRIP($PIECE(..Classes, ",", i), "<>W")
        If cls = "" Continue
        $$$ThrowOnError(..ResolveClass(cls, catalog))
    }
    Return $$$OK
}

Method ResolveClass(cls As %String, catalog As %DynamicArray) As %Status [ Internal, Private ]
{
    Set prefix = $PIECE(cls, ".", *)  // last segment used as tool-name prefix

    // Single query fetches all metadata needed for the tool spec and dispatch table.
    // SqlRowSpec is not used directly -- return shape comes from ResultSetReturnsSchema().
    Set rs = ##class(%SQL.Statement).%ExecDirect(,
        "SELECT Name, Description, FormalSpec " _
        "FROM %Dictionary.CompiledQuery " _
        "WHERE parent->ID = ? AND SqlProc = 1 AND Deprecated = 0 " _
        "ORDER BY Name",
        cls)
    If rs.%SQLCODE < 0 {
        Return $$$ERROR($$$SQLError, rs.%SQLCODE, rs.%Message)
    }

    While rs.%Next() {
        Set qname      = rs.%Get("Name")
        Set desc       = rs.%Get("Description")
        Set formalspec = rs.%Get("FormalSpec")

        If desc = "" Set desc = "Execute " _ cls _ " query " _ qname _ "."

        // Parse the FormalSpec into a local array; ParseFormalSpec kills parsedArgs first
        $$$ThrowOnError(..ParseFormalSpec(qname, formalspec, .parsedArgs))

        // Build parameter JSON Schema and record name order for dispatch
        Set paramschema = {"type": "object", "properties": {}, "required": []}
        Set paramorder  = ""
        For i = 1:1:parsedArgs {
            Set argname = parsedArgs(i)
            Set argtype = $GET(parsedArgs(i, 2), "%String")
            Set argdesc = ##class(%Global).Unquote($GET(parsedArgs(i, 2, "DESCRIPTION")))

            Set sc = ##class(%AI.Tool.Schema).%ElementSchema(argtype, .propschema)
            If $$$ISERR(sc) Set propschema = {"type": "string"}
            If argdesc '= "" Set propschema.description = argdesc

            Do paramschema.properties.%Set(argname, propschema)
            If '$DATA(parsedArgs(i, 3)) Do paramschema.required.%Push(argname)
            Set paramorder = paramorder _ $LB(argname)
        }

        Set toolname = prefix _ "_" _ qname

        Do catalog.%Push({
            "name":        (toolname),
            "description": (desc),
            "source":      "iris",
            "parameters":  (paramschema),
            "returns":     (##class(%AI.Tools.SQL).ResultSetReturnsSchema()),
            "metadata":    {"kind": "query", "provider": "ClassQueryDiscovery"}
        })

        Do ..ToolMap.%Set(toolname, {
            "class":  (cls),
            "query":  (qname),
            "params": (paramorder)
        })
    }
    If rs.%SQLCODE < 0 {
        Return $$$ERROR($$$SQLError, rs.%SQLCODE, rs.%Message)
    }
    Return $$$OK
}

/// Parse a compiled query FormalSpec string into a local array of argument
/// descriptors, using the IRIS compiler's own parsing routine.
///
/// After the call, parsedArgs contains:
///   parsedArgs       = total number of arguments
///   parsedArgs(i)    = argument name
///   parsedArgs(i, 2) = IRIS type (e.g. "%String", "%Integer")
///   parsedArgs(i, 2, "DESCRIPTION") = DESCRIPTION type-parameter if present
///   parsedArgs(i, 3) = default value (key absent = no default = required)
///
/// $$parseFormal^%occName is the IRIS compiler utility used internally to parse
/// method and query formal specifications.  The first argument must be "Method"
/// even for queries -- it controls how the spec is interpreted.
ClassMethod ParseFormalSpec(queryName As %String, formalSpec As %String, Output parsedArgs) As %Status [ Internal, Private ]
{
    Kill parsedArgs
    Try {
        Do $$parseFormal^%occName("Method", queryName, formalSpec, .parsedArgs)
    } Catch ex {
        Return ex.AsStatus()
    }
    Return $$$OK
}

// ---------------------------------------------------------------------------
// %Execute
// ---------------------------------------------------------------------------

Method %Execute(toolName As %String, args As %DynamicObject) As %DynamicObject
{
    Set entry = ..ToolMap.%Get(toolName)
    If '$ISOBJECT(entry) Return $$$NULLOREF  // not our tool

    Set cls    = entry.class
    Set qname  = entry.query
    Set porder = entry.params  // $LIST of parameter names in declaration order

    Set stmt = ##class(%SQL.Statement).%New()
    $$$ThrowOnError(stmt.%PrepareClassQuery(cls, qname))

    // Build positional args in formalspec order then spread into %Execute.
    // callArgs = 0 ensures zero-parameter queries dispatch correctly.
    Kill callArgs
    Set callArgs = 0
    For i = 1:1:$LL(porder) {
        Set callArgs($I(callArgs)) = args.%Get($LG(porder, i))
    }

    Set t0 = $zh
    // %SQLCODE on the result is checked inside FormatResultSet (returns error object on failure)
    Set rs = stmt.%Execute(callArgs...)

    Return ##class(%AI.Tools.SQL).FormatResultSet(rs, ..MaxRows, t0)
}

}

Set policy = ##class(Sample.AI.Policies.ClassQueryDiscovery).%New("Example.Order,Example.Product")

Do agent.ToolMgr.SetDiscoveryPolicy(policy)

Class MyApp.ReadOnlyPolicy Extends %AI.Policy.Authorization
    {
        Method %CanExecute(tool As %String, call As %DynamicObject, metadata As %DynamicObject) As %Status
        {
            // Extract tool name
            Set toolName = call.name
    
            // Deny all write/delete operations
            If (toolName = "delete_file") ||
               (toolName = "write_file") ||
               (toolName = "append_file") {
                Return $$$ERROR($$$AICoreToolAccessDenied, "Write operations not allowed in read-only mode")
            }
    
            Return $$$OK
        }
    }

Class MyApp.DatabaseAudit Extends %AI.Policy.Audit
    {
        Method %LogExecution(call, metadata, result, duration, status)
        {
            Set log = ##class(MyApp.ToolAuditLog).%New()
            Set log.Timestamp = $ZDATETIME($HOROLOG, 3)
            Set log.ToolName = call.name
            Set log.Arguments = call.arguments.%ToJSON()
            Set log.Success = $$$ISOK(status)
            Set log.DurationMs = duration
            Set resultJson = result.%ToJSON()
            Set log.ResultSize = $LENGTH(resultJson)
    
            If $$$ISOK(status) {
                Set log.ResultPreview = $EXTRACT(resultJson, 1, 200)
            } Else {
                Set log.Error = $SYSTEM.Status.GetErrorText(status)
            }
    
            Do log.%Save()
        }
    }

// Create an instance of the skill
Set skill = ##class(Sample.SummarizeDocument).%New()

// Export to a directory
// This exports the skill to /opt/skills/summarize-document/SKILL.md
Set path = skill.ExportSkill("/opt/skills")
    
// Export to a file
// This exports the skill to /opt/skills/summarize-document.md
Set path = skill.ExportSkill("/opt/skills/summarize-document.md")
    
// Export to a stream
Set stream = ##class(%Stream.GlobalCharacter).%New()
Do skill.ExportSkill(stream)

// From a directory
Set skillFromDirectory = ##class(%AI.Agent.Skill).("file:///opt/skills/summarize")
    
// From a file path
Set skillFromFile = ##class(%AI.Agent.Skill).GetSkillFromURI("file:///opt/skills/summarize-document.md")

// From a git repository
Set skillFromRemote = ##class(%AI.Agent.Skill).GetSkillFromURI("https://github.com/myorg/skills", "summarize")

agent.useSkill(skillFromFile)

SET sampleConfigData = { "domain" : "example.com" }

DO ##class(Security.Resources).Create("ExampleReadResource")
DO ##class(Security.Resources).Create("ExampleEditResource")

DO ##(%ConfigStore.Configuration).Create(
    "Area",                      ; Area*
    "Type",                      ; Type*
    "Subtype",                   ; Subtype
    "Example",                   ; Logical name*
    sampleConfigData,            ; Details, either JSON or %DynamicObject*
    "Example Configuration",     ; Display name
    "An example configuration",  ; Description
    "ExampleReadResource",       ; Read resource; if omitted, any user can read the resource
    "ExampleEditResource",       ; Edit resource; if omitted, any user can edit the resource
    1                            ; Enables the Configuration (default: 1)
    0                            ; Validates the Configuration with a descriptor (default: 1)
)

Class Sample.ProviderDescriptor Extends ConfigStore.Descriptor
{
    Parameter Area = "AI";
    Parameter Type = "LLM";
    Parameter Subtype = "";

    XData Schema [ MimeType = application/json ]
    {
        {
            "provider": {
                "type": "string",
                "required": true,
                "description": "The provider ID, one of the following: openai | gemini"
            },
            "api_key": {
                "type": "secret",
                "required": true,
                "description": "The API key"
            }
        }
    }
}

secret://CollectionName.SecretName.FieldName

// --- Secure Wallet Setup ---
// --- Create Collection: AISecrets ---
WRITE ##class(Security.Resources).Create("CollUseResource")
WRITE ##class(Security.Resources).Create("CollEditResource")
WRITE ##class(%Wallet.Collection).Create("AISecrets", {"UseResource" : "CollUseResource", "EditResource" : "CollEditResource"})

// --- Create a secret containing the OpenAI API key: OpenAIKey ---
// (which is retrieved from the "OPENAI_API_KEY" environment variable)
SET secret = {"Usage": "CUSTOM", "Secret": {"api_key": ($SYSTEM.Util.GetEnviron("OPENAI_API_KEY"))}}
SET sc = ##class(%Wallet.KeyValue).Create("AISecrets.OpenAIKey", secret)

// Create details, referencing the api_key secret stored in the Secure Wallet
SET details = { "provider": "openai", "api_key": "secret://AISecrets.OpenAIKey#api_key" }

// Create the configuration, specifying 1 for the final argument to validate it against the descriptor
SET sc = ##class(%ConfigStore.Configuration).Create("AI", "LLM", "", "OpenAIExample", details, "", "", "", "", 1, 1)

// Retrieve details from config store
SET sc = ##class(%ConfigStore.Configuration).Get("AI.LLM.OpenAIExample", .retrievedDetails, 1, 1)

// Create provider
SET provider = ##class(%AI.Provider).Create(retrievedDetails.provider, retrievedDetails)

// Full FQN -- used as-is
Parameter PROVIDERCONFIG = "@{config.AI.LLM.ProductionLLM}";

// Short form -- AI.LLM is prepended automatically
Parameter PROVIDERCONFIG = "@{config.ProductionLLM}";

// With subtype
Parameter PROVIDERCONFIG = "@{config.AI.LLM.OpenAI.ProductionLLM}";

%ConfigStore.Configuration.Modify(
    name,             ; %String
    details,          ; JSON/%DynamicObject
    displayName,      ; %String
    description,      ; %String
    readResourceName, ; %String, modifying this requires %Admin_ConfigStore:U
    editResourceName, ; %String, modifying this requires %Admin_ConfigStore:U
    enabled           ; %Boolean
    validateDetails   ; %Boolean, whether to validate the configuration with a descriptor
)

SET sc = ##class(%ConfigStore.Configuration).Modify(
    "AI.LLM.openai",,,"New description"
)

do ##class(%ConfigStore.Configuration).Delete("AI.LLM.openai")