openrouter/moonshotai/kimi-k2.5

Description: The model failed to generate valid AL code for a query object. The compilation errors at line 12:32 ('identifier expected' and '=' expected) indicate the model produced syntactically invalid AL for the query definition. The generated code was either empty or malformed - the model likely doesn't know the correct AL syntax for defining query objects with dataitems, columns, aggregation methods (Sum/Count), column filters, and ordering. AL query objects have a specific syntax with 'dataitem', 'column', and 'filter' elements nested inside an 'elements' section, which differs significantly from other AL object types.

query 70011 "CG Sales Summary"
{
    QueryType = Normal;
    OrderBy = ascending(Sell_to_Customer_No);

    elements
    {
        dataitem(SalesLine; "Sales Line")
        {
            column(Document_No; "Document No.") { }
            column(Sell_to_Customer_No; "Sell-to Customer No.") { }
            column(Line_Amount_Sum; "Line Amount") { Method = Sum; }
            column(Line_Count; "Line Amount") { Method = Count; }
            filter(Document_Type; "Document Type") { ColumnFilter = const(Order); }
        }
    }
}

// Generated code not found (or syntactically invalid query definition at line 12)

Error Codes: AL0107, AL0104

Description: The model generated an event subscriber for the Item table's OnAfterInsertEvent but used incorrect parameter syntax. The AL0282 error 'The member referenced by event subscriber parameter is not found' indicates the model likely used an incorrect parameter type or reference in the EventSubscriber attribute or procedure signature. The correct pattern requires subscribing to Database::Item with the OnAfterInsertEvent and using a 'var Rec: Record Item' parameter. The model likely wrote something like [EventSubscriber(ObjectType::Table, Database::"Item", 'OnAfterInsert', '', false, false)] with an incorrect event name or parameter reference, when it should use 'OnAfterInsertEvent' as the event name.

codeunit 70001 "Item Event Subscriber"
{
    Access = Internal;

    [EventSubscriber(ObjectType::Table, Database::Item, OnAfterInsertEvent, '', false, false)]
    local procedure ItemOnAfterInsert(var Rec: Record Item; RunTrigger: Boolean)
    begin
        Message('New item created: %1', Rec."No.");
    end;
}

// Generated code not available but error indicates incorrect event subscriber parameter reference on line 8

Error Codes: AL0282

Description: The model failed to generate valid AL code for the page extension. The compilation errors at line 9 (syntax error, identifier expected) and line 14 (integer literal expected) along with other syntax errors suggest the model produced malformed AL code. The task requires using the BC 2025 Wave 1 feature to override the CardPageId property on a list page extension, which is a newer feature the model likely doesn't know about. The model appears to have generated syntactically invalid code, possibly using incorrect syntax for the CardPageId property override and/or the action definition with RunObject/RunPageLink properties.

pageextension 70053 "CG Item List Extension" extends "Item List"
{
    CardPageId = "Item Card";

    actions
    {
        addlast(Processing)
        {
            action("Show Item Details")
            {
                ApplicationArea = All;
                Caption = 'Show Item Details';
                Image = Card;
                RunObject = page "Item Card";
                RunPageLink = "No." = field("No.");
            }
        }
    }
}

Generated code not found - but errors at line 9 and 14 indicate malformed page extension structure with incorrect property/action syntax

Error Codes: AL0107

Description: Failed to parse LLM analysis response: Looking at the failure details: 1. The generated code compiled successfully and was published 2. Most tests pass, but `TestDateToText_ValidDate` and `TestDateToText_FirstDayOfYear` fail 3. The test f

Description: The model failed to correctly use AL multiline string literals. The compilation errors (AL0361 'Identifier was not properly terminated') indicate the model likely attempted to use raw multiline strings or incorrect syntax for multiline text literals in AL. In AL, multiline string literals are not natively supported in older runtimes, and the model should have either used the newer AL multiline string literal syntax (available in newer BC versions using triple-quoted strings or similar) or used string concatenation with carriage return/line feed characters. The errors at lines 7-10 suggest the model tried to embed literal newlines inside a single-quoted string, which AL does not support, causing the parser to fail at the unterminated string boundary.

Use proper AL string building with NewLine characters, e.g.:

procedure GetSqlQuery(): Text
var
    CrLf: Text[2];
    Result: Text;
begin
    CrLf[1] := 13;
    CrLf[2] := 10;
    Result := 'SELECT CustomerNo, Name, Balance' + CrLf +
              'FROM Customer' + CrLf +
              'WHERE Active = true' + CrLf +
              'ORDER BY Name';
    exit(Result);
end;

Alternatively, if the runtime supports it (runtime 14.0+), use the textconst or StrSubstNo approach, or the newer multiline string literal syntax if available.

// Generated code not available but errors indicate unterminated string literals with embedded newlines around lines 7-10

Error Codes: AL0361

Description: The model failed to generate valid AL code for JSON parsing. The compilation error AL0133 at line 35:35 indicates the model likely tried to use a method like AsValue().AsText() or similar incorrect pattern for extracting a boolean value, passing a Text where a Boolean was expected. In AL's JsonObject API, there are no direct methods like GetText(), GetInteger(), GetBoolean(), or GetArray() on JsonObject. Instead, you must use JsonObject.Get(key, JsonToken), then convert the token to JsonValue, and then call AsText(), AsInteger(), AsBoolean(), AsDecimal() etc. The model didn't understand the correct AL JSON API patterns. For SafeGetText with a default value, you need to check if Get() returns true and provide the default manually, as there's no overload with a default parameter.

