@wictorwilen/cocogen 1.1.0-preview.10 → 1.1.0-preview.11

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.0-preview.11] - 2026-04-09
+
+### Changed
+- Generated TypeScript and .NET connector CLIs now support `--retry-attempts` (default `2`, max `10`) for ingestion; failed items are queued and retried after the initial batch pass completes, with retry-round backoff and final failed-item summaries.
+
 ## [1.1.0-preview.10] - 2026-04-08
 
 ## [1.1.0-preview.9] - 2026-04-08
@@ -378,6 +383,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Collection values no longer split on commas; use semicolons instead.
 
 [Unreleased]: https://github.com/wictorwilen/cocogen/compare/v1.0.16...HEAD
+[1.1.0-preview.11]: https://github.com/wictorwilen/cocogen/compare/main...v1.1.0-preview.11
 [1.1.0-preview.10]: https://github.com/wictorwilen/cocogen/compare/main...v1.1.0-preview.10
 [1.1.0-preview.9]: https://github.com/wictorwilen/cocogen/compare/main...v1.1.0-preview.9
 [1.1.0-preview.8]: https://github.com/wictorwilen/cocogen/compare/main...v1.1.0-preview.8

package/data/graph-external-connectors-principal.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-04-08T13:09:48.617Z",
+  "generatedAt": "2026-04-09T08:52:20.160Z",
   "graphVersion": "v1.0",
   "sourceUrl": "https://graph.microsoft.com/v1.0/$metadata",
   "namespace": "microsoft.graph.externalConnectors",

package/dist/init/templates/dotnet/Core/ConnectorCore.cs.ejs

@@ -269,43 +269,54 @@ public sealed class ConnectorCore<TItem>
     /// <summary>
     /// Ingest items from a datasource.
     /// </summary>
