diff --git a/extensions/mssql/l10n/bundle.l10n.json b/extensions/mssql/l10n/bundle.l10n.json
index 71d9c3f369..d156566173 100644
--- a/extensions/mssql/l10n/bundle.l10n.json
+++ b/extensions/mssql/l10n/bundle.l10n.json
@@ -560,6 +560,8 @@
     },
     "Chat": "Chat",
     "Open in GitHub Copilot Chat": "Open in GitHub Copilot Chat",
+    "Ask GitHub Copilot to Fix": "Ask GitHub Copilot to Fix",
+    "Open GitHub Copilot Chat to help fix these errors": "Open GitHub Copilot Chat to help fix these errors",
     "Design Schemas with GitHub Copilot": "Design Schemas with GitHub Copilot",
     "Ask questions or propose schema changes in chat, and GitHub Copilot updates the schema instantly in the diagram.": "Ask questions or propose schema changes in chat, and GitHub Copilot updates the schema instantly in the diagram.",
     "Build APIs with GitHub Copilot": "Build APIs with GitHub Copilot",
diff --git a/extensions/mssql/src/controllers/mainController.ts b/extensions/mssql/src/controllers/mainController.ts
index 4ae2144e5a..1556f615ff 100644
--- a/extensions/mssql/src/controllers/mainController.ts
+++ b/extensions/mssql/src/controllers/mainController.ts
@@ -937,6 +937,7 @@ export default class MainController implements vscode.Disposable {
     private async openCopilotChatFromUi(args?: CopilotChat.OpenFromUiArgs): Promise<void> {
         const scenario = args?.scenario ?? "schemaDesigner";
         const entryPoint = args?.entryPoint ?? "schemaDesignerToolbar";
+        const promptOverride = args?.prompt?.trim();
         const sendCopilotChatEntryTelemetry = (
             success: boolean,
             reason?: "noActiveDesigner" | "chatCommandMissing",
@@ -967,10 +968,11 @@ export default class MainController implements vscode.Disposable {
             return;
         }
 
-        await vscode.commands.executeCommand(
-            chatCommand,
-            this.getCopilotChatPromptForScenario(scenario),
-        );
+        const promptToUse =
+            promptOverride && promptOverride.length > 0
+                ? promptOverride
+                : this.getCopilotChatPromptForScenario(scenario);
+        await vscode.commands.executeCommand(chatCommand, promptToUse);
         sendCopilotChatEntryTelemetry(true);
     }
 
diff --git a/extensions/mssql/src/reactviews/common/locConstants.ts b/extensions/mssql/src/reactviews/common/locConstants.ts
index de5ae7d776..e0b1f297c0 100644
--- a/extensions/mssql/src/reactviews/common/locConstants.ts
+++ b/extensions/mssql/src/reactviews/common/locConstants.ts
@@ -808,6 +808,10 @@ export class LocConstants {
             publishChanges: l10n.t("Apply Changes"),
             openCopilotForSchemaDesigner: l10n.t("Chat"),
             openCopilotForSchemaDesignerTooltip: l10n.t("Open in GitHub Copilot Chat"),
+            askGithubCopilotToFix: l10n.t("Ask GitHub Copilot to Fix"),
+            askGithubCopilotToFixTooltip: l10n.t(
+                "Open GitHub Copilot Chat to help fix these errors",
+            ),
             schemaDesignerCopilotDiscoveryTitle: l10n.t("Design Schemas with GitHub Copilot"),
             schemaDesignerCopilotDiscoveryBody: l10n.t(
                 "Ask questions or propose schema changes in chat, and GitHub Copilot updates the schema instantly in the diagram.",
diff --git a/extensions/mssql/src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton.tsx b/extensions/mssql/src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton.tsx
index 5b970326c8..35c7946ee3 100644
--- a/extensions/mssql/src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton.tsx
+++ b/extensions/mssql/src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton.tsx
@@ -26,8 +26,17 @@ import Markdown from "react-markdown";
 import { SchemaDesigner } from "../../../../sharedInterfaces/schemaDesigner";
 import { useMarkdownStyles } from "../../../common/styles";
 import { useSchemaDesignerChangeContext } from "../definition/changes/schemaDesignerChangeContext";
+import { useSchemaDesignerSelector } from "../schemaDesignerSelector";
+import { CopilotChat } from "../../../../sharedInterfaces/copilotChat";
+import { ExecuteCommandRequest } from "../../../../sharedInterfaces/webview";
+import { GithubCopilot16Regular } from "../../../common/icons/fluentIcons";
+import {
+    schemaDesignerPublishErrorDetailsLabel,
+    schemaDesignerPublishErrorFallbackDetails,
+    schemaDesignerPublishErrorPrompt,
+} from "./publishChangesDialogPrompts";
 
-enum PublishDialogStages {
+export enum PublishDialogStages {
     NotStarted = "notStarted",
     ReportLoading = "reportLoading",
     ReportError = "reportError",
@@ -47,6 +56,45 @@ type PublishChangesDialogState = {
     currentStage: PublishDialogStages;
 };
 
+export function buildSchemaDesignerPublishErrorPrompt(errorString: string): string {
+    const errorDetails = errorString.trim() || schemaDesignerPublishErrorFallbackDetails;
+    return `${schemaDesignerPublishErrorPrompt}
+
+${schemaDesignerPublishErrorDetailsLabel}
+\`\`\`
+${errorDetails}
+\`\`\``;
+}
+
+export function isReportOrPublishErrorStage(currentStage: PublishDialogStages): boolean {
+    return (
+        currentStage === PublishDialogStages.ReportError ||
+        currentStage === PublishDialogStages.PublishError
+    );
+}
+
+export function getReportOrPublishErrorForStage(
+    currentStage: PublishDialogStages,
+    reportError: string | undefined,
+    publishError: string | undefined,
+): string {
+    if (currentStage === PublishDialogStages.ReportError) {
+        return reportError ?? "";
+    }
+    if (currentStage === PublishDialogStages.PublishError) {
+        return publishError ?? "";
+    }
+    return "";
+}
+
+export function shouldShowGithubCopilotFixButton(
+    currentStage: PublishDialogStages,
+    isCopilotChatInstalled: boolean,
+    isDabEnabled: boolean,
+): boolean {
+    return isReportOrPublishErrorStage(currentStage) && isCopilotChatInstalled && isDabEnabled;
+}
+
 const useStyles = makeStyles({
     errorSection: {
         marginBottom: "15px",
@@ -67,6 +115,8 @@ export function PublishChangesDialogButton() {
     const markdownClasses = useMarkdownStyles();
     const context = useContext(SchemaDesignerContext);
     const changeContext = useSchemaDesignerChangeContext();
+    const isCopilotChatInstalled =
+        useSchemaDesignerSelector((s) => s?.isCopilotChatInstalled) ?? false;
     const [open, setOpen] = useState(false);
     const [publishButtonDisabled, setPublishButtonDisabled] = useState(false);
     const hasSchemaChanges = changeContext.schemaChangesCount > 0;
@@ -372,6 +422,42 @@ export function PublishChangesDialogButton() {
         );
     };
 
+    const isGithubCopilotFixButtonVisible = () => {
+        return shouldShowGithubCopilotFixButton(
+            state.currentStage,
+            isCopilotChatInstalled,
+            context.isDabEnabled(),
+        );
+    };
+
+    const getCurrentError = () => {
+        return getReportOrPublishErrorForStage(
+            state.currentStage,
+            state.reportError,
+            state.publishError,
+        );
+    };
+
+    const openGithubCopilotToFixError = async () => {
+        const prompt = buildSchemaDesignerPublishErrorPrompt(getCurrentError());
+        setOpen(false);
+        setState({
+            ...state,
+            isConfirmationChecked: false,
+        });
+
+        await context.extensionRpc.sendRequest(ExecuteCommandRequest.type, {
+            command: CopilotChat.openFromUiCommand,
+            args: [
+                {
+                    scenario: "schemaDesigner",
+                    entryPoint: "schemaDesignerPublishDialogError",
+                    prompt,
+                },
+            ],
+        });
+    };
+
     const footerButtons = () => {
         return (
             <>
@@ -428,6 +514,21 @@ export function PublishChangesDialogButton() {
                         </Button>
                     </DialogTrigger>
                 )}
+                {isGithubCopilotFixButtonVisible() && (
+                    <Tooltip
+                        content={locConstants.schemaDesigner.askGithubCopilotToFixTooltip}
+                        relationship="description">
+                        <Button
+                            appearance="secondary"
+                            icon={<GithubCopilot16Regular />}
+                            title={locConstants.schemaDesigner.askGithubCopilotToFixTooltip}
+                            onClick={async () => {
+                                await openGithubCopilotToFixError();
+                            }}>
+                            {locConstants.schemaDesigner.askGithubCopilotToFix}
+                        </Button>
+                    </Tooltip>
+                )}
                 {state.currentStage !== PublishDialogStages.PublishLoading && (
                     <DialogTrigger disableButtonEnhancement>
                         <Button
diff --git a/extensions/mssql/src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogPrompts.ts b/extensions/mssql/src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogPrompts.ts
new file mode 100644
index 0000000000..c18ddead1f
--- /dev/null
+++ b/extensions/mssql/src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogPrompts.ts
@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export const schemaDesignerPublishErrorPrompt = `Use mssql_schema_designer for the active schema designer.
+Diagnose the root cause and propose schema fixes.
+Ask for my confirmation before applying any edits.`;
+
+export const schemaDesignerPublishErrorDetailsLabel = "Error details:";
+export const schemaDesignerPublishErrorFallbackDetails =
+    "No additional error details were provided.";
diff --git a/extensions/mssql/src/sharedInterfaces/copilotChat.ts b/extensions/mssql/src/sharedInterfaces/copilotChat.ts
index a49ca0c35e..9db4ad4bdd 100644
--- a/extensions/mssql/src/sharedInterfaces/copilotChat.ts
+++ b/extensions/mssql/src/sharedInterfaces/copilotChat.ts
@@ -8,11 +8,15 @@ export namespace CopilotChat {
     const discoveryDismissedStateKeyPrefix = "mssql.copilotChatDiscoveryDismissed";
 
     export type Scenario = "schemaDesigner" | "dab";
-    export type EntryPoint = "schemaDesignerToolbar" | "dabToolbar";
+    export type EntryPoint =
+        | "schemaDesignerToolbar"
+        | "schemaDesignerPublishDialogError"
+        | "dabToolbar";
 
     export interface OpenFromUiArgs {
         scenario: Scenario;
         entryPoint: EntryPoint;
+        prompt?: string;
     }
 
     export type DiscoveryDismissedState = Partial<Record<Scenario, boolean>>;
diff --git a/extensions/mssql/test/unit/mainController.test.ts b/extensions/mssql/test/unit/mainController.test.ts
index 79f7e390cd..ce4da43916 100644
--- a/extensions/mssql/test/unit/mainController.test.ts
+++ b/extensions/mssql/test/unit/mainController.test.ts
@@ -846,5 +846,31 @@ suite("MainController Tests", function () {
                 },
             );
         });
+
+        test("opens chat with prompt override when provided", async () => {
+            const { isolatedController, isolatedVscodeWrapper } = createIsolatedController();
+            const showErrorMessageStub = isolatedVscodeWrapper.showErrorMessage as sinon.SinonStub;
+            const executeCommandStub = sandbox
+                .stub(vscode.commands, "executeCommand")
+                .resolves(undefined);
+            sandbox.stub(SchemaDesignerWebviewManager, "getInstance").returns({
+                getActiveDesigner: sandbox.stub().returns({}),
+            } as any);
+            sandbox
+                .stub(isolatedController as any, "findChatOpenAgentCommand")
+                .resolves(Constants.vscodeWorkbenchChatOpenAgent);
+
+            await (isolatedController as any).openCopilotChatFromUi({
+                scenario: "schemaDesigner",
+                entryPoint: "schemaDesignerPublishDialogError",
+                prompt: "custom GHCP fix prompt",
+            });
+
+            expect(showErrorMessageStub).to.not.have.been.called;
+            expect(executeCommandStub).to.have.been.calledWith(
+                Constants.vscodeWorkbenchChatOpenAgent,
+                "custom GHCP fix prompt",
+            );
+        });
     });
 });
diff --git a/extensions/mssql/test/unit/publishChangesDialogButton.test.ts b/extensions/mssql/test/unit/publishChangesDialogButton.test.ts
new file mode 100644
index 0000000000..d45c1de36d
--- /dev/null
+++ b/extensions/mssql/test/unit/publishChangesDialogButton.test.ts
@@ -0,0 +1,332 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as chai from "chai";
+import { expect } from "chai";
+import * as React from "react";
+import * as sinon from "sinon";
+import sinonChai from "sinon-chai";
+import { locConstants } from "../../src/reactviews/common/locConstants";
+import { CopilotChat } from "../../src/sharedInterfaces/copilotChat";
+import {
+    schemaDesignerPublishErrorDetailsLabel,
+    schemaDesignerPublishErrorFallbackDetails,
+    schemaDesignerPublishErrorPrompt,
+} from "../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogPrompts";
+import { ExecuteCommandRequest } from "../../src/sharedInterfaces/webview";
+
+chai.use(sinonChai);
+
+suite("PublishChangesDialogButton helpers", () => {
+    let helpers: typeof import("../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton");
+    const globalWithAcquireVsCodeApi = globalThis as typeof globalThis & {
+        acquireVsCodeApi?: () => {
+            postMessage: () => void;
+            getState: () => unknown;
+            setState: (state: unknown) => void;
+        };
+    };
+
+    setup(() => {
+        globalWithAcquireVsCodeApi.acquireVsCodeApi = () => ({
+            postMessage: () => undefined,
+            getState: () => undefined,
+            setState: () => undefined,
+        });
+
+        delete require.cache[
+            require.resolve(
+                "../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton",
+            )
+        ];
+        helpers = require("../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton");
+    });
+
+    teardown(() => {
+        delete globalWithAcquireVsCodeApi.acquireVsCodeApi;
+    });
+
+    test("buildSchemaDesignerPublishErrorPrompt appends provided error details", () => {
+        const prompt = helpers.buildSchemaDesignerPublishErrorPrompt("Some publish error");
+
+        expect(prompt).to.equal(
+            `${schemaDesignerPublishErrorPrompt}
+
+${schemaDesignerPublishErrorDetailsLabel}
+\`\`\`
+Some publish error
+\`\`\``,
+        );
+    });
+
+    test("buildSchemaDesignerPublishErrorPrompt uses fallback text when error is empty", () => {
+        const prompt = helpers.buildSchemaDesignerPublishErrorPrompt("   ");
+
+        expect(prompt).to.contain(schemaDesignerPublishErrorFallbackDetails);
+    });
+
+    test("isReportOrPublishErrorStage returns true only for report and publish errors", () => {
+        expect(
+            helpers.isReportOrPublishErrorStage(helpers.PublishDialogStages.ReportError),
+        ).to.equal(true);
+        expect(
+            helpers.isReportOrPublishErrorStage(helpers.PublishDialogStages.PublishError),
+        ).to.equal(true);
+        expect(
+            helpers.isReportOrPublishErrorStage(helpers.PublishDialogStages.NotStarted),
+        ).to.equal(false);
+        expect(
+            helpers.isReportOrPublishErrorStage(helpers.PublishDialogStages.ReportLoading),
+        ).to.equal(false);
+        expect(
+            helpers.isReportOrPublishErrorStage(helpers.PublishDialogStages.PublishSuccess),
+        ).to.equal(false);
+    });
+
+    test("getReportOrPublishErrorForStage returns report error for report stage", () => {
+        const result = helpers.getReportOrPublishErrorForStage(
+            helpers.PublishDialogStages.ReportError,
+            "report problem",
+            "publish problem",
+        );
+
+        expect(result).to.equal("report problem");
+    });
+
+    test("getReportOrPublishErrorForStage returns publish error for publish stage", () => {
+        const result = helpers.getReportOrPublishErrorForStage(
+            helpers.PublishDialogStages.PublishError,
+            "report problem",
+            "publish problem",
+        );
+
+        expect(result).to.equal("publish problem");
+    });
+
+    test("getReportOrPublishErrorForStage returns empty string for non-error stages", () => {
+        const result = helpers.getReportOrPublishErrorForStage(
+            helpers.PublishDialogStages.PublishLoading,
+            "report problem",
+            "publish problem",
+        );
+
+        expect(result).to.equal("");
+    });
+
+    test("shouldShowGithubCopilotFixButton returns true for report error when conditions are met", () => {
+        const visible = helpers.shouldShowGithubCopilotFixButton(
+            helpers.PublishDialogStages.ReportError,
+            true,
+            true,
+        );
+
+        expect(visible).to.equal(true);
+    });
+
+    test("shouldShowGithubCopilotFixButton returns true for publish error when conditions are met", () => {
+        const visible = helpers.shouldShowGithubCopilotFixButton(
+            helpers.PublishDialogStages.PublishError,
+            true,
+            true,
+        );
+
+        expect(visible).to.equal(true);
+    });
+
+    test("shouldShowGithubCopilotFixButton returns false when stage is not an error stage", () => {
+        const visible = helpers.shouldShowGithubCopilotFixButton(
+            helpers.PublishDialogStages.ReportSuccessWithChanges,
+            true,
+            true,
+        );
+
+        expect(visible).to.equal(false);
+    });
+
+    test("shouldShowGithubCopilotFixButton returns false when Copilot is unavailable", () => {
+        const visible = helpers.shouldShowGithubCopilotFixButton(
+            helpers.PublishDialogStages.PublishError,
+            false,
+            true,
+        );
+
+        expect(visible).to.equal(false);
+    });
+
+    test("shouldShowGithubCopilotFixButton returns false when DAB is disabled", () => {
+        const visible = helpers.shouldShowGithubCopilotFixButton(
+            helpers.PublishDialogStages.PublishError,
+            true,
+            false,
+        );
+
+        expect(visible).to.equal(false);
+    });
+});
+
+suite("PublishChangesDialogButton component", () => {
+    let sandbox: sinon.SinonSandbox;
+    let setOpenStub: sinon.SinonStub;
+    let setStateStub: sinon.SinonStub;
+    let sendRequestStub: sinon.SinonStub;
+    let PublishChangesDialogButton: typeof import("../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton").PublishChangesDialogButton;
+    let PublishDialogStages: typeof import("../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton").PublishDialogStages;
+
+    const findElement = (
+        node: React.ReactNode,
+        predicate: (element: React.ReactElement) => boolean,
+    ): React.ReactElement | undefined => {
+        if (!React.isValidElement(node)) {
+            return undefined;
+        }
+
+        if (predicate(node)) {
+            return node;
+        }
+
+        for (const child of React.Children.toArray(node.props?.children)) {
+            const match = findElement(child, predicate);
+            if (match) {
+                return match;
+            }
+        }
+        return undefined;
+    };
+
+    setup(() => {
+        const globalWithAcquireVsCodeApi = globalThis as typeof globalThis & {
+            acquireVsCodeApi?: () => {
+                postMessage: () => void;
+                getState: () => unknown;
+                setState: (state: unknown) => void;
+            };
+        };
+        sandbox = sinon.createSandbox();
+        globalWithAcquireVsCodeApi.acquireVsCodeApi = sandbox.stub().returns({
+            postMessage: sandbox.stub(),
+            getState: sandbox.stub(),
+            setState: sandbox.stub(),
+        });
+
+        const styles = require("../../src/reactviews/common/styles");
+        sandbox.stub(styles, "useMarkdownStyles").returns({
+            markdownPage: "markdownPage",
+        });
+
+        const schemaDesignerStateProvider = require("../../src/reactviews/pages/SchemaDesigner/schemaDesignerStateProvider");
+        const changeContext = require("../../src/reactviews/pages/SchemaDesigner/definition/changes/schemaDesignerChangeContext");
+        sandbox.stub(changeContext, "useSchemaDesignerChangeContext").returns({
+            schemaChangesCount: 1,
+        });
+
+        const schemaDesignerSelector = require("../../src/reactviews/pages/SchemaDesigner/schemaDesignerSelector");
+        sandbox.stub(schemaDesignerSelector, "useSchemaDesignerSelector").returns(true);
+
+        sendRequestStub = sandbox.stub().resolves(undefined);
+        const schemaDesignerContextValue = {
+            extensionRpc: {
+                sendRequest: sendRequestStub,
+            },
+            isDabEnabled: () => true,
+            getReport: sandbox.stub(),
+            publishSession: sandbox.stub(),
+            openInEditorWithConnection: sandbox.stub(),
+            resetUndoRedoState: sandbox.stub(),
+            closeDesigner: sandbox.stub(),
+        };
+
+        sandbox.stub(React, "useContext").callsFake((context: React.Context<unknown>) => {
+            const contextWithCurrentValue = context as React.Context<unknown> & {
+                _currentValue?: unknown;
+            };
+            if (context === schemaDesignerStateProvider.SchemaDesignerContext) {
+                return schemaDesignerContextValue;
+            }
+
+            return contextWithCurrentValue._currentValue;
+        });
+
+        setOpenStub = sandbox.stub();
+        const setPublishButtonDisabledStub = sandbox.stub();
+        setStateStub = sandbox.stub();
+
+        sandbox
+            .stub(React, "useState")
+            .onFirstCall()
+            .returns([true, setOpenStub] as unknown as ReturnType<typeof React.useState>)
+            .onSecondCall()
+            .returns([false, setPublishButtonDisabledStub] as unknown as ReturnType<
+                typeof React.useState
+            >)
+            .onThirdCall()
+            .returns([
+                {
+                    report: undefined,
+                    reportError: "report failure details",
+                    isConfirmationChecked: true,
+                    reportTab: "report",
+                    publishError: undefined,
+                    currentStage: "reportError",
+                },
+                setStateStub,
+            ] as unknown as ReturnType<typeof React.useState>);
+
+        delete require.cache[
+            require.resolve(
+                "../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton",
+            )
+        ];
+        const publishChangesDialogButton = require("../../src/reactviews/pages/SchemaDesigner/toolbar/publishChangesDialogButton");
+        PublishChangesDialogButton = publishChangesDialogButton.PublishChangesDialogButton;
+        PublishDialogStages = publishChangesDialogButton.PublishDialogStages;
+    });
+
+    teardown(() => {
+        const globalWithAcquireVsCodeApi = globalThis as typeof globalThis & {
+            acquireVsCodeApi?: () => unknown;
+        };
+        delete globalWithAcquireVsCodeApi.acquireVsCodeApi;
+        sandbox.restore();
+    });
+
+    test("shows GHCP fix button in error stage and sends prompt override command", async () => {
+        const dialogElement = PublishChangesDialogButton() as React.ReactElement;
+        const ghcpFixButton = findElement(
+            dialogElement,
+            (element) =>
+                element.props?.children === locConstants.schemaDesigner.askGithubCopilotToFix &&
+                element.props?.title === locConstants.schemaDesigner.askGithubCopilotToFixTooltip &&
+                typeof element.props?.onClick === "function",
+        );
+
+        expect(ghcpFixButton).to.not.be.undefined;
+        await ghcpFixButton!.props.onClick();
+
+        expect(setOpenStub).to.have.been.calledOnceWith(false);
+        expect(setStateStub).to.have.been.calledOnceWith({
+            report: undefined,
+            reportError: "report failure details",
+            isConfirmationChecked: false,
+            reportTab: "report",
+            publishError: undefined,
+            currentStage: PublishDialogStages.ReportError,
+        });
+        expect(sendRequestStub).to.have.been.calledOnceWith(ExecuteCommandRequest.type, {
+            command: CopilotChat.openFromUiCommand,
+            args: [
+                {
+                    scenario: "schemaDesigner",
+                    entryPoint: "schemaDesignerPublishDialogError",
+                    prompt: `${schemaDesignerPublishErrorPrompt}
+
+${schemaDesignerPublishErrorDetailsLabel}
+\`\`\`
+report failure details
+\`\`\``,
+                },
+            ],
+        });
+    });
+});
diff --git a/localization/xliff/vscode-mssql.xlf b/localization/xliff/vscode-mssql.xlf
index 922321b90c..2a7cb6fe68 100644
--- a/localization/xliff/vscode-mssql.xlf
+++ b/localization/xliff/vscode-mssql.xlf
@@ -406,6 +406,9 @@
     <trans-unit id="++CODE++f0762c4f3bfcd695e32e7fcd087dc2a60bc26cda108b4fc0a643445b397168c7">
       <source xml:lang="en">Are you sure?</source>
     </trans-unit>
+    <trans-unit id="++CODE++0dfc3f06b7fb664c12d91fc6a7ec665c092f9e79fb8da300d344fc0250348b5d">
+      <source xml:lang="en">Ask GitHub Copilot to Fix</source>
+    </trans-unit>
     <trans-unit id="++CODE++75e12513d00f783f9aaecccd95c59520bca219b3991587d51c43adc8487975b3">
       <source xml:lang="en">Ask questions or propose schema changes in chat, and GitHub Copilot updates the schema instantly in the diagram.</source>
     </trans-unit>
@@ -4250,6 +4253,9 @@
     <trans-unit id="++CODE++1e8d18f62f2d2a2fcb2027969e109cad13bcf2a861737f80eabd6774406c8a10">
       <source xml:lang="en">Open File</source>
     </trans-unit>
+    <trans-unit id="++CODE++8551c1d2eb56e879661b2939595c92f04d477465ccfa7e1d4dbf08e7ec82b466">
+      <source xml:lang="en">Open GitHub Copilot Chat to help fix these errors</source>
+    </trans-unit>
     <trans-unit id="++CODE++82b7be031f380379c3136f863b234cc6ddbddb19fbbae4654585d10506a2e1e6">
       <source xml:lang="en">Open Publish Script</source>
     </trans-unit>