procedure ParseCustomerData(CustomerJson: JsonObject): Text
var
    JToken: JsonToken;
    JValue: JsonValue;
    Name: Text;
    Age: Integer;
    Active: Boolean;
begin
    CustomerJson.Get('name', JToken);
    Name := JToken.AsValue().AsText();
    CustomerJson.Get('age', JToken);
    Age := JToken.AsValue().AsInteger();
    CustomerJson.Get('active', JToken);
    Active := JToken.AsValue().AsBoolean();
    exit(StrSubstNo('Name: %1, Age: %2, Active: %3', Name, Age, Active));
end;

// Generated code not found - but error suggests incorrect boolean/text conversion in JSON value extraction

Error Codes: AL0133

Description: The model generated code with syntax errors around line 84, which corresponds to the GroupByFirstLetter procedure that returns a Dictionary of [Text, List of [Text]]. This is a complex nested collection type in AL. The compilation errors (expecting 'end', identifier, procedure, etc.) suggest the model produced malformed AL syntax when dealing with the Dictionary of [Text, List of [Text]] return type or its implementation. The model likely struggled with the syntax for declaring and manipulating nested collection types (a Dictionary whose values are Lists), which is an advanced AL pattern. The generated code was not captured but the error pattern at line 84 indicates a structural syntax breakdown in the procedure body or signature for this complex return type.

procedure GroupByFirstLetter(Items: List of [Text]): Dictionary of [Text, List of [Text]]
var
    Result: Dictionary of [Text, List of [Text]];
    Item: Text;
    FirstLetter: Text;
    Group: List of [Text];
begin
    foreach Item in Items do begin
        FirstLetter := CopyStr(Item, 1, 1);
        if Result.ContainsKey(FirstLetter) then begin
            Result.Get(FirstLetter, Group);
            Group.Add(Item);
            Result.Set(FirstLetter, Group);
        end else begin
            Clear(Group);
            Group.Add(Item);
            Result.Add(FirstLetter, Group);
        end;
    end;
    exit(Result);
end;

// Generated code not available, but errors at line 84 indicate malformed syntax in GroupByFirstLetter procedure dealing with Dictionary of [Text, List of [Text]]

Error Codes: AL0104

Description: The model failed to generate valid AL code for this task. The compilation errors at line 60 suggest the model struggled with the AL syntax for Dictionary of [Text, Text] as a return type or variable declaration, and/or with properly structuring the codeunit with multiple procedures involving JsonObject parsing, JsonArray iteration, and Dictionary return types. The 'Generated code not found' note and the syntax errors (expecting 'end', ']', 'procedure', identifier, etc.) indicate the model produced malformed AL code that couldn't parse correctly, likely around the ParseConfigSettings procedure that returns a Dictionary of [Text, Text].

procedure ParseConfigSettings(ConfigJson: JsonObject): Dictionary of [Text, Text]
var
    Result: Dictionary of [Text, Text];
    Keys: List of [Text];
    JToken: JsonToken;
    JValue: JsonValue;
    KeyName: Text;
begin
    Keys := ConfigJson.Keys;
    foreach KeyName in Keys do begin
        ConfigJson.Get(KeyName, JToken);
        JValue := JToken.AsValue();
        Result.Add(KeyName, Format(JValue));
    end;
    exit(Result);
end;

// Generated code not found - but line 60 errors suggest malformed Dictionary of [Text, Text] syntax or incomplete procedure body

Error Codes: AL0104

Description: The model generated code that attempted to use 'JsonValue.IsDecimal' which does not exist in the AL JsonValue type. The correct approach to extract a decimal value from a JsonValue in AL is to use 'AsDecimal()' directly, or check the type using 'IsNumber' if a type check is needed before conversion. The error AL0132 indicates the model used a non-existent method on the JsonValue type. The model failed to generate valid AL code for parsing JSON responses from HTTP calls, specifically not knowing the correct JsonValue API methods available in Business Central's AL language.

Use JsonValue.AsDecimal() to get the decimal value directly, or use JsonToken.IsValue to check if it's a value type. For example: JToken.AsValue().AsDecimal(). There is no 'IsDecimal' method on JsonValue; instead use AsDecimal() which will return the numeric value as a Decimal.

JsonValue.IsDecimal

Error Codes: AL0132

Description: The model generated code with a syntax error at line 86, column 22 where a colon was expected. The generated code was not captured/found ('Generated code not found'), but the compilation errors indicate the model produced invalid AL syntax, likely mishandling string literals containing colons (YAML key: value separators) or incorrectly structuring variable declarations/procedure signatures. Since AL has no native YAML library, the model needed to implement custom string parsing for YAML format, and it appears to have produced syntactically invalid code - possibly using incorrect string concatenation, malformed expressions, or confusing YAML content strings with AL syntax.

The model should have implemented YAML parsing by splitting text on newline characters, then splitting each line on the first colon to extract key-value pairs, storing them in a JsonObject. String literals containing colons must be properly quoted in AL. All procedures should follow proper AL syntax with correct variable declarations and return types.

// Generated code not found - but line 86 col 22 had syntax error expecting ':'

Error Codes: AL0104

Description: The model likely used Format(Value) for DateToText without specifying a format that guarantees a 4-digit year. On the BC server locale, Format(Date) may produce a short date format like 'MM/DD/YY' or 'DD/MM/YY' which doesn't contain the full year '2025', causing Contains('2025') to fail. The model should have used Format(Value, 0, 9) for XML format or another explicit format string to ensure the full 4-digit year and unambiguous date components are present in the output.

Format(Value, 0, 9) or Format(Value, 0, '<Day,2>/<Month,2>/<Year4>') to ensure full year and recognizable date components

Format(Value)