-    public async Task IngestAsync(IItemSource<TItem> source, bool dryRun, int? limit, int batchSize, bool verbose, bool failFast)
+    public async Task IngestAsync(IItemSource<TItem> source, bool dryRun, int? limit, int batchSize, int retryAttempts, bool verbose, bool failFast)
     {
         if (batchSize < 1 || batchSize > 20)
             throw new InvalidOperationException("Invalid batch size: expected integer between 1 and 20.");
+        if (retryAttempts < 0 || retryAttempts > MaxItemRetryAttempts)
+            throw new InvalidOperationException($"Invalid retry attempts: expected integer between 0 and {MaxItemRetryAttempts}.");
+
+        var retryQueueDelayAttempts = Math.Max(0, retryAttempts);
 
         var count = 0;
         var successCount = 0;
-        var failures = new List<(int Index, string Id, string Message)>();
-        var pending = new List<(int Index, string Id, TItem Item)>();
+        var failures = new List<(int Index, string Id, int Attempts, string Message)>();
+        var pending = new List<(int Index, string Id, TItem Item, int Attempt)>();
+        var retryQueue = new List<(int Index, string Id, TItem Item, int Attempt)>();
 
-        async Task<(int Index, string Id, bool Success, string Message, Exception? Error)> ProcessPendingItemAsync(
-            (int Index, string Id, TItem Item) pendingItem)
+        async Task<(int Index, string Id, int Attempt, bool Success, string Message, Exception? Error, TItem Item)> ProcessPendingItemAsync(
+            (int Index, string Id, TItem Item, int Attempt) pendingItem)
         {
             try
             {
                 await PutItemAsync(pendingItem.Item, verbose);
-                return (pendingItem.Index, pendingItem.Id, true, string.Empty, null);
+                return (pendingItem.Index, pendingItem.Id, pendingItem.Attempt, true, string.Empty, null, pendingItem.Item);
             }
             catch (Exception ex)
             {
-                return (pendingItem.Index, pendingItem.Id, false, ex.Message, ex);
+                return (pendingItem.Index, pendingItem.Id, pendingItem.Attempt, false, ex.Message, ex, pendingItem.Item);
             }
         }
 
-        async Task FlushBatchAsync()
+        async Task FlushBatchAsync(IReadOnlyList<(int Index, string Id, TItem Item, int Attempt)> batch)
         {
-            if (pending.Count == 0)
+            if (batch.Count == 0)
                 return;
 
-            var tasks = new List<Task<(int Index, string Id, bool Success, string Message, Exception? Error)>>();
-            foreach (var pendingItem in pending)
+            var tasks = new List<Task<(int Index, string Id, int Attempt, bool Success, string Message, Exception? Error, TItem Item)>>();
+            foreach (var pendingItem in batch)
             {
-                Console.WriteLine($"info: ingesting item {pendingItem.Index} (id={pendingItem.Id})");
+                if (pendingItem.Attempt == 0)
+                {
+                    Console.WriteLine($"info: ingesting item {pendingItem.Index} (id={pendingItem.Id})");
+                }
+                else
+                {
+                    Console.WriteLine($"info: retrying item {pendingItem.Index} (id={pendingItem.Id}) attempt {pendingItem.Attempt}/{retryAttempts}");
+                }
                 tasks.Add(ProcessPendingItemAsync(pendingItem));
             }
 
-            pending.Clear();
             var results = await Task.WhenAll(tasks);
             Exception? firstError = null;
 
@@ -319,7 +330,13 @@ public sealed class ConnectorCore<TItem>
                 }
 
                 Console.Error.WriteLine($"error: failed item {result.Index} (id={result.Id})");
-                failures.Add((result.Index, result.Id, result.Message));
+                if (!failFast && result.Attempt < retryAttempts)
+                {
+                    retryQueue.Add((result.Index, result.Id, result.Item, result.Attempt + 1));
+                    continue;
+                }
+
+                failures.Add((result.Index, result.Id, result.Attempt + 1, result.Message));
                 if (failFast && firstError is null)
                 {
                     firstError = result.Error;
@@ -340,9 +357,13 @@ public sealed class ConnectorCore<TItem>
 
             if (!dryRun)
             {
-                pending.Add((index, itemId, item));
+                pending.Add((index, itemId, item, 0));
                 if (pending.Count >= batchSize)
-                    await FlushBatchAsync();
+                {
+                    var batch = pending.ToArray();
+                    pending.Clear();
+                    await FlushBatchAsync(batch);
+                }
             }
             else if (verbose)
             {
@@ -354,7 +375,46 @@ public sealed class ConnectorCore<TItem>
         }
 
         if (!dryRun)
-            await FlushBatchAsync();
+        {
+            var batch = pending.ToArray();
+            pending.Clear();
+            await FlushBatchAsync(batch);
+
+            for (var retryAttempt = 1; retryAttempt <= retryAttempts && retryQueue.Count > 0; retryAttempt++)
+            {
+                var queue = retryQueue.ToArray();
+                retryQueue.Clear();
+                Console.WriteLine($"warn: retry pass {retryAttempt}/{retryAttempts} for {queue.Length} item(s)");
+
+                for (var offset = 0; offset < queue.Length; offset += batchSize)
+                {
+                    var length = Math.Min(batchSize, queue.Length - offset);
+                    var chunk = new (int Index, string Id, TItem Item, int Attempt)[length];
+                    Array.Copy(queue, offset, chunk, 0, length);
+                    await FlushBatchAsync(chunk);
+                }
+
+                if (retryQueue.Count > 0 && retryAttempt < retryQueueDelayAttempts)
+                {
+                    var delay = ComputeDelayMs(retryAttempt - 1, (int?)null);
+                    Console.WriteLine($"warn: waiting {delay}ms before next retry pass");
+                    await Task.Delay(delay);
+                }
+            }
+
+            if (retryQueue.Count > 0)
+            {
+                foreach (var item in retryQueue)
+                {
+                    failures.Add((
+                        item.Index,
+                        item.Id,
+                        item.Attempt,
+                        $"exhausted retry queue after {item.Attempt} attempt(s)"
+                    ));
+                }
+            }
+        }
 
         if (!dryRun)
         {
@@ -370,7 +430,7 @@ public sealed class ConnectorCore<TItem>
             Console.WriteLine($"warn: {failures.Count} item(s) failed");
             foreach (var failure in failures)
             {
-                Console.WriteLine($"warn: failed item {failure.Index} (id={failure.Id}) - {failure.Message}");
+                Console.WriteLine($"warn: failed item {failure.Index} (id={failure.Id}) after {failure.Attempts} attempt(s) - {failure.Message}");
             }
         }
     }
@@ -643,6 +703,7 @@ public sealed class ConnectorCore<TItem>
     private const int MaxRetries = 6;
     private const int BaseDelayMs = 1000;
     private const int MaxDelayMs = 30000;
+    private const int MaxItemRetryAttempts = 10;
 
 <% if (isPeopleConnector) { -%>
     /// <summary>

package/dist/init/templates/dotnet/Program.commandline.cs.ejs

@@ -92,6 +92,14 @@ int ValidateBatchSize(int? batchSize)
         throw new InvalidOperationException("Invalid --batch-size: expected an integer between 1 and 20.");
     return batchSize.Value;
 }
+
+int ValidateRetryAttempts(int? retryAttempts)
+{
+    retryAttempts ??= 2;
+    if (retryAttempts < 0 || retryAttempts > 10)
+        throw new InvalidOperationException("Invalid --retry-attempts: expected an integer between 0 and 10.");
+    return retryAttempts.Value;
+}
 <% if (inputFormat === "rest") { -%>
 string RestBaseUrl(string? inputPath)
 {
@@ -182,9 +190,10 @@ async Task ProvisionAsync()
 /// <summary>
 /// Ingest items from the configured input.
 /// </summary>
-async Task IngestAsync(string? inputPath, bool dryRun, int? limit, int? batchSize, bool verbose, bool failFast)
+async Task IngestAsync(string? inputPath, bool dryRun, int? limit, int? batchSize, int? retryAttempts, bool verbose, bool failFast)
 {
     var validatedBatchSize = ValidateBatchSize(batchSize);
+    var validatedRetryAttempts = ValidateRetryAttempts(retryAttempts);
 
     GraphServiceClient? graph = null;
     TokenCredential? credential = null;
@@ -209,7 +218,7 @@ async Task IngestAsync(string? inputPath, bool dryRun, int? limit, int? batchSiz
 <% } -%>
     var core = BuildConnectorCore(graph, credential, connectionId);
 
-    await core.IngestAsync(source, dryRun, limit, validatedBatchSize, verbose, failFast);
+    await core.IngestAsync(source, dryRun, limit, validatedBatchSize, validatedRetryAttempts, verbose, failFast);
 }
 
 /// <summary>
@@ -231,6 +240,7 @@ var dryRunOption = new Option<bool>("--dry-run") { Description = "Build payloads
 var failFastOption = new Option<bool>("--fail-fast") { Description = "Abort on the first item failure" };
 var limitOption = new Option<int?>("--limit") { Description = "Limit number of items" };
 var batchSizeOption = new Option<int?>("--batch-size") { Description = "Number of concurrent PUT requests to send per batch (1-20)" };
+var retryAttemptsOption = new Option<int?>("--retry-attempts") { Description = "Retry failed items after initial pass (0-10, default 2)" };
 var verboseOption = new Option<bool>("--verbose") { Description = "Print payloads sent to Graph" };
 
 var root = new RootCommand("Connector CLI generated by cocogen");
@@ -245,6 +255,7 @@ ingestCommand.Options.Add(dryRunOption);
 ingestCommand.Options.Add(failFastOption);
 ingestCommand.Options.Add(limitOption);
 ingestCommand.Options.Add(batchSizeOption);
+ingestCommand.Options.Add(retryAttemptsOption);
 ingestCommand.Options.Add(verboseOption);
 ingestCommand.SetAction(async (parseResult, cancellationToken) =>
 {
@@ -253,8 +264,9 @@ ingestCommand.SetAction(async (parseResult, cancellationToken) =>
     var failFast = parseResult.GetValue(failFastOption);
     var limit = parseResult.GetValue(limitOption);
     var batchSize = parseResult.GetValue(batchSizeOption);
+    var retryAttempts = parseResult.GetValue(retryAttemptsOption);
     var verbose = parseResult.GetValue(verboseOption);
-    await IngestAsync(input, dryRun, limit, batchSize, verbose, failFast);
+    await IngestAsync(input, dryRun, limit, batchSize, retryAttempts, verbose, failFast);
 });
 
 var deleteCommand = new Command("delete", "Delete the connection");

package/dist/init/templates/dotnet/README.md.ejs

@@ -73,6 +73,7 @@ Use `dotnet run -- ingest` with:
 - `--fail-fast` (abort on the first item failure)
 - `--limit <n>` (ingest only N items)
 - `--batch-size <n>` (send up to N concurrent PUT requests per batch, default `1`, max `20`)
+- `--retry-attempts <n>` (queue failed items and retry after the initial pass, default `2`, max `10`)
 - `--verbose` (print the exact payload sent to Graph)
 
 Note: `--dry-run` does not require Azure AD or connection settings.

package/dist/init/templates/ts/README.md.ejs

@@ -62,6 +62,7 @@ Use `npm run ingest --` with:
 - `--fail-fast` (abort on the first item failure)
 - `--limit <n>` (ingest only N items)
 - `--batch-size <n>` (send up to N concurrent PUT requests per batch, default `1`, max `20`)
+- `--retry-attempts <n>` (queue failed items and retry after the initial pass, default `2`, max `10`)
 - `--verbose` (print the exact payload sent to Graph)
 
 Note: `--dry-run` does not require CONNECTION_ID, but you still need it for real ingestion.

package/dist/init/templates/ts/src/cli.ts.ejs

@@ -118,6 +118,14 @@ function parseBatchSize(value: string): number {
   return parsed;
 }
 
+function parseRetryAttempts(value: string): number {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 10) {
+    throw new InvalidArgumentError("expected an integer between 0 and 10");
+  }
+  return parsed;
+}
+
 function buildItemSource(path: string): ItemSource<<%= itemTypeName %>> {
 <% if (inputFormat === "rest") { -%>
   return new RestItemSource(resolveRestOptions(path));
@@ -224,6 +232,7 @@ async function ingest(options: {
   dryRun?: boolean;
   limit?: number;
   batchSize?: number;
+  retryAttempts?: number;
   verbose?: boolean;
   failFast?: boolean;
 }): Promise<void> {
@@ -237,6 +246,7 @@ async function ingest(options: {
     dryRun: options.dryRun,
     limit: options.limit,
     batchSize: options.batchSize,
+    retryAttempts: options.retryAttempts,
     verbose: options.verbose,
     failFast: options.failFast,
     toExternalItem
@@ -259,14 +269,16 @@ program
   .option("--fail-fast", "Abort on the first item failure")
   .option("--limit <n>", "Limit number of items", (value) => Number(value))
   .option("--batch-size <n>", "Number of concurrent PUT requests to send per batch (1-20)", parseBatchSize, 1)
+  .option("--retry-attempts <n>", "Retry failed items after initial pass (0-10, default 2)", parseRetryAttempts, 2)
   .option("--verbose", "Print payloads sent to Graph")
-  .action((options: { input?: string; dryRun?: boolean; limit?: number; batchSize?: number; verbose?: boolean; failFast?: boolean }) =>
+  .action((options: { input?: string; dryRun?: boolean; limit?: number; batchSize?: number; retryAttempts?: number; verbose?: boolean; failFast?: boolean }) =>
     ingest({
       inputPath: options.input,
       dryRun: options.dryRun,
       failFast: options.failFast,
       limit: options.limit,
       batchSize: options.batchSize,
+      retryAttempts: options.retryAttempts,
       verbose: options.verbose,
     })
   );

package/dist/init/templates/ts/src/core/connectorCore.ts.ejs

@@ -41,6 +41,7 @@ export type IngestOptions<Item> = {
   dryRun?: boolean;
   limit?: number;
   batchSize?: number;
+  retryAttempts?: number;
   verbose?: boolean;
   failFast?: boolean;
   toExternalItem: (item: Item) => unknown;
@@ -229,24 +230,34 @@ export class ConnectorCore<Item> {
     if (!Number.isInteger(batchSize) || batchSize < 1 || batchSize > 20) {
       throw new Error("Invalid batch size: expected integer between 1 and 20.");
     }
+    const retryAttempts = options.retryAttempts ?? DEFAULT_ITEM_RETRY_ATTEMPTS;
+    if (!Number.isInteger(retryAttempts) || retryAttempts < 0 || retryAttempts > MAX_ITEM_RETRY_ATTEMPTS) {
+      throw new Error(`Invalid retry attempts: expected integer between 0 and ${MAX_ITEM_RETRY_ATTEMPTS}.`);
+    }
+
+    type PendingItem = { index: number; id: string; item: Item; attempt: number };
 
     let count = 0;
     let successCount = 0;
-    const failures: Array<{ index: number; id: string; message: string }> = [];
-    const pending: Array<{ index: number; id: string; item: Item }> = [];
+    const failures: Array<{ index: number; id: string; attempts: number; message: string }> = [];
+    const pending: PendingItem[] = [];
+    let retryQueue: PendingItem[] = [];
 
-    const flushBatch = async (): Promise<void> => {
-      if (pending.length === 0) {
+    const flushBatch = async (batch: PendingItem[]): Promise<void> => {
+      if (batch.length === 0) {
         return;
       }
 
-      for (const entry of pending) {
-        console.log(`info: ingesting item ${entry.index} (id=${entry.id})`);
+      for (const entry of batch) {
+        if (entry.attempt === 0) {
+          console.log(`info: ingesting item ${entry.index} (id=${entry.id})`);
+          continue;
+        }
+        console.log(`info: retrying item ${entry.index} (id=${entry.id}) attempt ${entry.attempt}/${retryAttempts}`);
       }
 
-      const currentBatch = pending.splice(0, pending.length);
       const results = await Promise.all(
-        currentBatch.map(async (entry) => {
+        batch.map(async (entry) => {
           try {
             await this.putItem(options.connectionId, entry.item, Boolean(options.verbose));
             return { ...entry, success: true as const };
@@ -266,7 +277,13 @@ export class ConnectorCore<Item> {
 
         const message = result.error instanceof Error ? result.error.message : String(result.error);
         console.error(`error: failed item ${result.index} (id=${result.id})`);
-        failures.push({ index: result.index, id: result.id, message });
+
+        if (!options.failFast && result.attempt < retryAttempts) {
+          retryQueue.push({ index: result.index, id: result.id, item: result.item, attempt: result.attempt + 1 });
+          continue;
+        }
+
+        failures.push({ index: result.index, id: result.id, attempts: result.attempt + 1, message });
         if (options.failFast && firstError === null) {
           firstError = result.error;
         }
@@ -282,9 +299,10 @@ export class ConnectorCore<Item> {
       const index = count + 1;
       const itemId = this.getItemId(item as Item);
       if (!options.dryRun) {
-        pending.push({ index, id: itemId, item: item as Item });
+        pending.push({ index, id: itemId, item: item as Item, attempt: 0 });
         if (pending.length >= batchSize) {
-          await flushBatch();
+          const batch = pending.splice(0, pending.length);
+          await flushBatch(batch);
         }
       } else if (options.verbose) {
         const payload = options.toExternalItem(item as Item) as any;
@@ -299,7 +317,36 @@ export class ConnectorCore<Item> {
     }
 
     if (!options.dryRun) {
-      await flushBatch();
+      const batch = pending.splice(0, pending.length);
+      await flushBatch(batch);
+
+      for (let retryAttempt = 1; retryAttempt <= retryAttempts && retryQueue.length > 0; retryAttempt++) {
+        const queue = retryQueue;
+        retryQueue = [];
+        console.warn(`warn: retry pass ${retryAttempt}/${retryAttempts} for ${queue.length} item(s)`);
+
+        for (let index = 0; index < queue.length; index += batchSize) {
+          const batchSlice = queue.slice(index, index + batchSize);
+          await flushBatch(batchSlice);
+        }
+
+        if (retryQueue.length > 0 && retryAttempt < retryAttempts) {
+          const delayMs = computeRetryDelayMs(retryAttempt - 1);
+          console.warn(`warn: waiting ${delayMs}ms before next retry pass`);
+          await sleep(delayMs);
+        }
+      }
+
+      if (retryQueue.length > 0) {
+        for (const entry of retryQueue) {
+          failures.push({
+            index: entry.index,
+            id: entry.id,
+            attempts: entry.attempt,
+            message: `exhausted retry queue after ${entry.attempt} attempt(s)`,
+          });
+        }
+      }
     }
 
     if (!options.dryRun) {
@@ -311,7 +358,7 @@ export class ConnectorCore<Item> {
     if (failures.length > 0) {
       console.warn(`warn: ${failures.length} item(s) failed`);
       for (const failure of failures) {
-        console.warn(`warn: failed item ${failure.index} (id=${failure.id}) - ${failure.message}`);
+        console.warn(`warn: failed item ${failure.index} (id=${failure.id}) after ${failure.attempts} attempt(s) - ${failure.message}`);
       }
     }
   }
@@ -518,6 +565,8 @@ const SCHEMA_POLL_DELAY_MS = 30000;
 const MAX_RETRIES = 6;
 const BASE_RETRY_DELAY_MS = 1000;
 const MAX_RETRY_DELAY_MS = 30000;
+const DEFAULT_ITEM_RETRY_ATTEMPTS = 2;
+const MAX_ITEM_RETRY_ATTEMPTS = 10;
 const SCHEMA_READY_STATES = new Set(["completed", "ready", "succeeded", "success"]);
 const SCHEMA_PENDING_STATES = new Set(["inprogress", "pending", "running", "updating"]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wictorwilen/cocogen",
-  "version": "1.1.0-preview.10",
+  "version": "1.1.0-preview.11",
   "description": "TypeSpec-driven Microsoft Copilot connector generator",
   "license": "MIT",
   "author": "Wictor Wilén <wictor@wictorwilen.se>",