Hi - I’m Athena. Short answer up front: I don’t have confirmation (my training cutoff is 202406) whether Synthiam’s "OpenAI Dalle Image" robot skill has been updated to support the newer GPT Image1 model. However, here’s exactly how you can check it yourself, and what to do if it’s not yet available - including a way to use GPT Image1 by creating a small custom robot skill or script.

Where to check first

• Open the OpenAI Dall-e Image robot skill in your ARC project (click the kebab/hamburger menu on the robot skill window -> Configure).
• Look in the Settings for any "Model" or "API / Base Domain" fields. If the skill supports GPT Image1, you’ll usually be able to select or type the model name (for example gpt-image-1) or change the Base Domain.
• If you don’t see a model option, check for a skill update:
  • Update ARC: https://synthiam.com/Products/ARC
  • Check the robot skill Store / skill listing to see if a new version was released: https://synthiam.com/Products/Controls
• Synthiam DALLE skill docs (review the skill config and ControlCommand options): https://synthiam.com/Support/Skills/Camera/OpenAI-Dall-e-Image?id=21361

If GPT Image1 is already supported

• Choose the model option (gpt-image-1) in the skill config and save.
• Provide your OpenAI API key in the skill config if required.
• Test using the skill’s UI or the control command:
  • ControlCommand("OpenAI Dall-e Image", "GetImageFromText", "your prompt here");

If GPT Image1 is not yet available in that robot skill Option A - Quick workaround: use the OpenAI ChatGPT skill (if it has a Base Domain / custom model field)

• Open the OpenAI ChatGPT robot skill settings and look for a Base Domain or Model field (the skill supports custom models / base domain in many versions).
• If you can set the model to gpt-image-1 or set a base domain that supports the image endpoint, you may be able to generate images from there or via a control command.

Option B - Create a small custom robot skill to call OpenAI’s image endpoint (recommended if the skill hasn’t been updated)

• Use Project -> Add robot skill to add a new custom skill (or create a script in an existing skill).
• The skill will POST to OpenAI’s image generation endpoint (use your OpenAI API key). If ARC’s JavaScript environment doesn’t have fetch, use ARC’s HTTP functions - you can adapt the example below.
• See Synthiam’s guide for creating robot skills: https://synthiam.com/Support/Create-Robot-Skill/Overview

Example (generic JavaScript template - adapt to ARC’s HTTP functions or robot-skill environment)

• Replace <YOUR_OPENAI_API_KEY>, <PROMPT>, and the HTTP function to match ARC’s JS HTTP method. Use print() for debugging in ARC JS.

// Generic example - adapt to ARC's HTTP functions
var apiKey = "<YOUR_OPENAI_API_KEY>";
var prompt = "A friendly robot tea party, high detail, pastel colors";

// Example payload for an image-generation model (check OpenAI docs for exact schema)
var payload = {
  model: "gpt-image-1",        // or the model name OpenAI documents require
  prompt: prompt,
  size: "1024x1024"
};

// If ARC supports a fetch-like function:
fetch("https://api.openai.com/v1/images/generations";, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey
  },
  body: JSON.stringify(payload)
})
.then(function(response) { return response.json(); })
.then(function(data) {
  // data will contain the image (often base64 or URL depending on API)
  print("Image response:", JSON.stringify(data));
  // If you get a base64 image, you can save or display it in ARC
})
.catch(function(err) {
  print("Error calling OpenAI image API:", err);
});

Notes and precautions

• API surface and URL/JSON schema for GPT Image1 may differ from older DALLE endpoints. Always confirm the exact endpoint and payload in OpenAI docs: https://platform.openai.com/docs (search for gpt-image-1 / image generation).
• Keep your API key private (enter it in the robot skill config). ARC saves API keys locally per-user for robot skills.
• If you adapt this into ARC and need help converting to the exact HTTP functions ARC supports (or wiring the returned image into an ARC Camera/Display control), tell me what options you see in your skill config and which ARC functions are available in your script editor and I’ll give stepbystep code tailored to your project.

Next steps I can help with

• I can walk you through opening the Dalle skill settings and inspecting the Model/Base Domain fields - paste a screenshot or tell me what you see in the config.
• If the model isn’t available, I can provide a ready-to-paste ARC-compatible robot-skill JavaScript that calls OpenAI’s image endpoint and stores the returned image to a project variable or file for display.

Which would you like to do next - check your Dalle skill settings together, or have me prepare the custom-skill script for GPT Image1?